Physics

include/anki/physics/PhysWorld.h

@@ -36,6 +36,8 @@ public:
 
 	void setDebugDrawer(btIDebugDraw* newDebugDrawer);
 
+	void debugDraw();
+
 	/// Time as always in sec
 	void update(F32 prevUpdateTime, F32 crntTime);
 

include/anki/renderer/Dbg.h

@@ -30,6 +30,15 @@ public:
 		depthTest = enable;
 	}
 
+	DebugDrawer& getDebugDrawer()
+	{
+		return *drawer;
+	}
+	const DebugDrawer& getDebugDrawer() const
+	{
+		return *drawer;
+	}
+
 private:
 	Fbo fbo;
 	std::unique_ptr<DebugDrawer> drawer;

include/anki/scene/Scene.h

@@ -8,6 +8,7 @@
 #include "anki/scene/Sector.h"
 #include "anki/util/Vector.h"
 #include "anki/core/Timestamp.h"
+#include "anki/physics/PhysWorld.h"
 
 namespace anki {
 
@@ -17,8 +18,6 @@ class Renderer;
 /// @{
 
 /// The Scene contains all the dynamic entities
-///
-/// XXX Add physics
 class Scene
 {
 	friend class SceneNode;
@@ -74,35 +73,41 @@ public:
 		return activeCameraChangeTimestamp;
 	}
 
-	Types<SceneNode>::ConstIterator getAllNodesBegin() const
+	Types<SceneNode>::ConstIterator getSceneNodesBegin() const
 	{
 		return nodes.begin();
 	}
-	Types<SceneNode>::Iterator getAllNodesBegin()
+	Types<SceneNode>::Iterator getSceneNodesBegin()
 	{
 		return nodes.begin();
 	}
-	Types<SceneNode>::ConstIterator getAllNodesEnd() const
+	Types<SceneNode>::ConstIterator getSceneNodesEnd() const
 	{
 		return nodes.end();
 	}
-	Types<SceneNode>::Iterator getAllNodesEnd()
+	Types<SceneNode>::Iterator getSceneNodesEnd()
 	{
 		return nodes.end();
 	}
-	U32 getAllNodesCount() const
+	U32 getSceneNodesCount() const
 	{
 		return nodes.size();
 	}
+
+	PhysWorld& getPhysics()
+	{
+		return physics;
+	}
+	const PhysWorld& getPhysics() const
+	{
+		return physics;
+	}
 	/// @}
 
 	void update(float prevUpdateTime, float crntTime, Renderer& renderer);
 
-	SceneNode* findSceneNode(const char* name)
-	{
-		Types<SceneNode>::NameToItemMap::iterator it = nameToNode.find(name);
-		return (it == nameToNode.end()) ? nullptr : it->second;
-	}
+	SceneNode& findSceneNode(const char* name);
+	SceneNode* tryFindSceneNode(const char* name);
 
 	PtrVector<Sector> sectors;
 
@@ -116,6 +121,7 @@ private:
 	Types<SceneNode>::NameToItemMap nameToNode;
 
 	VisibilityTester vtester;
+	PhysWorld physics;
 
 	void doVisibilityTests(Camera& cam, Renderer& r);
 

src/physics/PhysWorld.cpp

@@ -47,4 +47,10 @@ void PhysWorld::update(F32 prevUpdateTime, F32 crntTime)
 	}
 }
 
+//==============================================================================
+void PhysWorld::debugDraw()
+{
+	dynamicsWorld->debugDrawWorld();
+}
+
 } // end namespace anki

src/physics/RigidBody.cpp

@@ -36,7 +36,7 @@ RigidBody::RigidBody(PhysWorld* masterContainer_, const Initializer& init)
 	setContactProcessingThreshold(
 		masterContainer->defaultContactProcessingThreshold);
 
-	forceActivationState(ISLAND_SLEEPING);
+	//forceActivationState(ISLAND_SLEEPING);
 
 	// register
 	if(init.mask == -1 || init.group == -1)

src/renderer/Dbg.cpp

@@ -57,7 +57,7 @@ void Dbg::run()
 	drawer->setModelMatrix(Mat4::getIdentity());
 	//drawer->drawGrid();
 
-	for(auto it = scene.getAllNodesBegin(); it != scene.getAllNodesEnd(); it++)
+	for(auto it = scene.getSceneNodesBegin(); it != scene.getSceneNodesEnd(); it++)
 	{
 		SceneNode* node = *it;
 		Spatial* sp = node->getSpatial();
@@ -72,6 +72,8 @@ void Dbg::run()
 		sceneDrawer->draw(sector->getOctree());
 	}
 
+	scene.getPhysics().debugDraw();
+
 	drawer->flush();
 }
 

src/renderer/Drawer.cpp

