Changeset 6108 for code/branches/presentation2

Timestamp:

Nov 20, 2009, 8:15:25 PM (15 years ago)

Author:

scheusso

Message:

merged steering branch to presentation2 branch

Location:

code/branches/presentation2

Files:

• . (modified) (1 prop)
• data/defaultConfig/keybindings.ini (modified) (1 diff)
• src/libraries/core/input/InputManager.cc (modified) (2 diffs)
• src/modules/weapons/weaponmodes/HsW01.cc (modified) (2 diffs)
• src/orxonox/controllers/CMakeLists.txt (modified) (1 diff)
• src/orxonox/controllers/Controller.cc (modified) (1 diff)
• src/orxonox/controllers/Controller.h (modified) (2 diffs)
• src/orxonox/controllers/HumanController.cc (modified) (3 diffs)
• src/orxonox/controllers/HumanController.h (modified) (2 diffs)
• src/orxonox/controllers/NewHumanController.cc (copied) (copied from code/branches/steering/src/orxonox/controllers/NewHumanController.cc)
• src/orxonox/controllers/NewHumanController.h (copied) (copied from code/branches/steering/src/orxonox/controllers/NewHumanController.h)
• src/orxonox/graphics/Camera.cc (modified) (1 diff)
• src/orxonox/graphics/Camera.h (modified) (1 diff)
• src/orxonox/infos/HumanPlayer.cc (modified) (2 diffs)
• src/orxonox/infos/PlayerInfo.cc (modified) (3 diffs)
• src/orxonox/overlays/OrxonoxOverlay.h (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponMode.cc (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponMode.h (modified) (3 diffs)
• src/orxonox/worldentities/ControllableEntity.cc (modified) (1 diff)
• src/orxonox/worldentities/ControllableEntity.h (modified) (2 diffs)
• src/orxonox/worldentities/WorldEntity.cc (modified) (3 diffs)
• src/orxonox/worldentities/WorldEntity.h (modified) (5 diffs)

code/branches/presentation2/data/defaultConfig/keybindings.ini

@@ -122 +122 @@
 KeyStop=
 KeySystemRequest=
-KeyT=
-KeyTab="cycleNavigationFocus"
-KeyU=
+KeyT=""
+KeyTab="NewHumanController changeMode"
+KeyU=""
 KeyUP="scale 1 moveFrontBack"
 KeyUnassigned="openConsole"

code/branches/presentation2/src/libraries/core/input/InputManager.cc

@@ -631 +631 @@
                 {
                     // not scheduled for destruction
-                    // prevents a state being added multiple times
+                    // prevents a state from being added multiple times
                     stateEnterRequests_.insert(it->second);
                     return true;
                 }
             }
+            else if (this->stateLeaveRequests_.find(it->second) != this->stateLeaveRequests_.end())
+            {
+                // State already scheduled for leaving --> cancel
+                this->stateLeaveRequests_.erase(this->stateLeaveRequests_.find(it->second));
+            }
         }
         return false;
@@ -658 +663 @@
                 return true;
             }
+            else if (this->stateEnterRequests_.find(it->second) != this->stateEnterRequests_.end())
+            {
+                // State already scheduled for entering --> cancel
+                this->stateEnterRequests_.erase(this->stateEnterRequests_.find(it->second));
+            }
         }
         return false;

code/branches/presentation2/src/modules/weapons/weaponmodes/HsW01.cc

@@ -39 +39 @@
 #include "weaponsystem/WeaponPack.h"
 #include "weaponsystem/WeaponSystem.h"
+#include "worldentities/WorldEntity.h"
 
 namespace orxonox
@@ -110 +111 @@
         model->setScale(5);
 
+        this->computeMuzzleParameters();
         projectile->setOrientation(this->getMuzzleOrientation());
         projectile->setPosition(this->getMuzzlePosition());

code/branches/presentation2/src/orxonox/controllers/CMakeLists.txt

@@ -2 +2 @@
   Controller.cc
   HumanController.cc
+  NewHumanController.cc
   ArtificialController.cc
   AIController.cc

code/branches/presentation2/src/orxonox/controllers/Controller.cc

