Tearing apart PhysicActor

apps/openmw/mwworld/physicssystem.cpp

@@ -254,12 +254,12 @@ namespace MWWorld
     }
 
     void PhysicsSystem::addActor (const std::string& handle, const std::string& mesh,
-        const Ogre::Vector3& position)
+        const Ogre::Vector3& position, float scale, const Ogre::Quaternion& rotation)
     {
         //TODO:optimize this. Searching the std::map isn't very efficient i think.
-        mEngine->addCharacter(handle);
+        mEngine->addCharacter(handle, mesh, position, scale, rotation);
         OEngine::Physic::PhysicActor* act = mEngine->getCharacter(handle);
-        act->setPosition(btVector3(position.x,position.y,position.z));
+        
     }
 
     void PhysicsSystem::removeObject (const std::string& handle)
@@ -272,11 +272,12 @@ namespace MWWorld
 
     void PhysicsSystem::moveObject (const std::string& handle, Ogre::SceneNode* node)
     {
+        Ogre::Vector3 position = node->getPosition();
         if (OEngine::Physic::RigidBody* body = mEngine->getRigidBody(handle))
         {
             // TODO very dirty hack to avoid crash during setup -> needs cleaning up to allow
             // start positions others than 0, 0, 0
-            Ogre::Vector3 position = node->getPosition();
+            
             
             if(dynamic_cast<btBoxShape*>(body->getCollisionShape()) == NULL){
                 btTransform tr = body->getWorldTransform();
@@ -288,7 +289,7 @@ namespace MWWorld
         }
         if (OEngine::Physic::PhysicActor* act = mEngine->getCharacter(handle))
         {
-            /*// TODO very dirty hack to avoid crash during setup -> needs cleaning up to allow
+            // TODO very dirty hack to avoid crash during setup -> needs cleaning up to allow
             // start positions others than 0, 0, 0
             if (handle == "player")
             {
@@ -297,19 +298,20 @@ namespace MWWorld
             else
             {
                 act->setPosition(btVector3(position.x,position.y,position.z));
-            }*/
+            }
         }
     }
 
     void PhysicsSystem::rotateObject (const std::string& handle, Ogre::SceneNode* node)
     {
-        /*if (OEngine::Physic::PhysicActor* act = mEngine->getCharacter(handle))
+        Ogre::Quaternion rotation = node->getOrientation();
+        if (OEngine::Physic::PhysicActor* act = mEngine->getCharacter(handle))
         {
+            //Needs to be changed
             act->setRotation(btQuaternion(rotation.x, rotation.y, rotation.z, rotation.w));
-        }*/
+        }
         if (OEngine::Physic::RigidBody* body = mEngine->getRigidBody(handle))
         {
-            Ogre::Quaternion rotation = node->getOrientation();
             if(dynamic_cast<btBoxShape*>(body->getCollisionShape()) == NULL)
                 body->getWorldTransform().setRotation(btQuaternion(rotation.x, rotation.y, rotation.z, rotation.w));
             else
@@ -380,7 +382,7 @@ namespace MWWorld
 
     void PhysicsSystem::insertActorPhysics(const MWWorld::Ptr& ptr, const std::string model){
         Ogre::SceneNode* node = ptr.getRefData().getBaseNode();
-        addActor (node->getName(), model, node->getPosition());
+        addActor (node->getName(), model, node->getPosition(), node->getScale().x, node->getOrientation());
     }
 
     bool PhysicsSystem::getObjectAABB(const MWWorld::Ptr &ptr, Ogre::Vector3 &min, Ogre::Vector3 &max)

apps/openmw/mwworld/physicssystem.hpp

@@ -24,7 +24,7 @@ namespace MWWorld
                 const Ogre::Quaternion& rotation, float scale, const Ogre::Vector3& position);
 
             void addActor (const std::string& handle, const std::string& mesh,
-                const Ogre::Vector3& position);
+                const Ogre::Vector3& position, float scale, const Ogre::Quaternion& rotation);
 
             void addHeightField (float* heights,
                 int x, int y, float yoffset,

apps/openmw/mwworld/worldimp.cpp

@@ -189,7 +189,7 @@ namespace MWWorld
         mPlayer = new MWWorld::Player (mStore.npcs.find ("player"), *this);
         mRendering->attachCameraTo(mPlayer->getPlayer());
 
-        mPhysics->addActor (mPlayer->getPlayer().getRefData().getHandle(), "", Ogre::Vector3 (0, 0, 0));
+        mPhysics->addActor (mPlayer->getPlayer().getRefData().getHandle(), "", Ogre::Vector3 (0, 0, 0), 0, Ogre::Quaternion::ZERO);
 
         // global variables
         mGlobalVariables = new Globals (mStore);

libs/openengine/bullet/physic.cpp

@@ -26,111 +26,71 @@ namespace Physic
         COL_RAYCASTING = BIT(3)
     };
 
