rename SceneQueryMode in CollisionMode

engine/lua/LuaPhysicsWorld.cpp

@@ -65,7 +65,7 @@ CE_EXPORT int physics_world_make_raycast(lua_State* L)
 	int mode = stack.get_int(3);
 	int filter = stack.get_int(4);
 
-	RaycastId raycast = world->create_raycast(callback, (SceneQueryMode::Enum) mode, (CollisionType::Enum) filter);
+	RaycastId raycast = world->create_raycast(callback, (CollisionMode::Enum) mode, (CollisionType::Enum) filter);
 
 	stack.push_raycast(world->lookup_raycast(raycast));
 	return 1;
@@ -124,9 +124,9 @@ void load_physics_world(LuaEnvironment& env)
 	env.load_module_enum("SceneQueryType", "OVERLAP",				SceneQueryType::OVERLAP);
 
 	// SceneQuery modes
-	env.load_module_enum("SceneQueryMode", "CLOSEST",				SceneQueryMode::CLOSEST);
-	env.load_module_enum("SceneQueryMode", "ANY",					SceneQueryMode::ANY);
-	env.load_module_enum("SceneQueryMode", "ALL",					SceneQueryMode::ALL);
+	env.load_module_enum("CollisionMode", "CLOSEST",				CollisionMode::CLOSEST);
+	env.load_module_enum("CollisionMode", "ANY",					CollisionMode::ANY);
+	env.load_module_enum("CollisionMode", "ALL",					CollisionMode::ALL);
 
 	// SceneQuery filters
 	env.load_module_enum("CollisionType", "STATIC",					CollisionType::STATIC);

engine/physics/PhysicsTypes.h

@@ -118,34 +118,34 @@ struct CollisionGroup
 };
 
 //-----------------------------------------------------------------------------
-struct SceneQueryType
+struct CollisionType
 {
 	enum Enum
 	{
-		RAYCAST,
-		OVERLAP
+		STATIC,
+		DYNAMIC,
+		BOTH
 	};
 };
 
 //-----------------------------------------------------------------------------
-struct SceneQueryMode
+struct SceneQueryType
 {
 	enum Enum
 	{
-		CLOSEST,
-		ANY,
-		ALL
+		RAYCAST,
+		OVERLAP
 	};
 };
 
 //-----------------------------------------------------------------------------
-struct CollisionType
+struct CollisionMode
 {
 	enum Enum
 	{
-		STATIC,
-		DYNAMIC,
-		BOTH
+		CLOSEST,
+		ANY,
+		ALL
 	};
 };
 
@@ -180,7 +180,7 @@ struct SceneQueryEvent
 {
 	const char*				callback;
 	SceneQueryType::Enum	type;
-	SceneQueryMode::Enum	mode;
+	CollisionMode::Enum	mode;
 	bool					hit;
 	Vector3					position;
 	float					distance;

engine/physics/PhysicsWorld.cpp

@@ -308,7 +308,7 @@ void PhysicsWorld::destroy_joint(JointId id)
 }
 
 //-----------------------------------------------------------------------------
-RaycastId PhysicsWorld::create_raycast(const char* callback, SceneQueryMode::Enum mode, CollisionType::Enum filter)
+RaycastId PhysicsWorld::create_raycast(const char* callback, CollisionMode::Enum mode, CollisionType::Enum filter)
 {
 	Raycast* raycast = CE_NEW(m_raycasts_pool, Raycast)(m_scene, m_events, callback, mode, filter);
 	return m_raycasts.create(raycast);

engine/physics/PhysicsWorld.h

@@ -92,7 +92,7 @@ public:
 	JointId						create_joint(const PhysicsResource* pr, const uint32_t index, const Actor& actor_0, const Actor& actor_1);
 	void						destroy_joint(JointId id);
 
-	RaycastId					create_raycast(const char* callback, SceneQueryMode::Enum mode, CollisionType::Enum filter);
+	RaycastId					create_raycast(const char* callback, CollisionMode::Enum mode, CollisionType::Enum filter);
 	void						destroy_raycast(RaycastId id);
 
 	Actor*						lookup_actor(StringId32 name);

engine/physics/Raycast.cpp

@@ -35,7 +35,7 @@ namespace crown
 {
 
 //-------------------------------------------------------------------------
-Raycast::Raycast(PxScene* scene, EventStream& events, const char* callback, SceneQueryMode::Enum mode, CollisionType::Enum filter)
+Raycast::Raycast(PxScene* scene, EventStream& events, const char* callback, CollisionMode::Enum mode, CollisionType::Enum filter)
 	: m_scene(scene)
 	, m_buffer(m_hits, CE_MAX_RAY_INTERSECTIONS)
 	, m_events(events)
@@ -52,9 +52,9 @@ Raycast::Raycast(PxScene* scene, EventStream& events, const char* callback, Scen
 
 	switch (m_mode)
 	{
-		case SceneQueryMode::CLOSEST: break;
-		case SceneQueryMode::ANY: m_fd.flags |= PxQueryFlag::eANY_HIT; break;
-		case SceneQueryMode::ALL: break;
+		case CollisionMode::CLOSEST: break;
+		case CollisionMode::ANY: m_fd.flags |= PxQueryFlag::eANY_HIT; break;
+		case CollisionMode::ALL: break;
 	}
 }
 

engine/physics/Raycast.h

@@ -49,15 +49,15 @@ struct Actor;
 struct Raycast
 {
 	/// Constructor
-			Raycast(PxScene* scene, EventStream& events, const char* callback, SceneQueryMode::Enum mode, CollisionType::Enum filter);
+			Raycast(PxScene* scene, EventStream& events, const char* callback, CollisionMode::Enum mode, CollisionType::Enum filter);
 
 	/// Performs a raycast against objects in the scene. The ray is casted from position @a from, has direction @a dir and is long @a length
 	/// If any actor is hit along the ray, @a EventStream is filled according to @a mode previously specified and callback will be called for processing.
-	/// @a SceneQueryMode::ANY: the callback is called with just true or false depending on whether the ray hit anything or not.
-	/// @a SceneQueryMode::CLOSEST: the first argument will tell if there was a hit or not, as before. 
+	/// @a CollisionMode::ANY: the callback is called with just true or false depending on whether the ray hit anything or not.
+	/// @a CollisionMode::CLOSEST: the first argument will tell if there was a hit or not, as before. 
 	/// If there was a hit, the callback will also be called with the position of the hit, the distance from the origin, the normal of the surface that 
 	/// was hit and the actor that was hit.
-	/// @a SceneQueryMode::ALL: as @a SceneQueryMode::CLOSEST, with more tuples
+	/// @a CollisionMode::ALL: as @a CollisionMode::CLOSEST, with more tuples
 	void	cast(const Vector3& from, const Vector3& dir, const float length);
 
 	Actor*	sync_cast(const Vector3& from, const Vector3& dir, const float length);
@@ -72,7 +72,7 @@ private:
 	EventStream&			m_events;
 	const char*				m_callback;
 
-	SceneQueryMode::Enum		m_mode;
+	CollisionMode::Enum		m_mode;
 	CollisionType::Enum		m_filter;
 };