Changeset 2201 for code/branches/physics/src/orxonox/objects

Timestamp:

Nov 12, 2008, 4:17:02 PM (16 years ago)

Author:

martisty

Message:

loading objects and creating shapes…

Location:

code/branches/physics/src/orxonox/objects

Files:

• HelloBullet.cc (modified) (1 diff)
• HelloBullet.h (modified) (1 diff)
• worldentities/ControllableEntity.cc (modified) (9 diffs)
• worldentities/ControllableEntity.h (modified) (1 diff)
• worldentities/MovableEntity.cc (modified) (3 diffs)
• worldentities/MovableEntity.h (modified) (1 diff)
• worldentities/WorldEntity.cc (modified) (1 diff)

code/branches/physics/src/orxonox/objects/HelloBullet.cc

@@ -30 +30 @@
 #include "HelloBullet.h"
 
+#include <OgreSceneNode.h>
 #include <OgreStaticGeometry.h>
 #include <OgreSceneManager.h>

code/branches/physics/src/orxonox/objects/HelloBullet.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 #include "core/BaseObject.h"
+#include <OgrePrerequisites.h>
 
 #include "btBulletCollisionCommon.h"

code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.cc

@@ -326 +326 @@
 
 
-    void ControllableEntity::setPosition(const Vector3& position)
-    {
-        if (Core::isMaster())
-        {
-            this->node_->setPosition(position);
-            this->server_position_ = position;
-            ++this->server_overwrite_;
-        }
-        else if (this->bControlled_)
-        {
-            this->node_->setPosition(position);
+    // virtual void PositionChanged() { }
+    void ControllableEntity::positionChanged(const Vector3& position)
+    {
+        if (Core::isMaster())
+        {
+            this->server_position_ = this->getPosition();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
             this->client_position_ = position;
         }
@@ -355 +354 @@
         }
     }
-
-    void ControllableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
+    // virtual void translateChanged() { }
+    void ControllableEntity::translateChanged(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
     {
         if (Core::isMaster())
@@ -370 +369 @@
         }
     }
-
-    void ControllableEntity::setOrientation(const Quaternion& orientation)
+    // virtual void orientationChanged() { }
+    void ControllableEntity::orientationChanged(const Quaternion& orientation)
     {
         if (Core::isMaster())
@@ -385 +384 @@
         }
     }
-
-    void ControllableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
+    // virtual void rotateChanged() { }
+    void ControllableEntity::rotateChanged(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
     {
         if (Core::isMaster())
@@ -400 +399 @@
         }
     }
-
-    void ControllableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    // virtual void yawChanged() { }
+    void ControllableEntity::yawChanged(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         if (Core::isMaster())
@@ -415 +414 @@
         }
     }
-
-    void ControllableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    // virtual void pitchChanged() { }
+    void ControllableEntity::pitchChanged(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         if (Core::isMaster())
@@ -430 +429 @@
         }
     }
-
-    void ControllableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    // virtual void rollChanged() { }
+    void ControllableEntity::rollChanged(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         if (Core::isMaster())
@@ -445 +444 @@
         }
     }
-
-    void ControllableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    //virtual void lookAtChanged() { }
+    void ControllableEntity::lookAtChanged(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
     {
         if (Core::isMaster())
@@ -460 +459 @@
         }
     }
-
-    void ControllableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    // virtual void directionChanged( ) { }
+    void ControllableEntity::directionChanged(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
     {
         if (Core::isMaster())

code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.h

@@ -79 +79 @@
                 { return this->hudtemplate_; }
 
-            using WorldEntity::setPosition;
-            using WorldEntity::translate;
-            using WorldEntity::setOrientation;
-            using WorldEntity::rotate;
-            using WorldEntity::yaw;
-            using WorldEntity::pitch;
-            using WorldEntity::roll;
-            using WorldEntity::lookAt;
-            using WorldEntity::setDirection;
-
-            void setPosition(const Vector3& position);
+            void setPosition();
             void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
             void setOrientation(const Quaternion& orientation);

code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.cc

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Martin Stypinski
  *
  */
@@ -29 +29 @@
 #include "OrxonoxStableHeaders.h"
 #include "MovableEntity.h"
+
+#include "objects/Scene.h"
 
 #include "core/CoreIncludes.h"
@@ -54 +56 @@
     {
     }
+
+    void MovableEntity::setPosition(const Vector3& position){
+        // Here the code
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->setPosition(position);
+        positionChanged();
+    }
+
+    void MovableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->translate(distance, relativeTo); 
+        translateChanged();
+    }
+
+    void MovableEntity::setOrientation(const Quaternion& orientation){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->setOrientation(orientation);
+        orientationChanged();
+    }
+
+    void MovableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->rotate(rotation, relativeTo);
+        rotateChanged();
+    }
+
+    void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->yaw(angle, relativeTo);
+        yawChanged();
+    }
+
+    void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->pitch(angle, relativeTo);
+        pitchChanged();
+    }
+
+    void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->roll(angle, relativeTo);
+        rollChanged();
+    }
+
+    void MovableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->lookAt(target, relativeTo, localDirectionVector); 
+        lookAtChanged();
+    }
+
+    void MovableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector){
+        if(isDynamic() && bAddedToPhysicalWorld_){
+            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        }
+        this->node_->setDirection(direction, relativeTo, localDirectionVector); 
+        directionChanged();
+    }
+
 }

code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.h

@@ -47 +47 @@
             void registerVariables();
 
+            using WorldEntity::setPosition;
+            using WorldEntity::translate;
+            using WorldEntity::setOrientation;
+            using WorldEntity::rotate;
+            using WorldEntity::yaw;
+            using WorldEntity::pitch;
+            using WorldEntity::roll;
+            using WorldEntity::lookAt;
+            using WorldEntity::setDirection;
+
+            void setPosition(const Vector3& position);
+            void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void setOrientation(const Quaternion& orientation);
+            void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+
+
         private:
+
+            virtual void rollChanged() { }
+            virtual void positionChanged() { }
+            virtual void translateChanged() { }
+            virtual void orientationChanged() { }
+            virtual void rotateChanged() { }
+            virtual void yawChanged() { }
+            virtual void pitchChanged() { }
+            virtual void lookAtChanged() { }
+            virtual void directionChanged( ) { }
 
             //void attachPhysicalObject(WorldEntity* object);

code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.cc

@@ -148 +148 @@
     }
 
+    void WorldEntitiy::attachPhysicalObject(WorldEntity* object){
+    //function attachhysicalObject
+        StaticEntity* staticObject = dynamic_cast<WorldEntity*>(object);
+        if (staticObject != 0 && hasPhysics()){
+           btCompountShape* compoundShape = dynamic_cast<btCompoundShape*>(physicalBody_->getCollisionShape());
+           if(compoundShape == 0){
+                //NEW
+                btCompoundShape* newShape = new btCompoundShape();
+                newShape->addChildShape(this->physcialBody_->getCollisionShape());
+                newShape->addChildShape(staticObject->getCollisionShape());
+                this->physicalBody_->setCollisionShape();
+           }
+           else{
+               compoundShape -> addChildShape(staticObject->getCollisionShape());
+           }
+        }
+    }
+
     void WorldEntity::detach(WorldEntity* object)
     {