@@ -29 +29 @@
 #include "Controller.h"
 #include "core/CoreIncludes.h"
+#include "worldentities/ControllableEntity.h"
 
 namespace orxonox

code/branches/presentation2/src/orxonox/controllers/Controller.h

@@ -54 +54 @@
             virtual void changedControllableEntity() {}
 
+            virtual bool canFindTarget()
+                { return false; }
+            virtual Vector3 getTarget()
+                { return Vector3::ZERO; }
+
         protected:
             // don't use this directly, use getPlayer()->startControl(entity) (unless you know exactly what you do)
@@ -65 +70 @@
             }
 
+        protected:
             PlayerInfo* player_;
             ControllableEntity* controllableEntity_;

code/branches/presentation2/src/orxonox/controllers/HumanController.cc

@@ -113 +113 @@
     }
 
-    void HumanController::rotateYaw(const Vector2& value)
+    void HumanController::yaw(const Vector2& value)
     {
         //Hack to enable mouselook in map
@@ -125 +125 @@
     }
 
-    void HumanController::rotatePitch(const Vector2& value)
+    void HumanController::pitch(const Vector2& value)
     {
         //Hack to enable mouselook in map
@@ -143 +143 @@
     }
 
-    void HumanController::fire(unsigned int firemode)
+    void HumanController::doFire(unsigned int firemode)
     {
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)

code/branches/presentation2/src/orxonox/controllers/HumanController.h

@@ -49 +49 @@
             static void moveUpDown(const Vector2& value);
 
-            static void rotateYaw(const Vector2& value);
-            static void rotatePitch(const Vector2& value);
+            static void rotateYaw(const Vector2& value){ HumanController::localController_s->yaw(value); }
+            static void rotatePitch(const Vector2& value){ HumanController::localController_s->pitch(value); }
             static void rotateRoll(const Vector2& value);
+            
+            virtual void yaw(const Vector2& value);
+            virtual void pitch(const Vector2& value);
 
-            static void fire(unsigned int firemode);
+            static void fire(unsigned int firemode) { HumanController::localController_s->doFire(firemode); }
+            virtual void doFire(unsigned int firemode);
             static void reload();
 
@@ -76 +80 @@
             friend class Map;
 
-        private:
+        protected:
             static HumanController* localController_s;
     };

code/branches/presentation2/src/orxonox/graphics/Camera.cc

@@ -61 +61 @@
 
         this->camera_ = this->getScene()->getSceneManager()->createCamera(getUniqueNumberString());
+        this->camera_->setUserObject(this);
         this->cameraNode_ = this->getScene()->getRootSceneNode()->createChildSceneNode();
         this->attachNode(this->cameraNode_);

code/branches/presentation2/src/orxonox/graphics/Camera.h

@@ -52 +52 @@
             void releaseFocus();
 
+            inline Ogre::Camera* getOgreCamera()
+               { return this->camera_; }
+
             inline bool hasFocus()
                 { return this->bHasFocus_; }

code/branches/presentation2/src/orxonox/infos/HumanPlayer.cc

@@ -35 +35 @@
 #include "network/Host.h"
 #include "controllers/HumanController.h"
+#include "controllers/NewHumanController.h"
 #include "gametypes/Gametype.h"
 #include "overlays/OverlayGroup.h"
@@ -50 +51 @@
 
         this->bHumanPlayer_ = true;
-        this->defaultController_ = Class(HumanController);
+        this->defaultController_ = Class(NewHumanController);
 
         this->humanHud_ = 0;

code/branches/presentation2/src/orxonox/infos/PlayerInfo.cc

@@ -139 +139 @@
         this->controller_->setPlayer(this);
         if (this->controllableEntity_)
+        {
             this->controller_->setControllableEntity(this->controllableEntity_);
+            this->controllableEntity_->setController(this->controller_);
+        }
         this->changedController();
     }
@@ -161 +164 @@
 
         if (this->controller_)
+        {
             this->controller_->setControllableEntity(entity);
+            this->controllableEntity_->setController(this->controller_);
+        }
 
         this->changedControllableEntity();
@@ -195 +201 @@
             return;
 
