Changeset 2442 for code/branches/physics_merge/src/orxonox/objects/Scene.cc

Timestamp:

Dec 14, 2008, 4:16:52 PM (16 years ago)

Author:

rgrieder

Message:

Finally merged physics stuff. Target is physics_merge because I'll have to do some testing first.

Location:

code/branches/physics_merge

Files:

• . (modified) (1 prop)
• src/orxonox/objects/Scene.cc (modified) (7 diffs)

code/branches/physics_merge/src/orxonox/objects/Scene.cc

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Reto Grieder (physics)
  *
  */
@@ -35 +35 @@
 #include <OgreLight.h>
 
+#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h"
+#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+
 #include "core/CoreIncludes.h"
 #include "core/Core.h"
 #include "core/XMLPort.h"
+#include "tools/BulletConversions.h"
+#include "objects/worldentities/WorldEntity.h"
 
 namespace orxonox
@@ -69 +76 @@
             this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
         }
+
+        // No physics for default
+        this->physicalWorld_ = 0;
 
         // test test test
@@ -91 +101 @@
             if (Ogre::Root::getSingletonPtr())
             {
-//                this->sceneManager_->destroySceneNode(this->rootSceneNode_->getName()); // TODO: remove getName() for newer versions of Ogre
                 Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
             }
@@ -109 +118 @@
         XMLPortParam(Scene, "shadow", setShadow, getShadow, xmlelement, mode).defaultValues(true);
 
+        //const int defaultMaxWorldSize = 100000;
+        //Vector3 worldAabbMin(-defaultMaxWorldSize, -defaultMaxWorldSize, -defaultMaxWorldSize);
+        //Vector3 worldAabbMax( defaultMaxWorldSize,  defaultMaxWorldSize,  defaultMaxWorldSize);
+        //XMLPortParamVariable(Scene, "negativeWorldRange", worldAabbMin, xmlelement, mode);
+        //XMLPortParamVariable(Scene, "positiveWorldRange", worldAabbMax, xmlelement, mode);
+        XMLPortParam(Scene, "hasPhysics", setPhysicalWorld, hasPhysics, xmlelement, mode).defaultValue(0, true);//.defaultValue(1, worldAabbMin).defaultValue(2, worldAabbMax);
+
         XMLPortObjectExtended(Scene, BaseObject, "", addObject, getObject, xmlelement, mode, true, false);
     }
@@ -114 +130 @@
     void Scene::registerVariables()
     {
-        registerVariable(this->skybox_,     variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applySkybox));
+        registerVariable(this->skybox_,       variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applySkybox));
         registerVariable(this->ambientLight_, variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applyAmbientLight));
+        registerVariable(this->bHasPhysics_,  variableDirection::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_hasPhysics));
+    }
+
+    void Scene::setPhysicalWorld(bool wantPhysics)//, const Vector3& worldAabbMin, const Vector3& worldAabbMax)
+    {
+        this->bHasPhysics_ = wantPhysics;
+        if (wantPhysics && !hasPhysics())
+        {
+            //float x = worldAabbMin.x;
+            //float y = worldAabbMin.y;
+            //float z = worldAabbMin.z;
+            btVector3 worldAabbMin(-100000, -100000, -100000);
+            //x = worldAabbMax.x;
+            //y = worldAabbMax.y;
+            //z = worldAabbMax.z;
+            btVector3 worldAabbMax(100000, 100000, 100000);
+
+            btDefaultCollisionConfiguration*     collisionConfig = new btDefaultCollisionConfiguration();
+            btCollisionDispatcher*               dispatcher      = new btCollisionDispatcher(collisionConfig);
+            bt32BitAxisSweep3*                   broadphase      = new bt32BitAxisSweep3(worldAabbMin,worldAabbMax);
+            btSequentialImpulseConstraintSolver* solver          = new btSequentialImpulseConstraintSolver;
+
+            this->physicalWorld_ =  new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfig);
+
+            // Disable Gravity for space
+            this->physicalWorld_->setGravity(btVector3(0,0,0));
+        }
+        else
+        {
+            // TODO: Destroy Bullet physics
+        }
+    }
+
+    void Scene::tick(float dt)
+    {
+        if (!Core::showsGraphics())
+        {
+            // We need to update the scene nodes if we don't render
+            this->rootSceneNode_->_update(true, false);
+        }
+        if (physicalWorld_)
+        {
+            if (this->physicsQueue_.size() > 0)
+            {
+                // Add all scheduled WorldEntities
+                for (std::set<btRigidBody*>::const_iterator it = this->physicsQueue_.begin();
+                    it != this->physicsQueue_.end(); ++it)
+                {
+                    if (!(*it)->isInWorld())
+                    {
+                        //COUT(0) << "body position: " << omni_cast<Vector3>((*it)->getWorldTransform().getOrigin()) << std::endl;
+                        //COUT(0) << "body velocity: " << omni_cast<Vector3>((*it)->getLinearVelocity()) << std::endl;
+                        //COUT(0) << "body orientation: " << omni_cast<Quaternion>((*it)->getWorldTransform().getRotation()) << std::endl;
+                        //COUT(0) << "body angular: " << omni_cast<Vector3>((*it)->getAngularVelocity()) << std::endl;
+                        //COUT(0) << "body mass: " << omni_cast<float>((*it)->getInvMass()) << std::endl;
+                        //COUT(0) << "body inertia: " << omni_cast<Vector3>((*it)->getInvInertiaDiagLocal()) << std::endl;
+                        this->physicalWorld_->addRigidBody(*it);
+                    }
+                }
+                this->physicsQueue_.clear();
+            }
+
+            // TODO: This is not stable! If physics cannot be calculated real time anymore,
+            //       framerate will drop exponentially.
+            physicalWorld_->stepSimulation(dt,(int)(dt/0.0166666f + 1.0f));
+        }
     }
 
@@ -165 +247 @@
     }
 
-    void Scene::tick(float dt)
-    {
-        if (!Core::showsGraphics())
-        {
-            // We need to update the scene nodes if we don't render
-            this->rootSceneNode_->_update(true, false);
+    void Scene::addRigidBody(btRigidBody* body)
+    {
+        if (!this->physicalWorld_)
+            COUT(1) << "Error: Cannot add WorldEntity body to physical Scene: No physics." << std::endl;
+        else if (body)
+            this->physicsQueue_.insert(body);
+    }
+
+    void Scene::removeRigidBody(btRigidBody* body)
+    {
+        if (!this->physicalWorld_)
+            COUT(1) << "Error: Cannot remove WorldEntity body from physical Scene: No physics." << std::endl;
+        else if (body)
+        {
+            this->physicalWorld_->removeRigidBody(body);
+            // Also check queue
+            std::set<btRigidBody*>::iterator it = this->physicsQueue_.find(body);
+            if (it != this->physicsQueue_.end())
+                this->physicsQueue_.erase(it);
         }
     }