-    PhysicActor::PhysicActor(std::string name)
+    PhysicActor::PhysicActor(std::string name, std::string mesh, PhysicEngine* engine, Ogre::Vector3 position, Ogre::Quaternion rotation, float scale): 
+        mName(name), mEngine(engine), mMesh(mesh), mBoxTranslation(Ogre::Vector3::ZERO), mBoxRotation(Ogre::Quaternion::ZERO), mBody(0)
     {
-        mName = name;
 
         // The capsule is at the origin
         btTransform transform;
         transform.setIdentity();
 
-        // External capsule
-        externalGhostObject = new PairCachingGhostObject(name);
-        externalGhostObject->setWorldTransform( transform );
-
-        btScalar externalCapsuleHeight = 120;
-        btScalar externalCapsuleWidth = 19;
-
-        externalCollisionShape = new btCapsuleShapeZ( externalCapsuleWidth,  externalCapsuleHeight );
-        externalCollisionShape->setMargin( 0.1 );
-
-        externalGhostObject->setCollisionShape( externalCollisionShape );
-        externalGhostObject->setCollisionFlags( btCollisionObject::CF_CHARACTER_OBJECT );
-
-        // Internal capsule
-        internalGhostObject = new PairCachingGhostObject(name);
-        internalGhostObject->setWorldTransform( transform );
-        //internalGhostObject->getBroadphaseHandle()->s
-        btScalar internalCapsuleHeight =  110;
-        btScalar internalCapsuleWidth =  17;
-
-        internalCollisionShape = new btCapsuleShapeZ( internalCapsuleWidth, internalCapsuleHeight );
-        internalCollisionShape->setMargin( 0.1 );
-
-        internalGhostObject->setCollisionShape( internalCollisionShape );
-        internalGhostObject->setCollisionFlags( btCollisionObject::CF_CHARACTER_OBJECT );
-
-        mCharacter = new btKinematicCharacterController( externalGhostObject,internalGhostObject,btScalar( 40 ),1,4,20,9.8,0.2 );
-        mCharacter->setUpAxis(btKinematicCharacterController::Z_AXIS);
-        mCharacter->setUseGhostSweepTest(false);
-
-        mCharacter->mCollision = false;
-        setGravity(0);
-
-        mTranslation = btVector3(0,0,70);
     }
 
     PhysicActor::~PhysicActor()
     {
-        delete mCharacter;
+        if(mBody){
-        delete internalGhostObject;
+            mEngine->dynamicsWorld->removeRigidBody(mBody);
-        delete internalCollisionShape;
+            delete mBody;
-        delete externalGhostObject;
+        }
-        delete externalCollisionShape;
     }
 
     void PhysicActor::setGravity(float gravity)
     {
-        mCharacter->setGravity(gravity);
+        
-        //mCharacter->
     }
 
     void PhysicActor::enableCollisions(bool collision)
     {
-        mCharacter->mCollision = collision;
+       
     }
 
     void PhysicActor::setVerticalVelocity(float z)
     {
-        mCharacter->setVerticalVelocity(z);
+        
     }
 
     bool PhysicActor::getCollisionMode()
     {
-        return mCharacter->mCollision;
+        return false;
     }
 
     void PhysicActor::setWalkDirection(const btVector3& mvt)
     {
-        mCharacter->setWalkDirection( mvt );
+        
     }
 