+        this->controllableEntity_->setController(0);
         this->controllableEntity_ = 0;
         this->controllableEntityID_ = OBJECTID_UNKNOWN;

code/branches/presentation2/src/orxonox/overlays/OrxonoxOverlay.h

@@ -155 +155 @@
         static void rotateOverlay(const std::string& name, const Degree& angle);
 
+        void setBackgroundMaterial(const std::string& material);
+        const std::string& getBackgroundMaterial() const;
+
         virtual void changedVisibility();
 
@@ -181 +184 @@
         virtual void positionChanged();
 
-        void setBackgroundMaterial(const std::string& material);
-        const std::string& getBackgroundMaterial() const;
-
         Ogre::Overlay* overlay_;                   //!< The overlay the entire class is about.
         Ogre::PanelOverlayElement* background_;    //!< Background image (blank per default).

code/branches/presentation2/src/orxonox/weaponsystem/WeaponMode.cc

@@ -32 +32 @@
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "controllers/Controller.h"
+#include "worldentities/pawns/Pawn.h"
 
 #include "Munition.h"
@@ -194 +196 @@
     }
 
-    Vector3 WeaponMode::getMuzzlePosition() const
+    void WeaponMode::computeMuzzleParameters()
     {
         if (this->weapon_)
-            return (this->weapon_->getWorldPosition() + this->weapon_->getWorldOrientation() * this->muzzleOffset_);
-        else
-            return this->muzzleOffset_;
-    }
-
-    const Quaternion& WeaponMode::getMuzzleOrientation() const
+        {
+            this->muzzlePosition_ = this->weapon_->getWorldPosition() + this->weapon_->getWorldOrientation() * this->muzzleOffset_;
+
+            Controller* controller = this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getController();
+            if (controller->canFindTarget())
+            {
+                Vector3 muzzleDirection(controller->getTarget() - this->muzzlePosition_);
+                this->muzzleOrientation_ = (this->weapon_->getWorldOrientation() * WorldEntity::FRONT).getRotationTo(muzzleDirection) * this->weapon_->getWorldOrientation();
+            }
+            else
+                this->muzzleOrientation_ = this->weapon_->getWorldOrientation();
+        }
+        else
+        {
+            this->muzzlePosition_ = this->muzzleOffset_;
+            this->muzzleOrientation_ = Quaternion::IDENTITY;
+        }
+    }
+
+    Vector3 WeaponMode::getMuzzleDirection() const
     {
         if (this->weapon_)
-            return this->weapon_->getWorldOrientation();
-        else
-            return Quaternion::IDENTITY;
-    }
-
-    Vector3 WeaponMode::getMuzzleDirection() const
-    {
-        if (this->weapon_)
-            return (this->weapon_->getWorldOrientation() * WorldEntity::FRONT);
+            return (this->getMuzzleOrientation() * WorldEntity::FRONT);
         else
             return WorldEntity::FRONT;

code/branches/presentation2/src/orxonox/weaponsystem/WeaponMode.h

@@ -109 +109 @@
                 { return this->muzzleOffset_; }
 
-            Vector3 getMuzzlePosition() const;
-            const Quaternion& getMuzzleOrientation() const;
+            void computeMuzzleParameters();
+            const Vector3& getMuzzlePosition() const
+                { return this->muzzlePosition_; }
+            const Quaternion& getMuzzleOrientation() const
+                { return this->muzzleOrientation_; }
             Vector3 getMuzzleDirection() const;
 
@@ -124 +127 @@
             inline unsigned int getMode() const
                 { return this->mode_; }
+
+            Vector3 getTarget();
 
         protected:
@@ -152 +157 @@
             Timer reloadTimer_;
             bool bReloading_;
+
+            Vector3 muzzlePosition_;
+            Quaternion muzzleOrientation_;
     };
 }

code/branches/presentation2/src/orxonox/worldentities/ControllableEntity.cc

@@ -65 +65 @@
         this->camera_ = 0;
         this->xmlcontroller_ = 0;
+        this->controller_ = 0;
         this->reverseCamera_ = 0;
         this->bDestroyWhenPlayerLeft_ = false;

code/branches/presentation2/src/orxonox/worldentities/ControllableEntity.h

