source: GTP/trunk/App/Demos/Illum/IBRBillboardCloudTrees/OGRE/IBRTreesOGRE/include/ExtendedCamera.h @ 1493

// Generic Character class
class Character {
// Attributes ------------------------------------------------------------------------------
        protected:
                SceneNode *mMainNode; // Main character node
                SceneNode *mSightNode; // "Sight" node - The character is supposed to be looking here
                SceneNode *mCameraNode; // Node for the chase camera
                Entity *mEntity; // Character entity
                SceneManager *mSceneMgr;
        public:
// Methods ---------------------------------------------------------------------------------
        protected:
        public:
                // Updates the character (movement...)
                virtual void update (Real elapsedTime, InputReader *input) = 0;
                // The three methods below returns the two camera-related nodes, 
                // and the current position of the character (for the 1st person camera)
                SceneNode *getSightNode () {
                        return mSightNode;
                }
                SceneNode *getCameraNode () {
                        return mCameraNode;
                }
                Vector3 getWorldPosition () {
                        return mMainNode->getWorldPosition ();
                }

                Entity* getEntity()
                {
                        return mEntity;
                }
};

// Specialization of the Character class - Our dear Ogre :D
class OgreCharacter : public Character {
// Attributes ------------------------------------------------------------------------------
        protected:
                String mName;
        public:
// Methods ---------------------------------------------------------------------------------
        protected:
        public:
                OgreCharacter (String name, SceneManager *sceneMgr) {
                        // Setup basic member references
                        mName = name;
                        mSceneMgr = sceneMgr;

                        // Setup basic node structure to handle 3rd person cameras
                        mMainNode = mSceneMgr->getRootSceneNode ()->createChildSceneNode (mName);
                        mSightNode = mMainNode->createChildSceneNode (mName + "_sight", Vector3 (0, 0, 100));
                        mCameraNode = mMainNode->createChildSceneNode (mName + "_camera", Vector3 (0, 50, -100));
                        

                        // Give this character a shape :)
                        mEntity = mSceneMgr->createEntity (mName, "butterfly_bones_animated.mesh");
                        mMainNode->attachObject(mEntity);
                        
                }
                ~OgreCharacter () {
                        mMainNode->detachAllObjects ();
                        delete mEntity;
                        mMainNode->removeAndDestroyAllChildren ();
                        mSceneMgr->destroySceneNode (mName);
                }

                void update (Real elapsedTime, InputReader *input) {
                        // Handle movement
                        if (input->isKeyDown (KC_W)) {
                                mMainNode->translate (mMainNode->getOrientation () * Vector3 (0, 0, 100.0 * elapsedTime));
                        }

                        if (input->isKeyDown (KC_S)) {
                                mMainNode->translate (mMainNode->getOrientation () * Vector3 (0, 0, -50.0 * elapsedTime));
                        }

                        if (input->isKeyDown (KC_PGUP)) {
                                mMainNode->translate (mMainNode->getOrientation () * Vector3 (0, 50 * elapsedTime, 0));
                        }

                        if (input->isKeyDown (KC_PGDOWN)) {
                                mMainNode->translate (mMainNode->getOrientation () * Vector3 (0, -50 * elapsedTime, 0));
                        }

                        if (input->isKeyDown (KC_A)) {
                                mMainNode->yaw (Radian (2 * elapsedTime));
                        }
                        if (input->isKeyDown (KC_D)) {
                                mMainNode->yaw (Radian (-2 * elapsedTime));
                        }

                        Degree mRotX = Degree(-input->getMouseRelativeX() * 0.13);
                        Degree mRotY = Degree(-input->getMouseRelativeY() * 0.13);
                        mMainNode->yaw(mRotX);
                        mMainNode->pitch(mRotY);
                }

                // Change visibility - Useful for 1st person view ;)
                void setVisible (bool visible) {
                        mMainNode->setVisible (visible);
                }
};

// Our extended camera class
class ExtendedCamera {
// Attributes ------------------------------------------------------------------------------
        protected:
                SceneNode *mTargetNode; // The camera target
                SceneNode *mCameraNode; // The camera itself
                Camera *mCamera; // Ogre camera

                SceneManager *mSceneMgr;
                String mName;

                bool mOwnCamera; // To know if the ogre camera binded has been created outside or inside of this class

                Real mTightness; // Determines the movement of the camera - 1 means tight movement, while 0 means no movement
        public:
// Methods ---------------------------------------------------------------------------------
        protected:
        public:
                ExtendedCamera (String name, SceneManager *sceneMgr, Camera *camera = 0) {
                        // Basic member references setup
                        mName = name;
                        mSceneMgr = sceneMgr;

                        // Create the camera's node structure
                        mCameraNode = mSceneMgr->getRootSceneNode ()->createChildSceneNode (mName);
                        mTargetNode = mSceneMgr->getRootSceneNode ()->createChildSceneNode (mName + "_target");
                        mCameraNode->setAutoTracking (true, mTargetNode); // The camera will always look at the camera target
                        mCameraNode->setFixedYawAxis (true); // Needed because of auto tracking

                        // Create our camera if it wasn't passed as a parameter
                        if (camera == 0) {
                                mCamera = mSceneMgr->createCamera (mName);
                                mOwnCamera = true;
                        }
                        else {
                                mCamera = camera;
                                mOwnCamera = false;
                        }

                        mCamera->setFOVy(Radian(Degree(12.0)));
                        // ... and attach the Ogre camera to the camera node
                        mCameraNode->attachObject (mCamera);

                        // Default tightness
                        mTightness = 0.01f;
                }
                ~ExtendedCamera () {
                        mCameraNode->detachAllObjects ();
                        if (mOwnCamera)
                                delete mCamera;
                        mSceneMgr->destroySceneNode (mName);
                        mSceneMgr->destroySceneNode (mName + "_target");
                }

                void setFOVy(Ogre::Radian fovy)
                {
                        mCamera->setFOVy(Radian(Degree(fovy)));
                }

                void setTightness (Real tightness) {
                        mTightness = tightness;
                }

                Real getTightness () {
                        return mTightness;
                }

                Vector3 getCameraPosition () {
                        return mCameraNode->getPosition ();
                }

                void instantUpdate (Vector3 cameraPosition, Vector3 targetPosition) {
                        mCameraNode->setPosition (cameraPosition);
                        mTargetNode->setPosition (targetPosition);
                }

                void update (Real elapsedTime, Vector3 cameraPosition, Vector3 targetPosition) {
                        // Handle movement
                        Vector3 displacement;

                        displacement = (cameraPosition - mCameraNode->getPosition ()) * mTightness;
                        mCameraNode->translate (displacement);

                        displacement = (targetPosition - mTargetNode->getPosition ()) * mTightness;
                        mTargetNode->translate (displacement);
                }
};