Implement create/destroy/lookup_controller()

engine/World.cpp

@@ -132,6 +132,12 @@ Actor* World::lookup_actor(ActorId actor)
 	return m_physics_world.lookup_actor(actor);
 }
 
+//-----------------------------------------------------------------------------
+Controller* World::lookup_controller(ControllerId controller)
+{
+	return m_physics_world.lookup_controller(controller);
+}
+
 //-----------------------------------------------------------------------------
 void World::update(float dt)
 {
@@ -214,6 +220,18 @@ void World::destroy_actor(ActorId id)
 	m_physics_world.destroy_actor(id);
 }
 
+//-----------------------------------------------------------------------------
+ControllerId World::create_controller(const PhysicsResource* pr)
+{
+	return m_physics_world.create_controller(pr);
+}
+
+//-----------------------------------------------------------------------------
+void World::destroy_controller(ControllerId id)
+{
+	m_physics_world.destroy_controller(id);
+}
+
 //-----------------------------------------------------------------------------
 SoundId World::play_sound(const char* name, const bool loop, const float volume, const Vector3& pos, const float range)
 {

engine/World.h

@@ -78,6 +78,7 @@ class Sprite;
 class Actor;
 class Vector3;
 class Quaternion;
+struct PhysicsResource;
 
 class World
 {
@@ -97,6 +98,7 @@ public:
 	Mesh*								lookup_mesh(MeshId mesh);
 	Sprite*								lookup_sprite(SpriteId sprite);
 	Actor*								lookup_actor(ActorId actor);
+	Controller*							lookup_controller(ControllerId controller);
 
 	void								update(float dt);
 	void								render(Camera* camera);
@@ -113,6 +115,9 @@ public:
 	ActorId								create_actor(SceneGraph& sg, int32_t node, ActorType::Enum type);
 	void								destroy_actor(ActorId id);
 
+	ControllerId						create_controller(const PhysicsResource* pr);
+	void								destroy_controller(ControllerId id);
+
 	SoundId								play_sound(const char* name, const bool loop = false, const float volume = 1.0f, const Vector3& pos = Vector3::ZERO, const float range = 50.0f);
 	void								stop_sound(SoundId sound);
 	void								link_sound(SoundId sound, Unit* unit, int32_t node);

engine/physics/PhysicsWorld.cpp

@@ -31,6 +31,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Physics.h"
 #include "Quaternion.h"
 #include "SceneGraph.h"
+#include "Controller.h"
 
 #include "PxPhysicsAPI.h"
 
@@ -56,8 +57,11 @@ static physx::PxSimulationFilterShader g_default_filter_shader = physx::PxDefaul
 //-----------------------------------------------------------------------------
 PhysicsWorld::PhysicsWorld()
 	: m_scene(NULL)
-	, m_actor_pool(default_allocator(), MAX_ACTORS, sizeof(Actor), CE_ALIGNOF(Actor))
+	, m_actors_pool(default_allocator(), MAX_ACTORS, sizeof(Actor), CE_ALIGNOF(Actor))
+	, m_controllers_pool(default_allocator(), MAX_CONTROLLERS, sizeof(Controller), CE_ALIGNOF(Controller))
 {
+	m_controller_manager = PxCreateControllerManager(device()->physx()->getFoundation());
+
 	PxSceneDesc scene_desc(device()->physx()->getTolerancesScale());
 	scene_desc.gravity = PxVec3(0.0f, -9.81f, 0.0f);
 
@@ -94,31 +98,53 @@ PhysicsWorld::~PhysicsWorld()
 //-----------------------------------------------------------------------------
 ActorId	PhysicsWorld::create_actor(SceneGraph& sg, int32_t node, ActorType::Enum type)
 {
-	Actor* actor = CE_NEW(m_actor_pool, Actor)(sg, node, type, Vector3::ZERO, Quaternion::IDENTITY);
+	Actor* actor = CE_NEW(m_actors_pool, Actor)(sg, node, type, Vector3::ZERO, Quaternion::IDENTITY);
 	m_scene->addActor(*actor->m_actor);
 
-	return m_actor.create(actor);
+	return m_actors.create(actor);
 }
 
 //-----------------------------------------------------------------------------
 void PhysicsWorld::destroy_actor(ActorId id)
 {
-	CE_ASSERT(m_actor.has(id), "Actor does not exist");
+	CE_ASSERT(m_actors.has(id), "Actor does not exist");
 
-	Actor* actor = m_actor.lookup(id);
-	CE_DELETE(m_actor_pool, actor);
+	Actor* actor = m_actors.lookup(id);
+	CE_DELETE(m_actors_pool, actor);
 
 	m_scene->removeActor(*actor->m_actor);
 
-	m_actor.destroy(id);
+	m_actors.destroy(id);
+}
+
+//-----------------------------------------------------------------------------
+ControllerId PhysicsWorld::create_controller(const PhysicsResource* pr)
+{
+	Controller* controller = CE_NEW(m_controllers_pool, Controller)(pr, m_scene, m_controller_manager);
+	return m_controllers.create(controller);
+}
+
+//-----------------------------------------------------------------------------
+void PhysicsWorld::destroy_controller(ControllerId id)
+{
+	CE_ASSERT(m_controllers.has(id), "Controller does not exist");
+
+	CE_DELETE(m_controllers_pool, m_controllers.lookup(id));
+	m_controllers.destroy(id);
 }
 
 //-----------------------------------------------------------------------------
 Actor* PhysicsWorld::lookup_actor(ActorId id)
 {
-	CE_ASSERT(m_actor.has(id), "Actor does not exist");
+	CE_ASSERT(m_actors.has(id), "Actor does not exist");
+	return m_actors.lookup(id);
+}
 
-	return m_actor.lookup(id);
+//-----------------------------------------------------------------------------
+Controller* PhysicsWorld::lookup_controller(ControllerId id)
+{
+	CE_ASSERT(m_controllers.has(id), "Controller does not exist");
+	return m_controllers.lookup(id);
 }
 
 //-----------------------------------------------------------------------------
@@ -137,6 +163,12 @@ void PhysicsWorld::set_gravity(const Vector3& g)
 //-----------------------------------------------------------------------------
 void PhysicsWorld::update()
 {
+	// Update world pose of the actors
+	for (Actor** aa = m_actors.begin(); aa != m_actors.end(); aa++)
+	{
+		(*aa)->update_pose();
+	}
+
 	// Run with fixed timestep
 	m_scene->simulate(1.0 / 60.0);
 

engine/physics/PhysicsWorld.h

@@ -32,14 +32,23 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #include "PxScene.h"
 #include "PxDefaultCpuDispatcher.h"
+#include "PxControllerManager.h"
+
+using physx::PxControllerManager;
+using physx::PxScene;
+using physx::PxDefaultCpuDispatcher;
 
 #define MAX_ACTORS 1024
+#define MAX_CONTROLLERS 1024
 
 namespace crown
 {
 
 typedef Id ActorId;
+typedef Id ControllerId;
 
+struct PhysicsResource;
+struct Controller;
 class Vector3;
 class Actor;
 class SceneGraph;
@@ -49,26 +58,34 @@ class PhysicsWorld
 {
 public:
 
-				PhysicsWorld();
-				~PhysicsWorld();
+								PhysicsWorld();
+								~PhysicsWorld();
+
+	ActorId						create_actor(SceneGraph& sg, int32_t node, ActorType::Enum type);
+	void						destroy_actor(ActorId id);
 
-	ActorId		create_actor(SceneGraph& sg, int32_t node, ActorType::Enum type);
-	void		destroy_actor(ActorId id);
+	ControllerId				create_controller(const PhysicsResource* pr);
+	void						destroy_controller(ControllerId id);
 
-	Actor*		lookup_actor(ActorId id);
+	Actor*						lookup_actor(ActorId id);
+	Controller*					lookup_controller(ControllerId id);
 
-	Vector3		gravity() const;
-	void		set_gravity(const Vector3& g);
+	Vector3						gravity() const;
+	void						set_gravity(const Vector3& g);
 
-	void		update();
+	void						update();
 
 public:
 
-	physx::PxScene* m_scene;
-	physx::PxDefaultCpuDispatcher* m_cpu_dispatcher;
+	PxControllerManager*		m_controller_manager;
+	PxScene*					m_scene;
+	PxDefaultCpuDispatcher*		m_cpu_dispatcher;
+	
+	PoolAllocator				m_actors_pool;
+	IdArray<MAX_ACTORS, Actor*>	m_actors;
 
-	PoolAllocator m_actor_pool;
-	IdArray<MAX_ACTORS, Actor*> m_actor;
+	PoolAllocator				m_controllers_pool;
+	IdArray<MAX_CONTROLLERS, Controller*> m_controllers;
 };
 
 } // namespace crown