@@ -140 +140 @@
             inline Controller* getXMLController() const
                 { return this->xmlcontroller_; }
+
+            inline Controller* getController() const
+                { return this->controller_; }
+            inline void setController(Controller* val)
+                { this->controller_ = val; }
 
         protected:
@@ -202 +207 @@
             std::string cameraPositionTemplate_;
             Controller* xmlcontroller_;
+            Controller* controller_;
             CameraPosition* reverseCamera_;
     };

code/branches/presentation2/src/orxonox/worldentities/WorldEntity.cc

@@ -472 +472 @@
     //! Attaches an Ogre::MovableObject to this WorldEntity.
     void WorldEntity::attachOgreObject(Ogre::MovableObject* object)
-        { this->node_->attachObject(object); }
+    {
+        this->node_->attachObject(object);
+        object->setUserObject(this);
+    }
+
     void WorldEntity::attachOgreObject(Ogre::BillboardSet* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::Camera* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::Entity* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::ParticleSystem* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
 
     //! Detaches an Ogre::MovableObject from this WorldEntity.
     void WorldEntity::detachOgreObject(Ogre::MovableObject* object)
-        { this->node_->detachObject(object); }
+    {
+        object->setUserObject(NULL);
+        this->node_->detachObject(object);
+    }
+
     void WorldEntity::detachOgreObject(Ogre::BillboardSet* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::Camera* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::Entity* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::ParticleSystem* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
 
     //! Detaches an Ogre::MovableObject (by string) from this WorldEntity.
@@ -646 +654 @@
     /**
     @brief
-        Makes this WorldEntity look a specific target location.
+        Makes this WorldEntity look at a specific target location.
     @param relativeTo
         @see WorldEntity::TransformSpace
@@ -913 +921 @@
     }
 
-    //! Copies our own parameters for restitution, angular factor, dampings and friction to the bullet rigid body.
+    //! Copies our own parameters for restitution, angular factor, damping and friction to the bullet rigid body.
     void WorldEntity::internalSetPhysicsProps()
     {

code/branches/presentation2/src/orxonox/worldentities/WorldEntity.h

@@ -33 +33 @@
 #include "OrxonoxPrereqs.h"
 
+#include <OgreUserDefinedObject.h>
 #ifdef ORXONOX_RELEASE
 #  include <OgreSceneNode.h>
@@ -55 +56 @@
 
         The basic task of the WorldEntity is provide a location, a direction and a scaling and the possibility
-        to create an entire hierarchy of derivated objects.
+        to create an entire hierarchy of derived objects.
         It is also the basis for the physics interface to the Bullet physics engine.
         Every WorldEntity can have a specific collision type: @see CollisionType
@@ -63 +64 @@
         There is also support for attaching WorldEntities with physics to each other. Currently, the collision shape
         of both objects simply get merged into one larger shape (for static collision type).
-        The phyiscal body that is internally stored and administrated has the following supported properties:
-        - Restitution, angular factor, linear damping, angular damping, fricition, mass and collision shape.
+        The physical body that is internally stored and administrated has the following supported properties:
+        - Restitution, angular factor, linear damping, angular damping, friction, mass and collision shape.
         You can get more information at the corresponding set function.
 
         Collision shapes: These are controlled by the internal WorldEntityCollisionShape. @see WorldEntityCollisionShape.
     */
-    class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState
+    class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState, public Ogre::UserDefinedObject
     {
         friend class Scene;
@@ -318 +319 @@
                 Sets an artificial parameter that tells how much torque is applied when you apply a non-central force.
 
-                Normally the angular factor is 1, which means it's physically 'correct'. Howerver if you have a player
+                Normally the angular factor is 1, which means it's physically 'correct'. However if you have a player
                 character that should not rotate when hit sideways, you can set the angular factor to 0.
             */
@@ -394 +395 @@
                 You can override this function in a derived class to constrain the collision to e.g. None or Dynamic.
                 A projectile may not prove very useful if there is no physical body. Simply set the CollisionType
-                in its constructor and override this method. But be careful that a derived classe's virtual functions
+                in its constructor and override this method. But be careful that a derived class's virtual functions
                 don't yet exist in the constructor if a base class.
             */