-    void PhysicActor::Rotate(const btQuaternion& quat)
+    
-    {
-        externalGhostObject->getWorldTransform().setRotation( externalGhostObject->getWorldTransform().getRotation() * quat );
-        internalGhostObject->getWorldTransform().setRotation( internalGhostObject->getWorldTransform().getRotation() * quat );
-    }
 
     void PhysicActor::setRotation(const btQuaternion& quat)
     {
-        externalGhostObject->getWorldTransform().setRotation( quat );
+        //externalGhostObject->getWorldTransform().setRotation( quat );
-        internalGhostObject->getWorldTransform().setRotation( quat );
+        //internalGhostObject->getWorldTransform().setRotation( quat );
     }
 
     btVector3 PhysicActor::getPosition(void)
     {
-        return internalGhostObject->getWorldTransform().getOrigin() -mTranslation;
+        return btVector3(0,0,0);//return internalGhostObject->getWorldTransform().getOrigin() -mTranslation;
     }
 
     btQuaternion PhysicActor::getRotation(void)
     {
-        return internalGhostObject->getWorldTransform().getRotation();
+        return btQuaternion(0,0,0);//return btQuaternion::internalGhostObject->getWorldTransform().getRotation();
     }
 
     void PhysicActor::setPosition(const btVector3& pos)
     {
-        internalGhostObject->getWorldTransform().setOrigin(pos+mTranslation);
+        //internalGhostObject->getWorldTransform().setOrigin(pos+mTranslation);
-        externalGhostObject->getWorldTransform().setOrigin(pos+mTranslation);
+        //externalGhostObject->getWorldTransform().setOrigin(pos+mTranslation);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -247,9 +207,7 @@ namespace Physic
         {
             if (pa_it->second != NULL)
             {
-                dynamicsWorld->removeCollisionObject(pa_it->second->externalGhostObject);
+                
-                dynamicsWorld->removeCollisionObject(pa_it->second->internalGhostObject);
-                dynamicsWorld->removeAction(pa_it->second->mCharacter);
 
                 delete pa_it->second;
                 pa_it->second = NULL;
@@ -477,16 +435,17 @@ namespace Physic
         }
     }
 
-    void PhysicEngine::addCharacter(std::string name)
+    void PhysicEngine::addCharacter(std::string name, std::string mesh,
+        Ogre::Vector3 position, float scale, Ogre::Quaternion rotation)
     {
         // Remove character with given name, so we don't make memory
         // leak when character would be added twice
         removeCharacter(name);
 
-        PhysicActor* newActor = new PhysicActor(name);
+        PhysicActor* newActor = new PhysicActor(name, mesh, this, position, rotation, scale);
-        dynamicsWorld->addCollisionObject( newActor->externalGhostObject, COL_ACTOR_EXTERNAL, COL_WORLD |COL_ACTOR_EXTERNAL );
+        
-        dynamicsWorld->addCollisionObject( newActor->internalGhostObject, COL_ACTOR_INTERNAL, COL_WORLD |COL_ACTOR_INTERNAL );
+
-        dynamicsWorld->addAction( newActor->mCharacter );
+        //dynamicsWorld->addAction( newActor->mCharacter );
         PhysicActorMap[name] = newActor;
     }
 
@@ -499,20 +458,7 @@ namespace Physic
             PhysicActor* act = it->second;
             if(act != NULL)
             {
-                /*broadphase->getOverlappingPairCache()->removeOverlappingPairsContainingProxy(act->externalGhostObject->getBroadphaseHandle(),dispatcher);
+                
-                  broadphase->getOverlappingPairCache()->removeOverlappingPairsContainingProxy(act->internalGhostObject->getBroadphaseHandle(),dispatcher);
-                  PhysicActorContainer::iterator it2 = PhysicActorMap.begin();
-                  for(;it2!=PhysicActorMap.end();it++)
-                  {
-                  it->second->internalGhostObject->getOverlappingPairCache()->removeOverlappingPairsContainingProxy(act->externalGhostObject->getBroadphaseHandle(),dispatcher);
-                  it->second->externalGhostObject->getOverlappingPairCache()->removeOverlappingPairsContainingProxy(act->externalGhostObject->getBroadphaseHandle(),dispatcher);
-                  it->second->internalGhostObject->getOverlappingPairCache()->removeOverlappingPairsContainingProxy(act->internalGhostObject->getBroadphaseHandle(),dispatcher);
-                  it->second->externalGhostObject->getOverlappingPairCache()->removeOverlappingPairsContainingProxy(act->internalGhostObject->getBroadphaseHandle(),dispatcher);
-                  }*/
-                //act->externalGhostObject->
-                dynamicsWorld->removeCollisionObject(act->externalGhostObject);
-                dynamicsWorld->removeCollisionObject(act->internalGhostObject);
-                dynamicsWorld->removeAction(act->mCharacter);
                 delete act;
             }
             PhysicActorMap.erase(it);

libs/openengine/bullet/physic.hpp

@@ -15,7 +15,6 @@ class btDefaultCollisionConfiguration;
 class btSequentialImpulseConstraintSolver;
 class btCollisionDispatcher;
 class btDiscreteDynamicsWorld;
-class btKinematicCharacterController;
 class btHeightfieldTerrainShape;
 
 namespace BtOgre
@@ -33,6 +32,8 @@ namespace Physic
 {
     class CMotionState;
     struct PhysicEvent;
+    class PhysicEngine;
+    class RigidBody;
 
     /**
     *This is just used to be able to name objects.
@@ -55,7 +56,7 @@ namespace Physic
     class PhysicActor
     {
     public:
-        PhysicActor(std::string name);
+        PhysicActor(std::string name, std::string mesh, PhysicEngine *engine, Ogre::Vector3 position, Ogre::Quaternion rotation, float scale);
 
         ~PhysicActor();
 
@@ -66,8 +67,6 @@ namespace Physic
          */
         void setWalkDirection(const btVector3& mvt);
 
-        void Rotate(const btQuaternion& quat);
-
         void setRotation(const btQuaternion& quat);
 
         void setGravity(float gravity);
@@ -84,21 +83,17 @@ namespace Physic
 
         void setPosition(const btVector3& pos);
 
-        btKinematicCharacterController* mCharacter;
        
-        PairCachingGhostObject* internalGhostObject;
-        btCollisionShape* internalCollisionShape;
-
-        PairCachingGhostObject* externalGhostObject;
-        btCollisionShape* externalCollisionShape;
 
         std::string mName;
 
-        /**
+
-        *NPC scenenode is located on there feet, and you can't simply translate a btShape, so this vector is used
+    private:
-        *each time get/setposition is called.
+        OEngine::Physic::RigidBody* mBody;
-        */
+        Ogre::Vector3 mBoxTranslation;
-        btVector3 mTranslation;
+        Ogre::Quaternion mBoxRotation;
+        std::string mMesh;
+        PhysicEngine* mEngine;
     };
 
     /**
@@ -195,7 +190,8 @@ namespace Physic
         /**
          * Create and add a character to the scene, and add it to the ActorMap.
          */
-        void addCharacter(std::string name);
+        void addCharacter(std::string name, std::string mesh,
+        Ogre::Vector3 position, float scale, Ogre::Quaternion rotation);
 
         /**
          * Remove a character from the scene. TODO:delete it! for now, a small memory leak^^ done?