Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 30, 2008, 12:36:46 PM (16 years ago)
Author:
rgrieder
Message:

Still getting physics and its implications straight:

  • Removed PositionableEntity —> StaticEntity is now the way to go. They cannot be translated in any way during physics simulation. The trick will be to remove them and add them again to Bullet. This however is not yet implemented.
  • Forgot a few consts in WorldEntity
  • Fixed a bug with infinite masses
  • WE throws exception if you try to apply physics when the SceneNode is not in the root space of the Scene.
  • Moved velocity_ to MovableEntity
  • Outside world reference of WE/ME are now always the non-physical values. getPosition() will always return node_→getPosition() and when setting it, both RigidBody and SceneNode are translated. This accounts for velocity, orientation and position.
Location:
code/branches/physics/src/orxonox/objects/worldentities
Files:
2 deleted
27 edited

Legend:

Unmodified
Added
Removed

  • code/branches/physics/src/orxonox/objects/worldentities/Backlight.h

    r2103 r2300  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include "PositionableEntity.h"
     34#include "StaticEntity.h"
    3535#include "tools/BillboardSet.h"
    3636
    3737namespace orxonox
    3838{
    39     class _OrxonoxExport Backlight : public PositionableEntity
     39    class _OrxonoxExport Backlight : public StaticEntity
    4040    {
    4141        public:

  • code/branches/physics/src/orxonox/objects/worldentities/Billboard.cc

    r2296 r2300  
    3838    CreateFactory(Billboard);
    3939
    40     Billboard::Billboard(BaseObject* creator) : PositionableEntity(creator)
     40    Billboard::Billboard(BaseObject* creator) : StaticEntity(creator)
    4141    {
    4242        RegisterObject(Billboard);

  • code/branches/physics/src/orxonox/objects/worldentities/Billboard.h

    r2087 r2300  
    3131
    3232#include "OrxonoxPrereqs.h"
    33 #include "PositionableEntity.h"
     33#include "StaticEntity.h"
    3434#include "util/Math.h"
    3535#include "tools/BillboardSet.h"
    … …  
    3737namespace orxonox
    3838{
    39     class _OrxonoxExport Billboard : public PositionableEntity
     39    class _OrxonoxExport Billboard : public StaticEntity
    4040    {
    4141        public:

  • code/branches/physics/src/orxonox/objects/worldentities/Camera.cc

    r2296 r2300  
    4747    CreateFactory(Camera);
    4848
    49     Camera::Camera(BaseObject* creator) : PositionableEntity(creator)
     49    Camera::Camera(BaseObject* creator) : StaticEntity(creator)
    5050    {
    5151        RegisterObject(Camera);

  • code/branches/physics/src/orxonox/objects/worldentities/Camera.h

    r2103 r2300  
    3333
    3434#include <OgrePrerequisites.h>
    35 #include "objects/worldentities/PositionableEntity.h"
     35#include "objects/worldentities/StaticEntity.h"
    3636#include "objects/Tickable.h"
    3737
    3838namespace orxonox
    3939{
    40     class _OrxonoxExport Camera : public PositionableEntity, public Tickable
     40    class _OrxonoxExport Camera : public StaticEntity, public Tickable
    4141    {
    4242        friend class CameraManager;

  • code/branches/physics/src/orxonox/objects/worldentities/CameraPosition.cc

    r2087 r2300  
    3838    CreateFactory(CameraPosition);
    3939
    40     CameraPosition::CameraPosition(BaseObject* creator) : PositionableEntity(creator)
     40    CameraPosition::CameraPosition(BaseObject* creator) : StaticEntity(creator)
    4141    {
    4242        RegisterObject(CameraPosition);

  • code/branches/physics/src/orxonox/objects/worldentities/CameraPosition.h

    r2087 r2300  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include "objects/worldentities/PositionableEntity.h"
     34#include "objects/worldentities/StaticEntity.h"
    3535
    3636namespace orxonox
    3737{
    38     class _OrxonoxExport CameraPosition : public PositionableEntity
     38    class _OrxonoxExport CameraPosition : public StaticEntity
    3939    {
    4040        public:

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

    r2292 r2300  
    5757        this->bDestroyWhenPlayerLeft_ = false;
    5858
    59         this->velocity_ = Vector3::ZERO;
    6059        this->acceleration_ = Vector3::ZERO;
    6160
    … …  
    332331        if (Core::isMaster())
    333332        {
    334             this->server_position_ = this->node_->getPosition();
     333            this->server_position_ = this->getPosition();
    335334            ++this->server_overwrite_;
    336335        }
    337336        else if (this->bControlled_)
    338337        {
    339             this->client_position_ = this->node_->getPosition();
     338            this->client_position_ = this->getPosition();
    340339        }
    341340    }
    … …  
    345344        if (Core::isMaster())
    346345        {
    347             this->server_orientation_ = this->node_->getOrientation();
     346            this->server_orientation_ = this->getOrientation();
    348347            ++this->server_overwrite_;
    349348        }
    350349        else if (this->bControlled_)
    351350        {
    352             this->client_orientation_ = this->node_->getOrientation();
     351            this->client_orientation_ = this->getOrientation();
    353352        }
    354353    }
    … …  
    358357        if (Core::isMaster())
    359358        {
    360             this->server_velocity_ = this->velocity_;
     359            this->server_velocity_ = this->getVelocity();
    361360            ++this->server_overwrite_;
    362361        }
    363362        else if (this->bControlled_)
    364363        {
    365             this->client_velocity_ = this->velocity_;
    366         }
    367     }
    368 
    369     void ControllableEntity::setVelocity(const Vector3& velocity)
    370     {
    371         if (this->bControlled_ || Core::isMaster())
    372         {
    373             if (!this->isDynamic())
    374             {
    375                 // no physics, we do it ourselves
    376                 internalSetVelocity(velocity);
    377             }
    378             else
    379             {
    380                 this->physicalBody_->setLinearVelocity(btVector3(velocity.x, velocity.y, velocity.z));
    381             }
    382             velocityChanged();
     364            this->client_velocity_ = this->getVelocity();
    383365        }
    384366    }

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

    r2292 r2300  
    7979                { return this->hudtemplate_; }
    8080
    81             void setVelocity(const Vector3& velocity);
    82             inline void setVelocity(float x, float y, float z)
    83                 { setVelocity(Vector3(x,y,z)); }
    84 
    8581            inline void setAcceleration(const Vector3& acceleration)
    8682                { this->acceleration_ = acceleration; }
    … …  
    127123            void processClientOrientation();
    128124
    129             inline void internalSetVelocity(const Vector3& velocity)
    130                 { this->velocity_ = velocity; }
    131125            void positionChanged();
    132126            void orientationChanged();
    … …  
    137131            unsigned int server_overwrite_;
    138132            unsigned int client_overwrite_;
    139 
    140             Vector3 velocity_;
    141133
    142134            bool bControlled_;

  • code/branches/physics/src/orxonox/objects/worldentities/Light.cc

    r2296 r2300  
    4747    CreateFactory(Light);
    4848
    49     Light::Light(BaseObject* creator) : PositionableEntity(creator)
     49    Light::Light(BaseObject* creator) : StaticEntity(creator)
    5050    {
    5151        RegisterObject(Light);

  • code/branches/physics/src/orxonox/objects/worldentities/Light.h

    r2087 r2300  
    3131
    3232#include "OrxonoxPrereqs.h"
    33 #include "PositionableEntity.h"
     33#include "StaticEntity.h"
    3434
    3535#include <string>
    … …  
    4040namespace orxonox
    4141{
    42     class _OrxonoxExport Light : public PositionableEntity
     42    class _OrxonoxExport Light : public StaticEntity
    4343    {
    4444        public:

  • code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.cc

    r2292 r2300  
    4545        RegisterObject(LinearEntity);
    4646
    47         this->velocity_ = Vector3::ZERO;
    4847        this->acceleration_ = Vector3::ZERO;
    4948        this->rotationAxis_ = Vector3::ZERO;
    … …  
    6564        SUPER(LinearEntity, XMLPort, xmlelement, mode);
    6665
    67         XMLPortParamTemplate(LinearEntity, "velocity", setVelocity, getVelocity, xmlelement, mode, const Vector3&);
    6866        XMLPortParamTemplate(LinearEntity, "rotationaxis", setRotationAxis, getRotationAxis, xmlelement, mode, const Vector3&);
    6967        XMLPortParamTemplate(LinearEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Degree&);
    … …  
    129127    void LinearEntity::positionChanged()
    130128    {
    131         this->overwrite_position_  = this->node_->getPosition();
     129        this->overwrite_position_  = this->getPosition();
    132130    }
    133131
    134132    void LinearEntity::orientationChanged()
    135133    {
    136         this->overwrite_orientation_  = this->node_->getOrientation();
    137     }
    138 
    139     void LinearEntity::setVelocity(const Vector3& velocity)
    140     {
    141         if (!this->isDynamic())
    142         {
    143             // no physics, we do it ourselves
    144             internalSetVelocity(velocity);
    145         }
    146         else
    147         {
    148             this->physicalBody_->setLinearVelocity(btVector3(velocity.x, velocity.y, velocity.z));
    149         }
     134        this->overwrite_orientation_  = this->getOrientation();
    150135    }
    151136}

  • code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.h

    r2292 r2300  
    4848            void registerVariables();
    4949
    50             inline void setVelocity(const Vector3& velocity);
    51             inline void setVelocity(float x, float y, float z)
    52                 { this->velocity_.x = x; this->velocity_.y = y; this->velocity_.z = z; }
    53             inline const Vector3& getVelocity() const
    54                 { return this->velocity_; }
    55 
    5650            inline void setAcceleration(const Vector3& acceleration)
    5751                { this->acceleration_ = acceleration; }
    … …  
    9286            void positionChanged();
    9387            void orientationChanged();
    94             inline void internalSetVelocity(const Vector3& velocity)
    95                 { this->velocity_ = velocity; }
    9688
    97             Vector3 velocity_;
    9889            Vector3 acceleration_;
    9990            Vector3 rotationAxis_;

  • code/branches/physics/src/orxonox/objects/worldentities/Model.cc

    r2296 r2300  
    3838    CreateFactory(Model);
    3939
    40     Model::Model(BaseObject* creator) : PositionableEntity(creator)
     40    Model::Model(BaseObject* creator) : StaticEntity(creator)
    4141    {
    4242        RegisterObject(Model);

  • code/branches/physics/src/orxonox/objects/worldentities/Model.h

    r2192 r2300  
    3131
    3232#include "OrxonoxPrereqs.h"
    33 #include "PositionableEntity.h"
     33#include "StaticEntity.h"
    3434#include "tools/Mesh.h"
    3535
    3636namespace orxonox
    3737{
    38     class _OrxonoxExport Model : public PositionableEntity
     38    class _OrxonoxExport Model : public StaticEntity
    3939    {
    4040        public:

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

    r2298 r2300  
    4242        RegisterObject(MovableEntity);
    4343
     44        this->velocity_ = Vector3::ZERO;
     45
    4446        this->registerVariables();
    4547    }
    … …  
    5254    {
    5355        SUPER(MovableEntity, XMLPort, xmlelement, mode);
     56
     57        XMLPortParamTemplate(MovableEntity, "velocity", setVelocity, getVelocity, xmlelement, mode, const Vector3&);
    5458    }
    5559
    … …  
    165169            this->physicalBody_->setWorldTransform(transf);
    166170        }
    167         else
    168         {
    169             // no physics, we do it ourselves
    170             this->node_->setPosition(position);
    171         }
     171
     172        this->node_->setPosition(position);
     173        positionChanged();
    172174    }
    173175
    … …  
    180182            this->physicalBody_->translate(btVector3(distance.x, distance.y, distance.z));
    181183        }
    182         else
    183         {
    184             // no physics, we do it ourselves
    185             this->node_->translate(distance, relativeTo);
    186         }
     184
     185        this->node_->translate(distance, relativeTo);
     186        positionChanged();
    187187    }
    188188
    … …  
    195195            this->physicalBody_->setWorldTransform(transf);
    196196        }
    197         else
    198         {
    199             // no physics, we do it ourselves
    200             this->node_->setOrientation(orientation);
    201         }
     197
     198        this->node_->setOrientation(orientation);
     199        orientationChanged();
    202200    }
    203201
    … …  
    211209            this->physicalBody_->setWorldTransform(transf * btTransform(btQuaternion(rotation.w, rotation.x, rotation.y, rotation.z)));
    212210        }
    213         else
    214         {
    215             // no physics, we do it ourselves
    216             this->node_->rotate(rotation, relativeTo);
    217         }
     211
     212        this->node_->rotate(rotation, relativeTo);
     213        orientationChanged();
    218214    }
    219215
    … …  
    228224            this->physicalBody_->setWorldTransform(transf * rotation);
    229225        }
    230         else
    231         {
    232             // no physics, we do it ourselves
    233             this->node_->yaw(angle, relativeTo);
    234         }
     226
     227        this->node_->yaw(angle, relativeTo);
     228        orientationChanged();
    235229    }
    236230
    … …  
    245239            this->physicalBody_->setWorldTransform(transf * rotation);
    246240        }
    247         else
    248         {
    249             // no physics, we do it ourselves
    250             this->node_->pitch(angle, relativeTo);
    251         }
     241
     242        this->node_->pitch(angle, relativeTo);
     243        orientationChanged();
    252244    }
    253245
    … …  
    262254            this->physicalBody_->setWorldTransform(transf * rotation);
    263255        }
    264         else
    265         {
    266             // no physics, we do it ourselves
    267             this->node_->roll(angle, relativeTo);
    268         }
     256
     257        this->node_->roll(angle, relativeTo);
     258        orientationChanged();
    269259    }
    270260
    … …  
    279269            //this->physicalBody_->setWorldTransform(transf);
    280270        }
    281         else
    282         {
    283             // no physics, we do it ourselves
    284             this->node_->lookAt(target, relativeTo, localDirectionVector);
    285         }
     271
     272        this->node_->lookAt(target, relativeTo, localDirectionVector);
     273        orientationChanged();
    286274    }
    287275
    … …  
    290278        if (this->isDynamic())
    291279        {
    292             ThrowException(NotImplemented, "ControllableEntity::lookAt() is not yet supported for physical objects.");
     280            ThrowException(NotImplemented, "ControllableEntity::setDirection() is not yet supported for physical objects.");
    293281            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot align physical object relative \
    294282                                                          to any other space than TS_LOCAL.");
    … …  
    296284            //this->physicalBody_->setWorldTransform(transf);
    297285        }
    298         else
    299         {
    300             // no physics, we do it ourselves
    301             this->node_->setDirection(direction, relativeTo, localDirectionVector);
    302         }
    303     }
    304 
    305     bool MovableEntity::isCollisionTypeLegal(WorldEntity::CollisionType type)
     286
     287        this->node_->setDirection(direction, relativeTo, localDirectionVector);
     288        orientationChanged();
     289    }
     290
     291    void MovableEntity::setVelocity(const Vector3& velocity)
     292    {
     293        if (this->isDynamic())
     294        {
     295            this->physicalBody_->setLinearVelocity(btVector3(velocity.x, velocity.y, velocity.z));
     296        }
     297
     298        this->velocity_ = velocity;
     299        velocityChanged();
     300    }
     301
     302    bool MovableEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
    306303    {
    307304        if (type == WorldEntity::Static)
    … …  
    320317        this->node_->setOrientation(Quaternion(worldTrans.getRotation().w(), worldTrans.getRotation().x(), worldTrans.getRotation().y(), worldTrans.getRotation().z()));
    321318        const btVector3& velocity = this->physicalBody_->getLinearVelocity();
    322         internalSetVelocity(Vector3(velocity.x(), velocity.y(), velocity.z()));
     319        this->velocity_ = Vector3(velocity.x(), velocity.y(), velocity.z());
     320        velocityChanged();
    323321        positionChanged();
    324322        orientationChanged();
    … …  
    330328        worldTrans.setOrigin(btVector3(node_->getPosition().x, node_->getPosition().y, node_->getPosition().z));
    331329        worldTrans.setRotation(btQuaternion(node_->getOrientation().w, node_->getOrientation().x, node_->getOrientation().y, node_->getOrientation().z));
     330        if (this->isDynamic())
     331        {
     332            // This function gets called only once for dynamic objects to set the initial conditions
     333            // We have to set the velocity too.
     334            this->physicalBody_->setLinearVelocity(btVector3(velocity_.x, velocity_.y, velocity_.z));
     335        }
    332336    }
    333337}

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

    r2298 r2300  
    6767            void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
    6868
     69            void setVelocity(const Vector3& velocity);
     70            inline void setVelocity(float x, float y, float z)
     71                { this->velocity_.x = x; this->velocity_.y = y; this->velocity_.z = z; }
     72            inline const Vector3& getVelocity() const
     73                { return this->velocity_; }
     74
     75        protected:
     76            Vector3 velocity_;
    6977
    7078        private:
    7179            //void attachPhysicalObject(WorldEntity* object);
    7280
    73             virtual void internalSetVelocity(const Vector3& velocity) { }
    7481            virtual void positionChanged() { }
    7582            virtual void orientationChanged() { }
    76             virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type);
     83            virtual void velocityChanged() { }
     84
     85            virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type) const;
    7786
    7887            // Bullet btMotionState related

  • code/branches/physics/src/orxonox/objects/worldentities/ParticleEmitter.cc

    r2296 r2300  
    4545    CreateFactory(ParticleEmitter);
    4646
    47     ParticleEmitter::ParticleEmitter(BaseObject* creator) : PositionableEntity(creator)
     47    ParticleEmitter::ParticleEmitter(BaseObject* creator) : StaticEntity(creator)
    4848    {
    4949        RegisterObject(ParticleEmitter);

  • code/branches/physics/src/orxonox/objects/worldentities/ParticleEmitter.h

    r2087 r2300  
    3131
    3232#include "OrxonoxPrereqs.h"
    33 #include "PositionableEntity.h"
     33#include "StaticEntity.h"
    3434
    3535namespace orxonox
    3636{
    37     class _OrxonoxExport ParticleEmitter : public PositionableEntity
     37    class _OrxonoxExport ParticleEmitter : public StaticEntity
    3838    {
    3939        public:

  • code/branches/physics/src/orxonox/objects/worldentities/SpawnPoint.cc

    r2087 r2300  
    3838    CreateFactory(SpawnPoint);
    3939
    40     SpawnPoint::SpawnPoint(BaseObject* creator) : PositionableEntity(creator)
     40    SpawnPoint::SpawnPoint(BaseObject* creator) : StaticEntity(creator)
    4141    {
    4242        RegisterObject(SpawnPoint);

  • code/branches/physics/src/orxonox/objects/worldentities/SpawnPoint.h

    r2087 r2300  
    3434#include "core/Identifier.h"
    3535#include "core/Template.h"
    36 #include "PositionableEntity.h"
    3736#include "objects/worldentities/pawns/Pawn.h"
     37#include "objects/worldentities/StaticEntity.h"
    3838
    3939namespace orxonox
    4040{
    41     class _OrxonoxExport SpawnPoint : public PositionableEntity
     41    class _OrxonoxExport SpawnPoint : public StaticEntity
    4242    {
    4343        public:

  • code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc

    r2298 r2300  
    6060    }
    6161
    62     bool StaticEntity::isCollisionTypeLegal(WorldEntity::CollisionType type)
     62    bool StaticEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
    6363    {
    6464        if (type == WorldEntity::Static)
    … …  
    7373    void StaticEntity::setWorldTransform(const btTransform& worldTrans)
    7474    {
    75         OrxAssert(false, "Setting world transform of a StaticEntity, which is static!");
     75        OrxAssert(false, "Setting world transform of a StaticEntity, which is CF_STATIC!");
    7676        //COUT(0) << "Setting world transform of a StaticEntity, which is static!" << std::endl;
    7777    }

  • code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h

    r2298 r2300  
    7474        private:
    7575
    76             bool isCollisionTypeLegal(CollisionType type);
     76            bool isCollisionTypeLegal(CollisionType type) const;
    7777
    7878            // Bullet btMotionState related

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

    r2298 r2300  
    192192    }
    193193
    194     float WorldEntity::getMass()
     194    float WorldEntity::getMass() const
    195195    {
    196196        if (!checkPhysics())
    197197            return 0.0f;
    198198
    199         return 1.0f/this->physicalBody_->getInvMass();
     199        if (this->physicalBody_->getInvMass() == 0.0f)
     200            return 0.0f;
     201        else
     202            return 1.0f/this->physicalBody_->getInvMass();
    200203    }
    201204
    … …  
    221224        if (type != None && this->collisionType_ == None)
    222225        {
     226            // First, check whether our SceneNode is relative to the root space of the scene.
     227            // TODO: Static and Kinematic objects don't always have to obey this rule.
     228            if (this->node_->getParent() != this->getScene()->getRootSceneNode())
     229                ThrowException(PhysicsViolation, "Cannot make WorldEntity physical that is not in the root space of the Scene.");
     230
    223231            // Create new rigid body
    224232            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, 0, btVector3(0,0,0));
    … …  
    227235
    228236            // Adjust parameters according to the node
    229             btTransform nodeTransform;
     237            //btTransform nodeTransform;
    230238            //this->
    231239        }
    … …  
    303311    }
    304312
    305     std::string WorldEntity::getCollisionTypeStr()
     313    std::string WorldEntity::getCollisionTypeStr() const
    306314    {
    307315        switch (this->getCollisionType())
    … …  
    334342    }
    335343
    336     float WorldEntity::getCollisionRadius()
     344    float WorldEntity::getCollisionRadius() const
    337345    {
    338346        if (checkPhysics())
    … …  
    345353    }
    346354
    347     bool WorldEntity::checkPhysics()
     355    bool WorldEntity::checkPhysics() const
    348356    {
    349357        if (!this->physicalBody_)

  • code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h

    r2298 r2300  
    168168            std::set<WorldEntity*> children_;
    169169
    170             /////////////
    171             // Physics //
    172             /////////////
     170
     171        /////////////
     172        // Physics //
     173        /////////////
    173174
    174175        public:
    … …  
    181182            };
    182183
    183             bool hasPhysics() { return getCollisionType() != None; }
    184 
    185             CollisionType getCollisionType() { return this->collisionType_; }
     184            bool hasPhysics() const { return getCollisionType() != None; }
     185
     186            CollisionType getCollisionType() const { return this->collisionType_; }
    186187            void setCollisionType(CollisionType type);
    187188
    188189            void setCollisionTypeStr(const std::string& type);
    189             std::string getCollisionTypeStr();
    190 
    191             bool isStatic()    { return getCollisionType() == Static   ; }
    192             bool isKinematic() { return getCollisionType() == Kinematic; }
    193             bool isDynamic()   { return getCollisionType() == Dynamic  ; }
     190            std::string getCollisionTypeStr() const;
     191
     192            bool isStatic()    const { return getCollisionType() == Static   ; }
     193            bool isKinematic() const { return getCollisionType() == Kinematic; }
     194            bool isDynamic()   const { return getCollisionType() == Dynamic  ; }
    194195
    195196            void setMass(float mass);
    196             float getMass();
     197            float getMass() const;
    197198
    198199            void setCollisionRadius(float radius);
    199             float getCollisionRadius();
     200            float getCollisionRadius() const;
    200201
    201202        protected:
    … …  
    203204            //virtual void attachPhysicalObject(WorldEntity* object);
    204205
    205             virtual bool isCollisionTypeLegal(CollisionType type) = 0;
    206             bool checkPhysics();
     206            virtual bool isCollisionTypeLegal(CollisionType type) const = 0;
     207            bool checkPhysics() const;
    207208            void updateCollisionType();
    208209

  • code/branches/physics/src/orxonox/objects/worldentities/triggers/Trigger.cc

    r2296 r2300  
    4444  CreateFactory(Trigger);
    4545
    46   Trigger::Trigger(BaseObject* creator) : PositionableEntity(creator)
     46  Trigger::Trigger(BaseObject* creator) : StaticEntity(creator)
    4747  {
    4848    RegisterObject(Trigger);

  • code/branches/physics/src/orxonox/objects/worldentities/triggers/Trigger.h

    r2103 r2300  
    3636
    3737#include "objects/Tickable.h"
    38 #include "objects/worldentities/PositionableEntity.h"
     38#include "objects/worldentities/StaticEntity.h"
    3939#include "tools/BillboardSet.h"
    4040
    … …  
    4848  };
    4949
    50   class _OrxonoxExport Trigger : public PositionableEntity, public Tickable
     50  class _OrxonoxExport Trigger : public StaticEntity, public Tickable
    5151  {
    5252    public:
Note: See TracChangeset for help on using the changeset viewer.