@@ -171,12 +171,12 @@ void RenderableDrawer::render(const Frustumable& fr, uint pass,
 	setupShaderProg(key, fr, renderable);
 
 	// Render
-	U32 indecesNum = renderable.getModelPatchBase().getIndecesCount(0);
+	U32 indecesCount = renderable.getModelPatchBase().getIndecesCount(0);
 
 	const Vao& vao = renderable.getModelPatchBase().getVao(key);
 	ANKI_ASSERT(vao.getAttachmentsCount() > 1);
 	vao.bind();
-	glDrawElements(GL_TRIANGLES, indecesNum, GL_UNSIGNED_SHORT, 0);
+	glDrawElements(GL_TRIANGLES, indecesCount, GL_UNSIGNED_SHORT, 0);
 }
 
 }  // end namespace anki

src/scene/ModelNode.cpp

@@ -33,10 +33,9 @@ ModelNode::ModelNode(const char* modelFname,
 	uint i = 0;
 	for(const ModelPatch* patch : model->getModelPatches())
 	{
-		std::string name = model.getResourceName()
-			+ std::to_string(i);
+		std::string name_ = name + std::to_string(i);
 
-		ModelPatchNode* mpn = new ModelPatchNode(patch, name.c_str(),
+		ModelPatchNode* mpn = new ModelPatchNode(patch, name_.c_str(),
 			scene, Movable::MF_IGNORE_LOCAL_TRANSFORM, this);
 
 		patches.push_back(mpn);

src/scene/Scene.cpp

@@ -32,6 +32,8 @@ void Scene::unregisterNode(SceneNode* node)
 //==============================================================================
 void Scene::update(float prevUpdateTime, float crntTime, Renderer& r)
 {
+	physics.update(prevUpdateTime, crntTime);
+
 	// First do the movable updates
 	for(SceneNode* n : nodes)
 	{
@@ -98,4 +100,18 @@ void Scene::doVisibilityTests(Camera& cam, Renderer& r)
 	vtester.test(*f, *this, r);
 }
 
+//==============================================================================
+SceneNode& Scene::findSceneNode(const char* name)
+{
+	ANKI_ASSERT(nameToNode.find(name) != nameToNode.end());
+	return *(nameToNode.find(name)->second);
+}
+
+//==============================================================================
+SceneNode* Scene::tryFindSceneNode(const char* name)
+{
+	Types<SceneNode>::NameToItemMap::iterator it = nameToNode.find(name);
+	return (it == nameToNode.end()) ? nullptr : it->second;
+}
+
 } // end namespace anki

src/scene/VisibilityTester.cpp

@@ -210,7 +210,7 @@ VisibilityTester::~VisibilityTester()
 void VisibilityTester::test(Frustumable& ref, Scene& scene, Renderer& r)
 {
 	// Set all spatials to not visible
-	for(auto it = scene.getAllNodesBegin(); it != scene.getAllNodesEnd(); ++it)
+	for(auto it = scene.getSceneNodesBegin(); it != scene.getSceneNodesEnd(); ++it)
 	{
 		Spatial* sp = (*it)->getSpatial();
 
@@ -232,8 +232,8 @@ void VisibilityTester::test(Frustumable& ref, Scene& scene, Renderer& r)
 
 	for(U i = 0; i < threadPool.getThreadsCount(); i++)
 	{
-		jobs[i].nodesCount = scene.getAllNodesCount();
-		jobs[i].nodes = scene.getAllNodesBegin();
+		jobs[i].nodesCount = scene.getSceneNodesCount();
+		jobs[i].nodes = scene.getSceneNodesBegin();
 		jobs[i].renderablesMtx = &renderablesMtx;
 		jobs[i].lightsMtx = &lightsMtx;
 		jobs[i].frustumable = &ref;

testapp/Main.cpp

@@ -43,6 +43,80 @@ ModelNode* horse;
 PerspectiveCamera* cam;
 NativeWindow* win;
 
+//==============================================================================
+void initPhysics()
+{
+	Scene& scene = SceneSingleton::get();
+
+	scene.getPhysics().setDebugDrawer(
+		new PhysicsDebugDrawer(
+			&MainRendererSingleton::get().getDbg().getDebugDrawer()));
+
+	btCollisionShape* groundShape = new btBoxShape(
+	    btVector3(btScalar(50.), btScalar(50.), btScalar(50.)));
+
+	Transform groundTransform;
+	groundTransform.setIdentity();
+	groundTransform.setOrigin(Vec3(0, -50, 0));
+
+	RigidBody::Initializer init;
+	init.mass = 0.0;
+	init.shape = groundShape;
+	init.startTrf = groundTransform;
+	init.group = PhysWorld::CG_MAP;
+	init.mask = PhysWorld::CG_ALL;
+
+	new RigidBody(&SceneSingleton::get().getPhysics(), init);
+
+	btCollisionShape* colShape = new btBoxShape(
+	    btVector3(1, 1, 1));
+
+	init.startTrf.setOrigin(Vec3(0.0, 15.0, 0.0));
+	init.mass = 1;
+	init.shape = colShape;
+	init.group = PhysWorld::CG_PARTICLE;
+	init.mask = PhysWorld::CG_MAP;
+
+	const U ARRAY_SIZE_X = 5;
+	const U ARRAY_SIZE_Y = 5;
+	const U ARRAY_SIZE_Z = 5;
+	const U START_POS_X = -5;
+	const U START_POS_Y = 15;
+	const U START_POS_Z = -3;
+
+	float start_x = START_POS_X - ARRAY_SIZE_X / 2;
+	float start_y = START_POS_Y;
+	float start_z = START_POS_Z - ARRAY_SIZE_Z / 2;
+
+	for(U k = 0; k < ARRAY_SIZE_Y; k++)
+	{
+		for(U i = 0; i < ARRAY_SIZE_X; i++)
+		{
+			for(U j = 0; j < ARRAY_SIZE_Z; j++)
+			{
+				std::string name = std::string("crate0") + std::to_string(i)
+					+ std::to_string(j) + std::to_string(k);
+
+				new ModelNode(
+					"data/models/crate0/crate0.mdl",
+					name.c_str(),
+					&SceneSingleton::get(), Movable::MF_NONE, nullptr);
+
+				init.movable = scene.findSceneNode((name + "0").c_str()).getMovable();
+				ANKI_ASSERT(init.movable);
+
+				Transform trf(
+					Vec3(2.0 * i + start_x, 2.0 * k + start_y,
+						2.0 * j + start_z), Mat3::getIdentity(), 1.0);
+
+				init.startTrf = trf;
+
+				new RigidBody(&SceneSingleton::get().getPhysics(), init);
+			}
+		}
+	}
+}
+
 //==============================================================================
 void init()
 {
@@ -63,7 +137,7 @@ void init()
 	cam->setAll(
 		MainRendererSingleton::get().getAspectRatio() * toRad(ang),
 		toRad(ang), 0.5, 500.0);
-	cam->setLocalTransform(Transform(Vec3(88.0, 5.0, 8.0),
+	cam->setLocalTransform(Transform(Vec3(82.0, 5.0, 8.0),
 		Mat3(Euler(toRad(-10.0), toRad(90.0), toRad(0.0))),
 		1.0));
 	scene.setActiveCamera(cam);
@@ -167,6 +241,8 @@ void init()
 		"sponza", &scene, Movable::MF_NONE, nullptr);
 
 	(void)sponzaModel;
+
+	initPhysics();
 }
 
 //==============================================================================
@@ -212,15 +288,15 @@ void mainLoopExtra()
 	}
 	if(in.getKey(KC_2))
 	{
-		mover = SceneSingleton::get().findSceneNode("horse")->getMovable();
+		mover = SceneSingleton::get().findSceneNode("horse").getMovable();
 	}
 	if(in.getKey(KC_3))
 	{
-		mover = SceneSingleton::get().findSceneNode("spot0")->getMovable();
+		mover = SceneSingleton::get().findSceneNode("spot0").getMovable();
 	}
 	if(in.getKey(KC_4))
 	{
-		mover = SceneSingleton::get().findSceneNode("spot1")->getMovable();
+		mover = SceneSingleton::get().findSceneNode("spot1").getMovable();
 	}
 	/*if(in.getKey(KC_5))
 	{
@@ -228,13 +304,13 @@ void mainLoopExtra()
 	}*/
 	if(in.getKey(KC_6))
 	{
-		mover = SceneSingleton::get().findSceneNode("camera1")->getMovable();
+		mover = SceneSingleton::get().findSceneNode("camera1").getMovable();
 		mover->setLocalTransform(cam->getLocalTransform());
 	}
 
 	if(in.getKey(KC_L) == 1)
 	{
-		Light* l = SceneSingleton::get().findSceneNode("point1")->getLight();
+		Light* l = SceneSingleton::get().findSceneNode("point1").getLight();
 		static_cast<PointLight*>(l)->setRadius(10.0);
 	}
 
@@ -312,7 +388,7 @@ void mainLoop()
 
 		// Sleep
 		//
-#if 0
+#if 1
 		timer.stop();
 		if(timer.getElapsedTime() < AppSingleton::get().getTimerTick())
 		{
@@ -373,7 +449,7 @@ void initSubsystems(int argc, char* argv[])
 	// Main renderer
 	RendererInitializer initializer;
 	initializer.ms.ez.enabled = true;
-	initializer.dbg.enabled = false;
+	initializer.dbg.enabled = true;
 	initializer.is.sm.bilinearEnabled = true;
 	initializer.is.sm.enabled = true;
 	initializer.is.sm.pcfEnabled = false;