This lab is only losely based on Chapter 8 on human interface devices in the text book. The focus here is on being able to control the on-screen character with a specialized game interface device.

Discussion thread for this lab is here: Lab 4 Discussion Thread

The primary goal of this lab is to hook a joypad game input device up to your Ogre application and use it to control both the character and the camera. This is also an opportunity to see how you set up buffered input (previously you've been using unbuffered input in this application).

No special preparation is required - preparing the joypad is explained in the project steps below.

Follow these steps to complete the lab project:

1. Create a New Project Create a new empty project called “Lab4” in the same way you have created new projectsfor other lab projects.
2. Move Character with Arrow Keys In the hand-out from Lab 1 you should now complete the then optional step 10: Controlling the model with the arrow keys. NOTE: Be aware that you have already made some changes to your code since Lab 1, you need to preserve those. For example, continue to pass your ogre entity into the MyFrameListener constructor, even if you now also have to pass your ogre node into the same constructor.
3. Adding Animation Continue with the hand-out from Lab 1 and now complete the then optional step 11: Adding Animation. Again make sure you preserve your prior code.
4. Plug in and Test Joypad Plug a USB joypad into your computer and find the device in your system's control panel (usually under “Devices and Printers”). Examine the device properties and find a small test panel for the device. Make sure the device works. Intall necessary drivers if the system is not picking it up.
5. Initialize Joystick Input Your MyFrameListener class needs to receive callbacks from the joystick device and therefore has to inherit joystick callback methods from an abstract class called OIS::JoyStickListener. Luckily you can inherit from multiple classes! Change your declaration of your MyFrameListener into this:

   class MyFrameListener : public Ogre::FrameListener, public OIS::JoyStickListener { 

   You then have to provide implementations of a few abstract callback methods:

   	bool axisMoved( const OIS::JoyStickEvent &e, int axis ) {
   		return true;
   	}
   	
   	bool buttonPressed( const OIS::JoyStickEvent &arg, int button ) {
   		return true;
   	};
   
   	bool buttonReleased( const OIS::JoyStickEvent &arg, int button ) {
   	        return true;
   	};
   
   	bool povMoved( const OIS::JoyStickEvent &arg, int pov ) {
   	        return true;
   	};

   In this class you need a new member variable to hold a pointer to a new joystick input object (e.g. OIS::JoyStick* _Joystick;) and then you have to create this object in your constructor. Because it is not guaranteed that the joypad is connected, you need to catch a possible exception upon creation and let the application gracefully continue even if the creation fails:

   		try {
   			_Joystick = static_cast<OIS::JoyStick*>(_InputManager->createInputObject( OIS::OISJoyStick, true ));
   			_Joystick->setEventCallback(this);
   			std::cout << "Successfuly created Joystick";
   		}
   		catch(...) {
   			std::cout << "Failed to initialize Joystick";
   			_Joystick = 0;
   		}

   Don't forget to also destroy the joystick object in your destructor, just like you do with the mouse and keyboard. Make sure this code compiles and check to see if your joypad gets properly initialized.

6. Move Character with POV Now you want to give players the option to move the character by pressing one of the directions on the POV (point of view) digital button on the left of the joypad. You should still retain the keyboard control of the movement. First explore the values you get when you press the POV button. Do that by adding the following two lines to the povMoved callback:

   		int direction = arg.state.mPOV[pov].direction;
   		std::cout << direction << "\n";

   Notice that you get special codes for each direction and the code 0 when you let go of the button (it goes back into center position). Unlike the keyboard, you don't get continuous events when you press and hold the directions! To use this for moving the character you need to store the last direction code received and reset it when you receive 0. In the same callback (below the two lines above), add the following code:

   		_WalkingNorth = false;
   		_WalkingSouth = false;
   		_WalkingEast = false;
   		_WalkingWest = false;
   		switch(direction) {
   			case OIS::Pov::North:
   				_WalkingSouth = true;
   			break;
   			case OIS::Pov::South:
   				_WalkingNorth = true;		
   				break;
   			case OIS::Pov::East:
   				_WalkingWest = true;
   			break;
   			case OIS::Pov::West:
   				_WalkingEast = true;
   			break;
   			case OIS::Pov::Centered:
   			break;
   		}

   Make sure also to declare each of the bool variables as member variables in your class! This is a bit verbose here for clarity, but you can also pack these bits into a single byte to save space and use bit masking. Notice that the POV directions don't necessarily map correctly onto the directions in our world. Finally, you can now use these booleans just like the keyboard button presses for moving the character in your class's frameStarted method. In fact, you can use the OR operator to check to see if a keyboard direction was pressed OR the corresponding walking direction is true, for example:

                   if(_Keyboard->isKeyDown(OIS::KC_UP) || _WalkingNorth) { ... }

Upload your commented source files into Lab4 in MySchool (zip them up if more than one). The lab projects will not be graded, but their completion counts towards your participation grade.