Move physics object, heightfield, ptrholder into separate files

apps/openmw/CMakeLists.txt

@@ -70,7 +70,7 @@ add_openmw_dir (mwworld
     )
 
 add_openmw_dir (mwphysics
-    physicssystem trace collisiontype actor convert
+    physicssystem trace collisiontype actor convert object heightfield
     )
 
 add_openmw_dir (mwclass

apps/openmw/mwphysics/actor.hpp

@@ -3,7 +3,7 @@
 
 #include <memory>
 
-#include "../mwworld/ptr.hpp"
+#include "ptrholder.hpp"
 
 #include <osg/Vec3f>
 #include <osg/Quat>
@@ -22,30 +22,6 @@ namespace Resource
 namespace MWPhysics
 {
 
-    class PtrHolder
-    {
-    public:
-        virtual ~PtrHolder() {}
-
-        void updatePtr(const MWWorld::Ptr& updated)
-        {
-            mPtr = updated;
-        }
-
-        MWWorld::Ptr getPtr()
-        {
-            return mPtr;
-        }
-
-        MWWorld::ConstPtr getPtr() const
-        {
-            return mPtr;
-        }
-
-    protected:
-        MWWorld::Ptr mPtr;
-    };
-
     class Actor : public PtrHolder
     {
     public:

apps/openmw/mwphysics/heightfield.cpp

@@ -0,0 +1,54 @@
+#include "heightfield.hpp"
+
+#include <osg/Object>
+
+#include <BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h>
+#include <BulletCollision/CollisionDispatch/btCollisionObject.h>
+
+#include <LinearMath/btTransform.h>
+
+namespace MWPhysics
+{
+    HeightField::HeightField(const float* heights, int x, int y, float triSize, float sqrtVerts, float minH, float maxH, const osg::Object* holdObject)
+    {
+        mShape = new btHeightfieldTerrainShape(
+            sqrtVerts, sqrtVerts, heights, 1,
+            minH, maxH, 2,
+            PHY_FLOAT, false
+        );
+        mShape->setUseDiamondSubdivision(true);
+        mShape->setLocalScaling(btVector3(triSize, triSize, 1));
+
+        btTransform transform(btQuaternion::getIdentity(),
+                                btVector3((x+0.5f) * triSize * (sqrtVerts-1),
+                                          (y+0.5f) * triSize * (sqrtVerts-1),
+                                          (maxH+minH)*0.5f));
+
+        mCollisionObject = new btCollisionObject;
+        mCollisionObject->setCollisionShape(mShape);
+        mCollisionObject->setWorldTransform(transform);
+
+        mHoldObject = holdObject;
+    }
+
+    HeightField::~HeightField()
+    {
+        delete mCollisionObject;
+        delete mShape;
+    }
+
+    btCollisionObject* HeightField::getCollisionObject()
+    {
+        return mCollisionObject;
+    }
+
+    const btCollisionObject* HeightField::getCollisionObject() const
+    {
+        return mCollisionObject;
+    }
+
+    const btHeightfieldTerrainShape* HeightField::getShape() const
+    {
+        return mShape;
+    }
+}

apps/openmw/mwphysics/heightfield.hpp

@@ -0,0 +1,36 @@
+#ifndef OPENMW_MWPHYSICS_HEIGHTFIELD_H
+#define OPENMW_MWPHYSICS_HEIGHTFIELD_H
+
+#include <osg/ref_ptr>
+
+class btCollisionObject;
+class btHeightfieldTerrainShape;
+
+namespace osg
+{
+    class Object;
+}
+
+namespace MWPhysics
+{
+    class HeightField
+    {
+    public:
+        HeightField(const float* heights, int x, int y, float triSize, float sqrtVerts, float minH, float maxH, const osg::Object* holdObject);
+        ~HeightField();
+
+        btCollisionObject* getCollisionObject();
+        const btCollisionObject* getCollisionObject() const;
+        const btHeightfieldTerrainShape* getShape() const;
+
+    private:
+        btHeightfieldTerrainShape* mShape;
+        btCollisionObject* mCollisionObject;
+        osg::ref_ptr<const osg::Object> mHoldObject;
+
+        void operator=(const HeightField&);
+        HeightField(const HeightField&);
+    };
+}
+
+#endif

apps/openmw/mwphysics/object.cpp

@@ -0,0 +1,130 @@
+#include "object.hpp"
+#include "convert.hpp"
+
+#include <components/debug/debuglog.hpp>
+#include <components/nifosg/particle.hpp>
+#include <components/resource/bulletshape.hpp>
+#include <components/sceneutil/positionattitudetransform.hpp>
+
+#include <osg/Object>
+
+#include <BulletCollision/CollisionShapes/btCompoundShape.h>
+#include <BulletCollision/CollisionDispatch/btCollisionObject.h>
+#include <BulletCollision/CollisionDispatch/btCollisionWorld.h>
+
+#include <LinearMath/btTransform.h>
+
+namespace MWPhysics
+{
+    Object::Object(const MWWorld::Ptr& ptr, osg::ref_ptr<Resource::BulletShapeInstance> shapeInstance)
+        : mShapeInstance(shapeInstance)
+        , mSolid(true)
+    {
+        mPtr = ptr;
+
+        mCollisionObject.reset(new btCollisionObject);
+        mCollisionObject->setCollisionShape(shapeInstance->getCollisionShape());
+
+        mCollisionObject->setUserPointer(static_cast<PtrHolder*>(this));
+
+        setScale(ptr.getCellRef().getScale());
+        setRotation(toBullet(ptr.getRefData().getBaseNode()->getAttitude()));
+        const float* pos = ptr.getRefData().getPosition().pos;
+        setOrigin(btVector3(pos[0], pos[1], pos[2]));
+    }
+
+    const Resource::BulletShapeInstance* Object::getShapeInstance() const
+    {
+        return mShapeInstance.get();
+    }
+
+    void Object::setScale(float scale)
+    {
+        mShapeInstance->getCollisionShape()->setLocalScaling(btVector3(scale,scale,scale));
+    }
+
+    void Object::setRotation(const btQuaternion& quat)
+    {
+        mCollisionObject->getWorldTransform().setRotation(quat);
+    }
+
+    void Object::setOrigin(const btVector3& vec)
+    {
+        mCollisionObject->getWorldTransform().setOrigin(vec);
+    }
+
+    btCollisionObject* Object::getCollisionObject()
+    {
+        return mCollisionObject.get();
+    }
+
+    const btCollisionObject* Object::getCollisionObject() const
+    {
+        return mCollisionObject.get();
+    }
+
+    bool Object::isSolid() const
+    {
+        return mSolid;
+    }
+
+    void Object::setSolid(bool solid)
+    {
+        mSolid = solid;
+    }
+
+    bool Object::isAnimated() const
+    {
+        return !mShapeInstance->mAnimatedShapes.empty();
+    }
+
+    void Object::animateCollisionShapes(btCollisionWorld* collisionWorld)
+    {
+        if (mShapeInstance->mAnimatedShapes.empty())
+            return;
+
+        assert (mShapeInstance->getCollisionShape()->isCompound());
+
+        btCompoundShape* compound = static_cast<btCompoundShape*>(mShapeInstance->getCollisionShape());
+        for (std::map<int, int>::const_iterator it = mShapeInstance->mAnimatedShapes.begin(); it != mShapeInstance->mAnimatedShapes.end(); ++it)
+        {
+            int recIndex = it->first;
+            int shapeIndex = it->second;
+
+            std::map<int, osg::NodePath>::iterator nodePathFound = mRecIndexToNodePath.find(recIndex);
+            if (nodePathFound == mRecIndexToNodePath.end())
+            {
+                NifOsg::FindGroupByRecIndex visitor(recIndex);
+                mPtr.getRefData().getBaseNode()->accept(visitor);
+                if (!visitor.mFound)
+                {
+                    Log(Debug::Warning) << "Warning: animateCollisionShapes can't find node " << recIndex << " for " << mPtr.getCellRef().getRefId();
+
+                    // Remove nonexistent nodes from animated shapes map and early out
+                    mShapeInstance->mAnimatedShapes.erase(recIndex);
+                    return;
+                }
+                osg::NodePath nodePath = visitor.mFoundPath;
+                nodePath.erase(nodePath.begin());
+                nodePathFound = mRecIndexToNodePath.insert(std::make_pair(recIndex, nodePath)).first;
+            }
+
+            osg::NodePath& nodePath = nodePathFound->second;
+            osg::Matrixf matrix = osg::computeLocalToWorld(nodePath);
+            matrix.orthoNormalize(matrix);
+
+            btTransform transform;
+            transform.setOrigin(toBullet(matrix.getTrans()) * compound->getLocalScaling());
+            for (int i=0; i<3; ++i)
+                for (int j=0; j<3; ++j)
+                    transform.getBasis()[i][j] = matrix(j,i); // NB column/row major difference
+
+            // Note: we can not apply scaling here for now since we treat scaled shapes
+            // as new shapes (btScaledBvhTriangleMeshShape) with 1.0 scale for now
+            if (!(transform == compound->getChildTransform(shapeIndex)))
+                compound->updateChildTransform(shapeIndex, transform);
+        }
+
+        collisionWorld->updateSingleAabb(mCollisionObject.get());
+    }
+}

apps/openmw/mwphysics/object.hpp

@@ -0,0 +1,48 @@
+#ifndef OPENMW_MWPHYSICS_OBJECT_H
+#define OPENMW_MWPHYSICS_OBJECT_H
+
+#include "ptrholder.hpp"
+
+#include <osg/Node>
+
+#include <map>
+#include <memory>
+
+namespace Resource
+{
+    class BulletShapeInstance;
+}
+
+class btCollisionObject;
+class btCollisionWorld;
+class btQuaternion;
+class btVector3;
+
+namespace MWPhysics
+{
+    class Object : public PtrHolder
+    {
+    public:
+        Object(const MWWorld::Ptr& ptr, osg::ref_ptr<Resource::BulletShapeInstance> shapeInstance);
+
+        const Resource::BulletShapeInstance* getShapeInstance() const;
+        void setScale(float scale);
+        void setRotation(const btQuaternion& quat);
+        void setOrigin(const btVector3& vec);
+        btCollisionObject* getCollisionObject();
+        const btCollisionObject* getCollisionObject() const;
+        /// Return solid flag. Not used by the object itself, true by default.
+        bool isSolid() const;
+        void setSolid(bool solid);
+        bool isAnimated() const;
+        void animateCollisionShapes(btCollisionWorld* collisionWorld);
+
+    private:
+        std::unique_ptr<btCollisionObject> mCollisionObject;
+        osg::ref_ptr<Resource::BulletShapeInstance> mShapeInstance;
+        std::map<int, osg::NodePath> mRecIndexToNodePath;
+        bool mSolid;
+    };
+}
+
+#endif

apps/openmw/mwphysics/physicssystem.cpp

@@ -48,6 +48,8 @@
 #include "actor.hpp"
 #include "convert.hpp"
 #include "trace.h"
+#include "object.hpp"
+#include "heightfield.hpp"
 
 namespace MWPhysics
 {
@@ -507,175 +509,6 @@ namespace MWPhysics
 
     // ---------------------------------------------------------------
 
-    class HeightField
-    {
-    public:
-        HeightField(const float* heights, int x, int y, float triSize, float sqrtVerts, float minH, float maxH, const osg::Object* holdObject)
-        {
-            mShape = new btHeightfieldTerrainShape(
-                sqrtVerts, sqrtVerts, heights, 1,
-                minH, maxH, 2,
-                PHY_FLOAT, false
-            );
-            mShape->setUseDiamondSubdivision(true);
-            mShape->setLocalScaling(btVector3(triSize, triSize, 1));
-
-            btTransform transform(btQuaternion::getIdentity(),
-                                  btVector3((x+0.5f) * triSize * (sqrtVerts-1),
-                                            (y+0.5f) * triSize * (sqrtVerts-1),
-                                            (maxH+minH)*0.5f));
-
-            mCollisionObject = new btCollisionObject;
-            mCollisionObject->setCollisionShape(mShape);
-            mCollisionObject->setWorldTransform(transform);
-
-            mHoldObject = holdObject;
-        }
-        ~HeightField()
-        {
-            delete mCollisionObject;
-            delete mShape;
-        }
-        btCollisionObject* getCollisionObject()
-        {
-            return mCollisionObject;
-        }
-
-    private:
-        btHeightfieldTerrainShape* mShape;
-        btCollisionObject* mCollisionObject;
-        osg::ref_ptr<const osg::Object> mHoldObject;
-
-        void operator=(const HeightField&);
-        HeightField(const HeightField&);
-    };
-
-    // --------------------------------------------------------------
-
-    class Object : public PtrHolder
-    {
-    public:
-        Object(const MWWorld::Ptr& ptr, osg::ref_ptr<Resource::BulletShapeInstance> shapeInstance)
-            : mShapeInstance(shapeInstance)
-            , mSolid(true)
-        {
-            mPtr = ptr;
-
-            mCollisionObject.reset(new btCollisionObject);
-            mCollisionObject->setCollisionShape(shapeInstance->getCollisionShape());
-
-            mCollisionObject->setUserPointer(static_cast<PtrHolder*>(this));
-
-            setScale(ptr.getCellRef().getScale());
-            setRotation(toBullet(ptr.getRefData().getBaseNode()->getAttitude()));
-            const float* pos = ptr.getRefData().getPosition().pos;
-            setOrigin(btVector3(pos[0], pos[1], pos[2]));
-        }
-
-        const Resource::BulletShapeInstance* getShapeInstance() const
-        {
-            return mShapeInstance.get();
-        }
-
-        void setScale(float scale)
-        {
-            mShapeInstance->getCollisionShape()->setLocalScaling(btVector3(scale,scale,scale));
-        }
-
-        void setRotation(const btQuaternion& quat)
-        {
-            mCollisionObject->getWorldTransform().setRotation(quat);
-        }
-
-        void setOrigin(const btVector3& vec)
-        {
-            mCollisionObject->getWorldTransform().setOrigin(vec);
-        }
-
-        btCollisionObject* getCollisionObject()
-        {
-            return mCollisionObject.get();
-        }
-
-        const btCollisionObject* getCollisionObject() const
-        {
-            return mCollisionObject.get();
-        }
-
-        /// Return solid flag. Not used by the object itself, true by default.
-        bool isSolid() const
-        {
-            return mSolid;
-        }
-
-        void setSolid(bool solid)
-        {
-            mSolid = solid;
-        }
-
-        bool isAnimated() const
-        {
-            return !mShapeInstance->mAnimatedShapes.empty();
-        }
-
-        void animateCollisionShapes(btCollisionWorld* collisionWorld)
-        {
-            if (mShapeInstance->mAnimatedShapes.empty())
-                return;
-
-            assert (mShapeInstance->getCollisionShape()->isCompound());
-
-            btCompoundShape* compound = static_cast<btCompoundShape*>(mShapeInstance->getCollisionShape());
-            for (std::map<int, int>::const_iterator it = mShapeInstance->mAnimatedShapes.begin(); it != mShapeInstance->mAnimatedShapes.end(); ++it)
-            {
-                int recIndex = it->first;
-                int shapeIndex = it->second;
-
-                std::map<int, osg::NodePath>::iterator nodePathFound = mRecIndexToNodePath.find(recIndex);
-                if (nodePathFound == mRecIndexToNodePath.end())
-                {
-                    NifOsg::FindGroupByRecIndex visitor(recIndex);
-                    mPtr.getRefData().getBaseNode()->accept(visitor);
-                    if (!visitor.mFound)
-                    {
-                        Log(Debug::Warning) << "Warning: animateCollisionShapes can't find node " << recIndex << " for " << mPtr.getCellRef().getRefId();
-
-                        // Remove nonexistent nodes from animated shapes map and early out
-                        mShapeInstance->mAnimatedShapes.erase(recIndex);
-                        return;
-                    }
-                    osg::NodePath nodePath = visitor.mFoundPath;
-                    nodePath.erase(nodePath.begin());
-                    nodePathFound = mRecIndexToNodePath.insert(std::make_pair(recIndex, nodePath)).first;
-                }
-
-                osg::NodePath& nodePath = nodePathFound->second;
-                osg::Matrixf matrix = osg::computeLocalToWorld(nodePath);
-                matrix.orthoNormalize(matrix);
-
-                btTransform transform;
-                transform.setOrigin(toBullet(matrix.getTrans()) * compound->getLocalScaling());
-                for (int i=0; i<3; ++i)
-                    for (int j=0; j<3; ++j)
-                        transform.getBasis()[i][j] = matrix(j,i); // NB column/row major difference
-
-                // Note: we can not apply scaling here for now since we treat scaled shapes
-                // as new shapes (btScaledBvhTriangleMeshShape) with 1.0 scale for now
-                if (!(transform == compound->getChildTransform(shapeIndex)))
-                    compound->updateChildTransform(shapeIndex, transform);
-            }
-
-            collisionWorld->updateSingleAabb(mCollisionObject.get());
-        }
-
-    private:
-        std::unique_ptr<btCollisionObject> mCollisionObject;
-        osg::ref_ptr<Resource::BulletShapeInstance> mShapeInstance;
-        std::map<int, osg::NodePath> mRecIndexToNodePath;
-        bool mSolid;
-    };
-
-    // ---------------------------------------------------------------
 
     PhysicsSystem::PhysicsSystem(Resource::ResourceSystem* resourceSystem, osg::ref_ptr<osg::Group> parentNode)
         : mShapeManager(new Resource::BulletShapeManager(resourceSystem->getVFS(), resourceSystem->getSceneManager(), resourceSystem->getNifFileManager()))

apps/openmw/mwphysics/ptrholder.hpp

@@ -0,0 +1,33 @@
+#ifndef OPENMW_MWPHYSICS_PTRHOLDER_H
+#define OPENMW_MWPHYSICS_PTRHOLDER_H
+
+#include "../mwworld/ptr.hpp"
+
+namespace MWPhysics
+{
+    class PtrHolder
+    {
+    public:
+        virtual ~PtrHolder() {}
+
+        void updatePtr(const MWWorld::Ptr& updated)
+        {
+            mPtr = updated;
+        }
+
+        MWWorld::Ptr getPtr()
+        {
+            return mPtr;
+        }
+
+        MWWorld::ConstPtr getPtr() const
+        {
+            return mPtr;
+        }
+
+    protected:
+        MWWorld::Ptr mPtr;
+    };
+}
+
+#endif