Cleanup

src/lua/lua_api.cpp

@@ -1975,7 +1975,7 @@ static int physics_world_actor_instances(lua_State* L)
 	if (inst.i == UINT32_MAX)
 		stack.push_nil();
 	else
-		stack.push_actor(inst);
+		stack.actor_push(inst);
 
 	return 1;
 }
@@ -2001,24 +2001,24 @@ static int physics_world_actor_world_pose(lua_State* L)
 	return 1;
 }
 
-static int physics_world_teleport_actor_world_position(lua_State* L)
+static int physics_world_actor_teleport_world_position(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->teleport_actor_world_position(stack.get_actor(2), stack.get_vector3(3));
+	stack.get_physics_world(1)->actor_teleport_world_position(stack.get_actor(2), stack.get_vector3(3));
 	return 0;
 }
 
-static int physics_world_teleport_actor_world_rotation(lua_State* L)
+static int physics_world_actor_teleport_world_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->teleport_actor_world_rotation(stack.get_actor(2), stack.get_quaternion(3));
+	stack.get_physics_world(1)->actor_teleport_world_rotation(stack.get_actor(2), stack.get_quaternion(3));
 	return 0;
 }
 
-static int physics_world_teleport_actor_world_pose(lua_State* L)
+static int physics_world_actor_teleport_world_pose(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->teleport_actor_world_pose(stack.get_actor(2), stack.get_matrix4x4(3));
+	stack.get_physics_world(1)->actor_teleport_world_pose(stack.get_actor(2), stack.get_matrix4x4(3));
 	return 0;
 }
 
@@ -2029,80 +2029,80 @@ static int physics_world_actor_center_of_mass(lua_State* L)
 	return 1;
 }
 
-static int physics_world_enable_actor_gravity(lua_State* L)
+static int physics_world_actor_enable_gravity(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->enable_actor_gravity(stack.get_actor(2));
+	stack.get_physics_world(1)->actor_enable_gravity(stack.get_actor(2));
 	return 0;
 }
 
-static int physics_world_disable_actor_gravity(lua_State* L)
+static int physics_world_actor_disable_gravity(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->disable_actor_gravity(stack.get_actor(2));
+	stack.get_physics_world(1)->actor_disable_gravity(stack.get_actor(2));
 	return 0;
 }
 
-static int physics_world_enable_actor_collision(lua_State* L)
+static int physics_world_actor_enable_collision(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->enable_actor_collision(stack.get_actor(2));
+	stack.get_physics_world(1)->actor_enable_collision(stack.get_actor(2));
 	return 0;
 }
 
-static int physics_world_disable_actor_collision(lua_State* L)
+static int physics_world_actor_disable_collision(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->disable_actor_collision(stack.get_actor(2));
+	stack.get_physics_world(1)->actor_disable_collision(stack.get_actor(2));
 	return 0;
 }
 
-static int physics_world_set_actor_collision_filter(lua_State* L)
+static int physics_world_actor_set_collision_filter(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->set_actor_collision_filter(stack.get_actor(2), stack.get_string_id_32(3));
+	stack.get_physics_world(1)->actor_set_collision_filter(stack.get_actor(2), stack.get_string_id_32(3));
 	return 0;
 }
 
-static int physics_world_set_actor_kinematic(lua_State* L)
+static int physics_world_actor_set_kinematic(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->set_actor_kinematic(stack.get_actor(2), stack.get_bool(3));
+	stack.get_physics_world(1)->actor_set_kinematic(stack.get_actor(2), stack.get_bool(3));
 	return 0;
 }
 
-static int physics_world_move_actor(lua_State* L)
+static int physics_world_actor_move(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->move_actor(stack.get_actor(2), stack.get_vector3(3));
+	stack.get_physics_world(1)->actor_move(stack.get_actor(2), stack.get_vector3(3));
 	return 0;
 }
 
-static int physics_world_is_static(lua_State* L)
+static int physics_world_actor_is_static(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.push_bool(stack.get_physics_world(1)->is_static(stack.get_actor(2)));
+	stack.push_bool(stack.get_physics_world(1)->actor_is_static(stack.get_actor(2)));
 	return 1;
 }
 
-static int physics_world_is_dynamic(lua_State* L)
+static int physics_world_actor_is_dynamic(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.push_bool(stack.get_physics_world(1)->is_dynamic(stack.get_actor(2)));
+	stack.push_bool(stack.get_physics_world(1)->actor_is_dynamic(stack.get_actor(2)));
 	return 1;
 }
 
-static int physics_world_is_kinematic(lua_State* L)
+static int physics_world_actor_is_kinematic(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.push_bool(stack.get_physics_world(1)->is_kinematic(stack.get_actor(2)));
+	stack.push_bool(stack.get_physics_world(1)->actor_is_kinematic(stack.get_actor(2)));
 	return 1;
 }
 
-static int physics_world_is_nonkinematic(lua_State* L)
+static int physics_world_actor_is_nonkinematic(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.push_bool(stack.get_physics_world(1)->is_nonkinematic(stack.get_actor(2)));
+	stack.push_bool(stack.get_physics_world(1)->actor_is_nonkinematic(stack.get_actor(2)));
 	return 1;
 }
 
@@ -2114,10 +2114,10 @@ static int physics_world_actor_linear_damping(lua_State* L)
 	return 1;
 }
 
-static int physics_world_set_actor_linear_damping(lua_State* L)
+static int physics_world_actor_set_linear_damping(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->set_actor_linear_damping(stack.get_actor(2), stack.get_float(3));
+	stack.get_physics_world(1)->actor_set_linear_damping(stack.get_actor(2), stack.get_float(3));
 	return 0;
 }
 
@@ -2128,10 +2128,10 @@ static int physics_world_actor_angular_damping(lua_State* L)
 	return 1;
 }
 
-static int physics_world_set_actor_angular_damping(lua_State* L)
+static int physics_world_actor_set_angular_damping(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->set_actor_angular_damping(stack.get_actor(2), stack.get_float(3));
+	stack.get_physics_world(1)->actor_set_angular_damping(stack.get_actor(2), stack.get_float(3));
 	return 0;
 }
 
@@ -2142,10 +2142,10 @@ static int physics_world_actor_linear_velocity(lua_State* L)
 	return 1;
 }
 
-static int physics_world_set_actor_linear_velocity(lua_State* L)
+static int physics_world_actor_set_linear_velocity(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->set_actor_linear_velocity(stack.get_actor(2), stack.get_vector3(3));
+	stack.get_physics_world(1)->actor_set_linear_velocity(stack.get_actor(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -2156,59 +2156,59 @@ static int physics_world_actor_angular_velocity(lua_State* L)
 	return 1;
 }
 
-static int physics_world_set_actor_angular_velocity(lua_State* L)
+static int physics_world_actor_set_angular_velocity(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->set_actor_angular_velocity(stack.get_actor(2), stack.get_vector3(3));
+	stack.get_physics_world(1)->actor_set_angular_velocity(stack.get_actor(2), stack.get_vector3(3));
 	return 0;
 }
 
-static int physics_world_add_actor_impulse(lua_State* L)
+static int physics_world_actor_add_impulse(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->add_actor_impulse(stack.get_actor(2), stack.get_vector3(3));
+	stack.get_physics_world(1)->actor_add_impulse(stack.get_actor(2), stack.get_vector3(3));
 	return 0;
 }
 
-static int physics_world_add_actor_impulse_at(lua_State* L)
+static int physics_world_actor_add_impulse_at(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->add_actor_impulse_at(stack.get_actor(2), stack.get_vector3(3), stack.get_vector3(4));
+	stack.get_physics_world(1)->actor_add_impulse_at(stack.get_actor(2), stack.get_vector3(3), stack.get_vector3(4));
 	return 0;
 }
 
-static int physics_world_add_actor_torque_impulse(lua_State* L)
+static int physics_world_actor_add_actor_torque_impulse(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->add_actor_torque_impulse(stack.get_actor(2), stack.get_vector3(3));
+	stack.get_physics_world(1)->actor_add_torque_impulse(stack.get_actor(2), stack.get_vector3(3));
 	return 0;
 }
 
-static int physics_world_push_actor(lua_State* L)
+static int physics_world_actor_push(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->push_actor(stack.get_actor(2), stack.get_vector3(3), stack.get_float(4));
+	stack.get_physics_world(1)->actor_push(stack.get_actor(2), stack.get_vector3(3), stack.get_float(4));
 	return 0;
 }
 
-static int physics_world_push_actor_at(lua_State* L)
+static int physics_world_actor_push_at(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->push_actor_at(stack.get_actor(2), stack.get_vector3(3), stack.get_float(4), stack.get_vector3(5));
+	stack.get_physics_world(1)->actor_push_at(stack.get_actor(2), stack.get_vector3(3), stack.get_float(4), stack.get_vector3(5));
 	return 0;
 }
 
-static int physics_world_is_sleeping(lua_State* L)
+static int physics_world_actor_is_sleeping(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.push_bool(stack.get_physics_world(1)->is_sleeping(stack.get_actor(2)));
+	stack.push_bool(stack.get_physics_world(1)->actor_is_sleeping(stack.get_actor(2)));
 	return 1;
 }
 
-static int physics_world_wake_up(lua_State* L)
+static int physics_world_actor_wake_up(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->wake_up(stack.get_actor(2));
+	stack.get_physics_world(1)->actor_wake_up(stack.get_actor(2));
 	return 0;
 }
 
@@ -2219,14 +2219,14 @@ static int physics_world_controller_instances(lua_State* L)
 	return 1;
 }
 
-static int physics_world_move_controller(lua_State* L)
+static int physics_world_controller_move(lua_State* L)
 {
 	LuaStack stack(L);
-	stack.get_physics_world(1)->move_controller(stack.get_controller(2), stack.get_vector3(3));
+	stack.get_physics_world(1)->controller_move(stack.get_controller(2), stack.get_vector3(3));
 	return 0;
 }
 
-static int physics_world_create_joint(lua_State* L)
+static int physics_world_joint_create(lua_State* L)
 {
 	LuaStack stack(L);
 	JointDesc jd;
@@ -2238,7 +2238,7 @@ static int physics_world_create_joint(lua_State* L)
 	jd.hinge.lower_limit = -3.14f / 4.0f;
 	jd.hinge.upper_limit = 3.14f / 4.0f;
 	jd.hinge.bounciness = 12.0f;
-	stack.get_physics_world(1)->create_joint(stack.get_actor(2), stack.get_actor(3), jd);
+	stack.get_physics_world(1)->joint_create(stack.get_actor(2), stack.get_actor(3), jd);
 	return 0;
 }
 
@@ -2279,7 +2279,7 @@ static int physics_world_raycast(lua_State* L)
 	for (u32 i = 0; i < array::size(hits); ++i)
 	{
 		stack.push_key_begin(i+1);
-		stack.push_actor(hits[i].actor);
+		stack.actor_push(hits[i].actor);
 		stack.push_key_end();
 	}
 
@@ -3282,39 +3282,39 @@ void load_api(LuaEnvironment& env)
 	env.add_module_function("PhysicsWorld", "actor_world_position",          physics_world_actor_world_position);
 	env.add_module_function("PhysicsWorld", "actor_world_rotation",          physics_world_actor_world_rotation);
 	env.add_module_function("PhysicsWorld", "actor_world_pose",              physics_world_actor_world_pose);
-	env.add_module_function("PhysicsWorld", "teleport_actor_world_position", physics_world_teleport_actor_world_position);
-	env.add_module_function("PhysicsWorld", "teleport_actor_world_rotation", physics_world_teleport_actor_world_rotation);
-	env.add_module_function("PhysicsWorld", "teleport_actor_world_pose",     physics_world_teleport_actor_world_pose);
+	env.add_module_function("PhysicsWorld", "actor_teleport_world_position", physics_world_actor_teleport_world_position);
+	env.add_module_function("PhysicsWorld", "actor_teleport_world_rotation", physics_world_actor_teleport_world_rotation);
+	env.add_module_function("PhysicsWorld", "actor_teleport_world_pose",     physics_world_actor_teleport_world_pose);
 	env.add_module_function("PhysicsWorld", "actor_center_of_mass",          physics_world_actor_center_of_mass);
-	env.add_module_function("PhysicsWorld", "enable_actor_gravity",          physics_world_enable_actor_gravity);
-	env.add_module_function("PhysicsWorld", "disable_actor_gravity",         physics_world_disable_actor_gravity);
-	env.add_module_function("PhysicsWorld", "enable_actor_collision",        physics_world_enable_actor_collision);
-	env.add_module_function("PhysicsWorld", "disable_actor_collision",       physics_world_disable_actor_collision);
-	env.add_module_function("PhysicsWorld", "set_actor_collision_filter",    physics_world_set_actor_collision_filter);
-	env.add_module_function("PhysicsWorld", "set_actor_kinematic",           physics_world_set_actor_kinematic);
-	env.add_module_function("PhysicsWorld", "move_actor",                    physics_world_move_actor);
-	env.add_module_function("PhysicsWorld", "is_static",                     physics_world_is_static);
-	env.add_module_function("PhysicsWorld", "is_dynamic",                    physics_world_is_dynamic);
-	env.add_module_function("PhysicsWorld", "is_kinematic",                  physics_world_is_kinematic);
-	env.add_module_function("PhysicsWorld", "is_nonkinematic",               physics_world_is_nonkinematic);
+	env.add_module_function("PhysicsWorld", "actor_enable_gravity",          physics_world_actor_enable_gravity);
+	env.add_module_function("PhysicsWorld", "actor_disable_gravity",         physics_world_actor_disable_gravity);
+	env.add_module_function("PhysicsWorld", "actor_enable_collision",        physics_world_actor_enable_collision);
+	env.add_module_function("PhysicsWorld", "actor_disable_collision",       physics_world_actor_disable_collision);
+	env.add_module_function("PhysicsWorld", "actor_set_collision_filter",    physics_world_actor_set_collision_filter);
+	env.add_module_function("PhysicsWorld", "actor_set_kinematic",           physics_world_actor_set_kinematic);
+	env.add_module_function("PhysicsWorld", "actor_move",                    physics_world_actor_move);
+	env.add_module_function("PhysicsWorld", "actor_is_static",               physics_world_actor_is_static);
+	env.add_module_function("PhysicsWorld", "actor_is_dynamic",              physics_world_actor_is_dynamic);
+	env.add_module_function("PhysicsWorld", "actor_is_kinematic",            physics_world_actor_is_kinematic);
+	env.add_module_function("PhysicsWorld", "actor_is_nonkinematic",         physics_world_actor_is_nonkinematic);
 	env.add_module_function("PhysicsWorld", "actor_linear_damping",          physics_world_actor_linear_damping);
-	env.add_module_function("PhysicsWorld", "set_actor_linear_damping",      physics_world_set_actor_linear_damping);
+	env.add_module_function("PhysicsWorld", "actor_set_linear_damping",      physics_world_actor_set_linear_damping);
 	env.add_module_function("PhysicsWorld", "actor_angular_damping",         physics_world_actor_angular_damping);
-	env.add_module_function("PhysicsWorld", "set_actor_angular_damping",     physics_world_set_actor_angular_damping);
+	env.add_module_function("PhysicsWorld", "actor_set_angular_damping",     physics_world_actor_set_angular_damping);
 	env.add_module_function("PhysicsWorld", "actor_linear_velocity",         physics_world_actor_linear_velocity);
-	env.add_module_function("PhysicsWorld", "set_actor_linear_velocity",     physics_world_set_actor_linear_velocity);
+	env.add_module_function("PhysicsWorld", "actor_set_linear_velocity",     physics_world_actor_set_linear_velocity);
 	env.add_module_function("PhysicsWorld", "actor_angular_velocity",        physics_world_actor_angular_velocity);
-	env.add_module_function("PhysicsWorld", "set_actor_angular_velocity",    physics_world_set_actor_angular_velocity);
-	env.add_module_function("PhysicsWorld", "add_actor_impulse",             physics_world_add_actor_impulse);
-	env.add_module_function("PhysicsWorld", "add_actor_impulse_at",          physics_world_add_actor_impulse_at);
-	env.add_module_function("PhysicsWorld", "add_actor_torque_impulse",      physics_world_add_actor_torque_impulse);
-	env.add_module_function("PhysicsWorld", "push_actor",                    physics_world_push_actor);
-	env.add_module_function("PhysicsWorld", "push_actor_at",                 physics_world_push_actor_at);
-	env.add_module_function("PhysicsWorld", "is_sleeping",                   physics_world_is_sleeping);
-	env.add_module_function("PhysicsWorld", "wake_up",                       physics_world_wake_up);
+	env.add_module_function("PhysicsWorld", "actor_set_angular_velocity",    physics_world_actor_set_angular_velocity);
+	env.add_module_function("PhysicsWorld", "actor_add_impulse",             physics_world_actor_add_impulse);
+	env.add_module_function("PhysicsWorld", "actor_add_impulse_at",          physics_world_actor_add_impulse_at);
+	env.add_module_function("PhysicsWorld", "actor_add_actor_torque_impulse",physics_world_actor_add_actor_torque_impulse);
+	env.add_module_function("PhysicsWorld", "actor_push",                    physics_world_actor_push);
+	env.add_module_function("PhysicsWorld", "actor_push_at",                 physics_world_actor_push_at);
+	env.add_module_function("PhysicsWorld", "actor_is_sleeping",             physics_world_actor_is_sleeping);
+	env.add_module_function("PhysicsWorld", "actor_wake_up",                 physics_world_actor_wake_up);
 	env.add_module_function("PhysicsWorld", "controller_instances",          physics_world_controller_instances);
-	env.add_module_function("PhysicsWorld", "move_controller",               physics_world_move_controller);
-	env.add_module_function("PhysicsWorld", "create_joint",                  physics_world_create_joint);
+	env.add_module_function("PhysicsWorld", "controller_move",               physics_world_controller_move);
+	env.add_module_function("PhysicsWorld", "joint_create",                  physics_world_joint_create);
 	env.add_module_function("PhysicsWorld", "gravity",                       physics_world_gravity);
 	env.add_module_function("PhysicsWorld", "set_gravity",                   physics_world_set_gravity);
 	env.add_module_function("PhysicsWorld", "raycast",                       physics_world_raycast);

src/world/physics_world.h

@@ -22,13 +22,13 @@ public:
 	PhysicsWorld() {}
 	virtual ~PhysicsWorld() {}
 
-	virtual ColliderInstance create_collider(UnitId id, const ColliderDesc* sd) = 0;
-	virtual void destroy_collider(ColliderInstance i) = 0;
-	virtual ColliderInstance first_collider(UnitId id) = 0;
-	virtual ColliderInstance next_collider(ColliderInstance i) = 0;
+	virtual ColliderInstance collider_create(UnitId id, const ColliderDesc* sd) = 0;
+	virtual void collider_destroy(ColliderInstance i) = 0;
+	virtual ColliderInstance collider_first(UnitId id) = 0;
+	virtual ColliderInstance collider_next(ColliderInstance i) = 0;
 
-	virtual ActorInstance create_actor(UnitId id, const ActorResource* ar, const Matrix4x4& tm) = 0;
-	virtual void destroy_actor(ActorInstance i) = 0;
+	virtual ActorInstance actor_create(UnitId id, const ActorResource* ar, const Matrix4x4& tm) = 0;
+	virtual void actor_destroy(ActorInstance i) = 0;
 	virtual ActorInstance actor(UnitId id) = 0;
 
 	/// Returns the world position of the actor.
@@ -41,129 +41,129 @@ public:
 	virtual Matrix4x4 actor_world_pose(ActorInstance i) const = 0;
 
 	/// Teleports the actor to the given world position.
-	virtual void teleport_actor_world_position(ActorInstance i, const Vector3& p) = 0;
+	virtual void actor_teleport_world_position(ActorInstance i, const Vector3& p) = 0;
 
 	/// Teleports the actor to the given world rotation.
-	virtual void teleport_actor_world_rotation(ActorInstance i, const Quaternion& r) = 0;
+	virtual void actor_teleport_world_rotation(ActorInstance i, const Quaternion& r) = 0;
 
 	/// Teleports the actor to the given world pose.
-	virtual void teleport_actor_world_pose(ActorInstance i, const Matrix4x4& m) = 0;
+	virtual void actor_teleport_world_pose(ActorInstance i, const Matrix4x4& m) = 0;
 
 	/// Returns the center of mass of the actor.
 	virtual Vector3 actor_center_of_mass(ActorInstance i) const = 0;
 
 	/// Enables gravity for the actor.
-	virtual void enable_actor_gravity(ActorInstance i) = 0;
+	virtual void actor_enable_gravity(ActorInstance i) = 0;
 
 	/// Disables gravity for the actor.
-	virtual void disable_actor_gravity(ActorInstance i) = 0;
+	virtual void actor_disable_gravity(ActorInstance i) = 0;
 
 	/// Enables collision detection for the actor.
-	virtual void enable_actor_collision(ActorInstance i) = 0;
+	virtual void actor_enable_collision(ActorInstance i) = 0;
 
 	/// Disables collision detection for the actor.
-	virtual void disable_actor_collision(ActorInstance i) = 0;
+	virtual void actor_disable_collision(ActorInstance i) = 0;
 
 	/// Sets the collision filter of the actor.
-	virtual void set_actor_collision_filter(ActorInstance i, StringId32 filter) = 0;
+	virtual void actor_set_collision_filter(ActorInstance i, StringId32 filter) = 0;
 
 	/// Sets whether the actor is kinematic or not.
 	/// @note This call has no effect on static actors.
-	virtual void set_actor_kinematic(ActorInstance i, bool kinematic) = 0;
+	virtual void actor_set_kinematic(ActorInstance i, bool kinematic) = 0;
 
 	/// Moves the actor to @a pos
 	/// @note This call only affects nonkinematic actors.
-	virtual void move_actor(ActorInstance i, const Vector3& pos) = 0;
+	virtual void actor_move(ActorInstance i, const Vector3& pos) = 0;
 
 	/// Returns whether the actor is static.
-	virtual bool is_static(ActorInstance i) const = 0;
+	virtual bool actor_is_static(ActorInstance i) const = 0;
 
 	/// Returns whether the actor is dynamic.
-	virtual bool is_dynamic(ActorInstance i) const = 0;
+	virtual bool actor_is_dynamic(ActorInstance i) const = 0;
 
 	/// Returns whether the actor is kinematic (keyframed).
-	virtual bool is_kinematic(ActorInstance i) const = 0;
+	virtual bool actor_is_kinematic(ActorInstance i) const = 0;
 
 	/// Returns whether the actor is nonkinematic (i.e. dynamic and not kinematic).
-	virtual bool is_nonkinematic(ActorInstance i) const = 0;
+	virtual bool actor_is_nonkinematic(ActorInstance i) const = 0;
 
 	/// Returns the linear damping of the actor.
 	virtual f32 actor_linear_damping(ActorInstance i) const = 0;
 
 	/// Sets the linear damping of the actor.
-	virtual void set_actor_linear_damping(ActorInstance i, f32 rate) = 0;
+	virtual void actor_set_linear_damping(ActorInstance i, f32 rate) = 0;
 
 	/// Returns the angular damping of the actor.
 	virtual f32 actor_angular_damping(ActorInstance i) const = 0;
 
 	/// Sets the angular damping of the actor.
-	virtual void set_actor_angular_damping(ActorInstance i, f32 rate) = 0;
+	virtual void actor_set_angular_damping(ActorInstance i, f32 rate) = 0;
 
 	/// Returns the linear velocity of the actor.
 	virtual Vector3 actor_linear_velocity(ActorInstance i) const = 0;
 
 	/// Sets the linear velocity of the actor.
 	/// @note This call only affects nonkinematic actors.
-	virtual void set_actor_linear_velocity(ActorInstance i, const Vector3& vel) = 0;
+	virtual void actor_set_linear_velocity(ActorInstance i, const Vector3& vel) = 0;
 
 	/// Returns the angular velocity of the actor.
 	virtual Vector3 actor_angular_velocity(ActorInstance i) const = 0;
 
 	/// Sets the angular velocity of the actor.
 	/// @note This call only affects nonkinematic actors.
-	virtual void set_actor_angular_velocity(ActorInstance i, const Vector3& vel) = 0;
+	virtual void actor_set_angular_velocity(ActorInstance i, const Vector3& vel) = 0;
 
 	/// Adds a linear impulse (acting along the center of mass) to the actor.
 	/// @note This call only affects nonkinematic actors.
-	virtual void add_actor_impulse(ActorInstance i, const Vector3& impulse) = 0;
+	virtual void actor_add_impulse(ActorInstance i, const Vector3& impulse) = 0;
 
 	/// Adds a linear impulse (acting along the world position @a pos) to the actor.
 	/// @note This call only affects nonkinematic actors.
-	virtual void add_actor_impulse_at(ActorInstance i, const Vector3& impulse, const Vector3& pos) = 0;
+	virtual void actor_add_impulse_at(ActorInstance i, const Vector3& impulse, const Vector3& pos) = 0;
 
 	/// Adds a torque impulse to the actor.
-	virtual void add_actor_torque_impulse(ActorInstance i, const Vector3& imp) = 0;
+	virtual void actor_add_torque_impulse(ActorInstance i, const Vector3& imp) = 0;
 
 	/// Pushes the actor as if it was hit by a point object with the given @a mass
 	/// travelling at the given @a velocity.
 	/// @note This call only affects nonkinematic actors.
-	virtual void push_actor(ActorInstance i, const Vector3& vel, f32 mass) = 0;
+	virtual void actor_push(ActorInstance i, const Vector3& vel, f32 mass) = 0;
 
 	/// Like push() but applies the force at the world position @a pos.
 	/// @note This call only affects nonkinematic actors.
-	virtual void push_actor_at(ActorInstance i, const Vector3& vel, f32 mass, const Vector3& pos) = 0;
+	virtual void actor_push_at(ActorInstance i, const Vector3& vel, f32 mass, const Vector3& pos) = 0;
 
 	/// Returns whether the actor is sleeping.
-	virtual bool is_sleeping(ActorInstance i) = 0;
+	virtual bool actor_is_sleeping(ActorInstance i) = 0;
 
 	/// Wakes the actor up.
-	virtual void wake_up(ActorInstance i) = 0;
+	virtual void actor_wake_up(ActorInstance i) = 0;
 
-	virtual ControllerInstance create_controller(UnitId id, const ControllerDesc& cd, const Matrix4x4& tm) = 0;
-	virtual void destroy_controller(ControllerInstance id) = 0;
+	virtual ControllerInstance controller_create(UnitId id, const ControllerDesc& cd, const Matrix4x4& tm) = 0;
+	virtual void controller_destroy(ControllerInstance id) = 0;
 	virtual ControllerInstance controller(UnitId id) = 0;
 
 	/// Returns the position of the controller.
-	virtual Vector3 position(ControllerInstance i) const = 0;
+	virtual Vector3 controller_position(ControllerInstance i) const = 0;
 
 	/// Moves the controller to @a pos.
-	virtual void move_controller(ControllerInstance i, const Vector3& pos) = 0;
+	virtual void controller_move(ControllerInstance i, const Vector3& pos) = 0;
 
 	/// Sets the contoller height.
-	virtual void set_height(ControllerInstance i, f32 height) = 0;
+	virtual void controller_set_height(ControllerInstance i, f32 height) = 0;
 
 	/// Returns whether the contoller collides upwards.
-	virtual bool collides_up(ControllerInstance i) const = 0;
+	virtual bool controller_collides_up(ControllerInstance i) const = 0;
 
 	/// Returns whether the controller collides downwards.
-	virtual bool collides_down(ControllerInstance i) const = 0;
+	virtual bool controller_collides_down(ControllerInstance i) const = 0;
 
 	/// Returns whether the controller collides sidewards.
-	virtual bool collides_sides(ControllerInstance i) const = 0;
+	virtual bool controller_collides_sides(ControllerInstance i) const = 0;
 
 	/// Creates joint
-	virtual JointInstance create_joint(ActorInstance a0, ActorInstance a1, const JointDesc& jd) = 0;
-	virtual void destroy_joint(JointInstance i) = 0;
+	virtual JointInstance joint_create(ActorInstance a0, ActorInstance a1, const JointDesc& jd) = 0;
+	virtual void joint_destroy(JointInstance i) = 0;
 
 	/// Performs a raycast.
 	virtual void raycast(const Vector3& from, const Vector3& dir, f32 len, RaycastMode::Enum mode, Array<RaycastHit>& hits) = 0;

src/world/physics_world_bullet.cpp

@@ -219,7 +219,7 @@ public:
 		CE_DELETE(*_allocator, _scene);
 	}
 
-	ColliderInstance create_collider(UnitId id, const ColliderDesc* sd)
+	ColliderInstance collider_create(UnitId id, const ColliderDesc* sd)
 	{
 		btTriangleIndexVertexArray* vertex_array = NULL;
 		btCollisionShape* child_shape = NULL;
@@ -290,9 +290,9 @@ public:
 		cid.shape        = child_shape;
 		cid.next.i       = UINT32_MAX;
 
-		ColliderInstance ci = first_collider(id);
-		while (is_valid(ci) && is_valid(next_collider(ci)))
-			ci = next_collider(ci);
+		ColliderInstance ci = collider_first(id);
+		while (is_valid(ci) && is_valid(collider_next(ci)))
+			ci = collider_next(ci);
 
 		if (is_valid(ci))
 			_collider[ci.i].next.i = last;
@@ -303,17 +303,17 @@ public:
 		return make_collider_instance(last);
 	}
 
-	void destroy_collider(ColliderInstance i)
+	void collider_destroy(ColliderInstance i)
 	{
 		CE_ASSERT(i.i < array::size(_collider), "Index out of bounds");
 
 		const u32 last                 = array::size(_collider) - 1;
 		const UnitId u                 = _collider[i.i].unit;
-		const ColliderInstance first_i = first_collider(u);
+		const ColliderInstance first_i = collider_first(u);
 		const ColliderInstance last_i  = make_collider_instance(last);
 
-		swap_collider_node(last_i, i);
-		remove_collider_node(first_i, i);
+		collider_swap_node(last_i, i);
+		collider_remove_node(first_i, i);
 
 		CE_DELETE(*_allocator, _collider[i.i].vertex_array);
 		CE_DELETE(*_allocator, _collider[i.i].shape);
@@ -323,7 +323,7 @@ public:
 		array::pop_back(_collider);
 	}
 
-	void remove_collider_node(ColliderInstance first, ColliderInstance i)
+	void collider_remove_node(ColliderInstance first, ColliderInstance i)
 	{
 		CE_ASSERT(first.i < array::size(_collider), "Index out of bounds");
 		CE_ASSERT(i.i < array::size(_collider), "Index out of bounds");
@@ -332,25 +332,25 @@ public:
 
 		if (i.i == first.i)
 		{
-			if (!is_valid(next_collider(i)))
+			if (!is_valid(collider_next(i)))
 				hash_map::remove(_collider_map, u);
 			else
-				hash_map::set(_collider_map, u, next_collider(i).i);
+				hash_map::set(_collider_map, u, collider_next(i).i);
 		}
 		else
 		{
-			ColliderInstance prev = previous_collider(i);
-			_collider[prev.i].next = next_collider(i);
+			ColliderInstance prev = collider_previous(i);
+			_collider[prev.i].next = collider_next(i);
 		}
 	}
 
-	void swap_collider_node(ColliderInstance a, ColliderInstance b)
+	void collider_swap_node(ColliderInstance a, ColliderInstance b)
 	{
 		CE_ASSERT(a.i < array::size(_collider), "Index out of bounds");
 		CE_ASSERT(b.i < array::size(_collider), "Index out of bounds");
 
 		const UnitId u = _collider[a.i].unit;
-		const ColliderInstance first_i = first_collider(u);
+		const ColliderInstance first_i = collider_first(u);
 
 		if (a.i == first_i.i)
 		{
@@ -358,41 +358,41 @@ public:
 		}
 		else
 		{
-			const ColliderInstance prev_a = previous_collider(a);
+			const ColliderInstance prev_a = collider_previous(a);
 			CE_ENSURE(prev_a.i != a.i);
 			_collider[prev_a.i].next = b;
 		}
 	}
 
-	ColliderInstance first_collider(UnitId id)
+	ColliderInstance collider_first(UnitId id)
 	{
 		return make_collider_instance(hash_map::get(_collider_map, id, UINT32_MAX));
 	}
 
-	ColliderInstance next_collider(ColliderInstance i)
+	ColliderInstance collider_next(ColliderInstance i)
 	{
 		return _collider[i.i].next;
 	}
 
-	ColliderInstance previous_collider(ColliderInstance i)
+	ColliderInstance collider_previous(ColliderInstance i)
 	{
 		CE_ASSERT(i.i < array::size(_collider), "Index out of bounds");
 
 		const UnitId u = _collider[i.i].unit;
 
-		ColliderInstance curr = first_collider(u);
+		ColliderInstance curr = collider_first(u);
 		ColliderInstance prev = { UINT32_MAX };
 
 		while (curr.i != i.i)
 		{
 			prev = curr;
-			curr = next_collider(curr);
+			curr = collider_next(curr);
 		}
 
 		return prev;
 	}
 
-	ActorInstance create_actor(UnitId id, const ActorResource* ar, const Matrix4x4& tm)
+	ActorInstance actor_create(UnitId id, const ActorResource* ar, const Matrix4x4& tm)
 	{
 		const PhysicsConfigActor* actor_class = physics_config_resource::actor(_config_resource, ar->actor_class);
 
@@ -404,11 +404,11 @@ public:
 		// Create compound shape
 		btCompoundShape* shape = CE_NEW(*_allocator, btCompoundShape)(true);
 
-		ColliderInstance ci = first_collider(id);
+		ColliderInstance ci = collider_first(id);
 		while (is_valid(ci))
 		{
 			shape->addChildShape(btTransform::getIdentity(), _collider[ci.i].shape);
-			ci = next_collider(ci);
+			ci = collider_next(ci);
 		}
 
 		// Create motion state
@@ -467,7 +467,7 @@ public:
 		return make_actor_instance(last);
 	}
 
-	void destroy_actor(ActorInstance i)
+	void actor_destroy(ActorInstance i)
 	{
 		const u32 last      = array::size(_actor) - 1;
 		const UnitId u      = _actor[i.i].unit;
@@ -516,21 +516,21 @@ public:
 		return matrix4x4(to_quaternion(r), to_vector3(p));
 	}
 
-	void teleport_actor_world_position(ActorInstance i, const Vector3& p)
+	void actor_teleport_world_position(ActorInstance i, const Vector3& p)
 	{
 		btTransform pose = _actor[i.i].actor->getCenterOfMassTransform();
 		pose.setOrigin(to_btVector3(p));
 		_actor[i.i].actor->setCenterOfMassTransform(pose);
 	}
 
-	void teleport_actor_world_rotation(ActorInstance i, const Quaternion& r)
+	void actor_teleport_world_rotation(ActorInstance i, const Quaternion& r)
 	{
 		btTransform pose = _actor[i.i].actor->getCenterOfMassTransform();
 		pose.setRotation(to_btQuaternion(r));
 		_actor[i.i].actor->setCenterOfMassTransform(pose);
 	}
 
-	void teleport_actor_world_pose(ActorInstance i, const Matrix4x4& m)
+	void actor_teleport_world_pose(ActorInstance i, const Matrix4x4& m)
 	{
 		const Quaternion rot = rotation(m);
 		const Vector3 pos = translation(m);
@@ -543,58 +543,58 @@ public:
 
 	Vector3 actor_center_of_mass(ActorInstance i) const
 	{
-		if (is_static(i))
+		if (actor_is_static(i))
 			return VECTOR3_ZERO;
 
 		const btVector3 c = _actor[i.i].actor->getCenterOfMassTransform().getOrigin();
 		return to_vector3(c);
 	}
 
-	void enable_actor_gravity(ActorInstance i)
+	void actor_enable_gravity(ActorInstance i)
 	{
 		_actor[i.i].actor->setGravity(_scene->getGravity());
 	}
 
-	void disable_actor_gravity(ActorInstance i)
+	void actor_disable_gravity(ActorInstance i)
 	{
 		_actor[i.i].actor->setGravity(btVector3(0.0f, 0.0f, 0.0f));
 	}
 
-	void enable_actor_collision(ActorInstance /*i*/)
+	void actor_enable_collision(ActorInstance /*i*/)
 	{
 		CE_FATAL("Not implemented yet");
 	}
 
-	void disable_actor_collision(ActorInstance /*i*/)
+	void actor_disable_collision(ActorInstance /*i*/)
 	{
 		CE_FATAL("Not implemented yet");
 	}
 
-	void set_actor_collision_filter(ActorInstance /*i*/, StringId32 /*filter*/)
+	void actor_set_collision_filter(ActorInstance /*i*/, StringId32 /*filter*/)
 	{
 		CE_FATAL("Not implemented yet");
 	}
 
-	void set_actor_kinematic(ActorInstance i, bool kinematic)
+	void actor_set_kinematic(ActorInstance i, bool kinematic)
 	{
 		if (kinematic)
 			_actor[i.i].actor->setCollisionFlags(_actor[i.i].actor->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
 	}
 
-	void move_actor(ActorInstance i, const Vector3& pos)
+	void actor_move(ActorInstance i, const Vector3& pos)
 	{
-		if (!is_kinematic(i))
+		if (!actor_is_kinematic(i))
 			return;
 
 		_actor[i.i].actor->setLinearVelocity(to_btVector3(pos));
 	}
 
-	bool is_static(ActorInstance i) const
+	bool actor_is_static(ActorInstance i) const
 	{
 		return _actor[i.i].actor->getCollisionFlags() & btCollisionObject::CF_STATIC_OBJECT;
 	}
 
-	bool is_dynamic(ActorInstance i) const
+	bool actor_is_dynamic(ActorInstance i) const
 	{
 		const int flags = _actor[i.i].actor->getCollisionFlags();
 		return !(flags & btCollisionObject::CF_STATIC_OBJECT)
@@ -602,15 +602,15 @@ public:
 			;
 	}
 
-	bool is_kinematic(ActorInstance i) const
+	bool actor_is_kinematic(ActorInstance i) const
 	{
 		const int flags = _actor[i.i].actor->getCollisionFlags();
 		return (flags & btCollisionObject::CF_KINEMATIC_OBJECT) != 0;
 	}
 
-	bool is_nonkinematic(ActorInstance i) const
+	bool actor_is_nonkinematic(ActorInstance i) const
 	{
-		return is_dynamic(i) && !is_kinematic(i);
+		return actor_is_dynamic(i) && !actor_is_kinematic(i);
 	}
 
 	f32 actor_linear_damping(ActorInstance i) const
@@ -618,7 +618,7 @@ public:
 		return _actor[i.i].actor->getLinearDamping();
 	}
 
-	void set_actor_linear_damping(ActorInstance i, f32 rate)
+	void actor_set_linear_damping(ActorInstance i, f32 rate)
 	{
 		_actor[i.i].actor->setDamping(rate, _actor[i.i].actor->getAngularDamping());
 	}
@@ -628,7 +628,7 @@ public:
 		return _actor[i.i].actor->getAngularDamping();
 	}
 
-	void set_actor_angular_damping(ActorInstance i, f32 rate)
+	void actor_set_angular_damping(ActorInstance i, f32 rate)
 	{
 		_actor[i.i].actor->setDamping(_actor[i.i].actor->getLinearDamping(), rate);
 	}
@@ -639,7 +639,7 @@ public:
 		return to_vector3(v);
 	}
 
-	void set_actor_linear_velocity(ActorInstance i, const Vector3& vel)
+	void actor_set_linear_velocity(ActorInstance i, const Vector3& vel)
 	{
 		_actor[i.i].actor->setLinearVelocity(to_btVector3(vel));
 	}
@@ -650,57 +650,57 @@ public:
 		return to_vector3(v);
 	}
 
-	void set_actor_angular_velocity(ActorInstance i, const Vector3& vel)
+	void actor_set_angular_velocity(ActorInstance i, const Vector3& vel)
 	{
 		_actor[i.i].actor->setAngularVelocity(to_btVector3(vel));
 	}
 
-	void add_actor_impulse(ActorInstance i, const Vector3& impulse)
+	void actor_add_impulse(ActorInstance i, const Vector3& impulse)
 	{
 		_actor[i.i].actor->activate();
 		_actor[i.i].actor->applyCentralImpulse(to_btVector3(impulse));
 	}
 
-	void add_actor_impulse_at(ActorInstance i, const Vector3& impulse, const Vector3& pos)
+	void actor_add_impulse_at(ActorInstance i, const Vector3& impulse, const Vector3& pos)
 	{
 		_actor[i.i].actor->activate();
 		_actor[i.i].actor->applyImpulse(to_btVector3(impulse), to_btVector3(pos));
 	}
 
-	void add_actor_torque_impulse(ActorInstance i, const Vector3& imp)
+	void actor_add_torque_impulse(ActorInstance i, const Vector3& imp)
 	{
 		_actor[i.i].actor->applyTorqueImpulse(to_btVector3(imp));
 	}
 
-	void push_actor(ActorInstance i, const Vector3& vel, f32 mass)
+	void actor_push(ActorInstance i, const Vector3& vel, f32 mass)
 	{
 		const Vector3 f = vel * mass;
 		_actor[i.i].actor->applyCentralForce(to_btVector3(f));
 	}
 
-	void push_actor_at(ActorInstance i, const Vector3& vel, f32 mass, const Vector3& pos)
+	void actor_push_at(ActorInstance i, const Vector3& vel, f32 mass, const Vector3& pos)
 	{
 		const Vector3 f = vel * mass;
 		_actor[i.i].actor->applyForce(to_btVector3(f), to_btVector3(pos));
 	}
 
-	bool is_sleeping(ActorInstance i)
+	bool actor_is_sleeping(ActorInstance i)
 	{
 		return !_actor[i.i].actor->isActive();
 	}
 
-	void wake_up(ActorInstance i)
+	void actor_wake_up(ActorInstance i)
 	{
 		_actor[i.i].actor->activate(true);
 	}
 
-	ControllerInstance create_controller(UnitId /*id*/,	const ControllerDesc& /*cd*/, const Matrix4x4& /*tm*/)
+	ControllerInstance controller_create(UnitId /*id*/,	const ControllerDesc& /*cd*/, const Matrix4x4& /*tm*/)
 	{
 		CE_FATAL("Not implemented yet");
 		return make_controller_instance(UINT32_MAX);
 	}
 
-	void destroy_controller(ControllerInstance /*i*/)
+	void controller_destroy(ControllerInstance /*i*/)
 	{
 		CE_FATAL("Not implemented yet");
 	}
@@ -710,41 +710,41 @@ public:
 		return make_controller_instance(hash_map::get(_controller_map, id, UINT32_MAX));
 	}
 
-	void move_controller(ControllerInstance i, const Vector3& dir)
+	void controller_move(ControllerInstance i, const Vector3& dir)
 	{
 		_controller[i.i].contr->setWalkDirection(to_btVector3(dir));
 	}
 
-	void set_height(ControllerInstance /*i*/, f32 /*height*/)
+	void controller_set_height(ControllerInstance /*i*/, f32 /*height*/)
 	{
 		CE_FATAL("Not implemented yet");
 	}
 
-	Vector3 position(ControllerInstance /*i*/) const
+	Vector3 controller_position(ControllerInstance /*i*/) const
 	{
 		CE_FATAL("Not implemented yet");
 		return VECTOR3_ZERO;
 	}
 
-	bool collides_up(ControllerInstance /*i*/) const
+	bool controller_collides_up(ControllerInstance /*i*/) const
 	{
 		CE_FATAL("Not implemented yet");
 		return false;
 	}
 
-	bool collides_down(ControllerInstance /*i*/) const
+	bool controller_collides_down(ControllerInstance /*i*/) const
 	{
 		CE_FATAL("Not implemented yet");
 		return false;
 	}
 
-	bool collides_sides(ControllerInstance /*i*/) const
+	bool controller_collides_sides(ControllerInstance /*i*/) const
 	{
 		CE_FATAL("Not implemented yet");
 		return false;
 	}
 
-	JointInstance create_joint(ActorInstance a0, ActorInstance a1, const JointDesc& jd)
+	JointInstance joint_create(ActorInstance a0, ActorInstance a1, const JointDesc& jd)
 	{
 		const btVector3 anchor_0 = to_btVector3(jd.anchor_0);
 		const btVector3 anchor_1 = to_btVector3(jd.anchor_1);
@@ -810,7 +810,7 @@ public:
 		return make_joint_instance(UINT32_MAX);
 	}
 
-	void destroy_joint(JointInstance /*i*/)
+	void joint_destroy(JointInstance /*i*/)
 	{
 		CE_FATAL("Not implemented yet");
 	}
@@ -998,17 +998,17 @@ public:
 		{
 			ActorInstance first = actor(id);
 			if (is_valid(first))
-				destroy_actor(first);
+				actor_destroy(first);
 		}
 
 		{
-			ColliderInstance curr = first_collider(id);
+			ColliderInstance curr = collider_first(id);
 			ColliderInstance next;
 
 			while (is_valid(curr))
 			{
-				next = next_collider(curr);
-				destroy_collider(curr);
+				next = collider_next(curr);
+				collider_destroy(curr);
 				curr = next;
 			}
 		}

src/world/physics_world_null.cpp

@@ -40,7 +40,7 @@ public:
 		return make_collider_instance(UINT32_MAX);
 	}
 
-	virtual void destroy_collider(ColliderInstance /*i*/)
+	virtual void collider_destroy(ColliderInstance /*i*/)
 	{
 	}
 
@@ -54,12 +54,12 @@ public:
 		return make_collider_instance(UINT32_MAX);
 	}
 
-	virtual ActorInstance create_actor(UnitId /*id*/, const ActorResource* /*ar*/, const Matrix4x4& /*tm*/)
+	virtual ActorInstance actor_create(UnitId /*id*/, const ActorResource* /*ar*/, const Matrix4x4& /*tm*/)
 	{
 		return make_actor_instance(UINT32_MAX);
 	}
 
-	virtual void destroy_actor(ActorInstance /*i*/)
+	virtual void actor_destroy(ActorInstance /*i*/)
 	{
 	}
 
@@ -83,15 +83,15 @@ public:
 		return MATRIX4X4_IDENTITY;
 	}
 
-	virtual void teleport_actor_world_position(ActorInstance /*i*/, const Vector3& /*p*/)
+	virtual void actor_teleport_world_position(ActorInstance /*i*/, const Vector3& /*p*/)
 	{
 	}
 
-	virtual void teleport_actor_world_rotation(ActorInstance /*i*/, const Quaternion& /*r*/)
+	virtual void actor_teleport_world_rotation(ActorInstance /*i*/, const Quaternion& /*r*/)
 	{
 	}
 
-	virtual void teleport_actor_world_pose(ActorInstance /*i*/, const Matrix4x4& /*m*/)
+	virtual void actor_teleport_world_pose(ActorInstance /*i*/, const Matrix4x4& /*m*/)
 	{
 	}
 
@@ -100,50 +100,50 @@ public:
 		return VECTOR3_ZERO;
 	}
 
-	virtual void enable_actor_gravity(ActorInstance /*i*/)
+	virtual void actor_enable_gravity(ActorInstance /*i*/)
 	{
 	}
 
-	virtual void disable_actor_gravity(ActorInstance /*i*/)
+	virtual void actor_disable_gravity(ActorInstance /*i*/)
 	{
 	}
 
-	virtual void enable_actor_collision(ActorInstance /*i*/)
+	virtual void actor_enable_collision(ActorInstance /*i*/)
 	{
 	}
 
-	virtual void disable_actor_collision(ActorInstance /*i*/)
+	virtual void actor_disable_collision(ActorInstance /*i*/)
 	{
 	}
 
-	virtual void set_actor_collision_filter(ActorInstance /*i*/, StringId32 /*filter*/)
+	virtual void actor_set_collision_filter(ActorInstance /*i*/, StringId32 /*filter*/)
 	{
 	}
 
-	virtual void set_actor_kinematic(ActorInstance /*i*/, bool /*kinematic*/)
+	virtual void actor_set_kinematic(ActorInstance /*i*/, bool /*kinematic*/)
 	{
 	}
 
-	virtual void move_actor(ActorInstance /*i*/, const Vector3& /*pos*/)
+	virtual void actor_move(ActorInstance /*i*/, const Vector3& /*pos*/)
 	{
 	}
 
-	virtual bool is_static(ActorInstance /*i*/) const
+	virtual bool actor_is_static(ActorInstance /*i*/) const
 	{
 		return false;
 	}
 
-	virtual bool is_dynamic(ActorInstance /*i*/) const
+	virtual bool actor_is_dynamic(ActorInstance /*i*/) const
 	{
 		return false;
 	}
 
-	virtual bool is_kinematic(ActorInstance /*i*/) const
+	virtual bool actor_is_kinematic(ActorInstance /*i*/) const
 	{
 		return false;
 	}
 
-	virtual bool is_nonkinematic(ActorInstance /*i*/) const
+	virtual bool actor_is_nonkinematic(ActorInstance /*i*/) const
 	{
 		return false;
 	}
@@ -153,7 +153,7 @@ public:
 		return 0.0f;
 	}
 
-	virtual void set_actor_linear_damping(ActorInstance /*i*/, f32 /*rate*/)
+	virtual void actor_set_linear_damping(ActorInstance /*i*/, f32 /*rate*/)
 	{
 	}
 
@@ -162,7 +162,7 @@ public:
 		return 0.0f;
 	}
 
-	virtual void set_actor_angular_damping(ActorInstance /*i*/, f32 /*rate*/)
+	virtual void actor_set_angular_damping(ActorInstance /*i*/, f32 /*rate*/)
 	{
 	}
 
@@ -171,7 +171,7 @@ public:
 		return VECTOR3_ZERO;
 	}
 
-	virtual void set_actor_linear_velocity(ActorInstance /*i*/, const Vector3& /*vel*/)
+	virtual void actor_set_linear_velocity(ActorInstance /*i*/, const Vector3& /*vel*/)
 	{
 	}
 
@@ -180,45 +180,45 @@ public:
 		return VECTOR3_ZERO;
 	}
 
-	virtual void set_actor_angular_velocity(ActorInstance /*i*/, const Vector3& /*vel*/)
+	virtual void actor_set_angular_velocity(ActorInstance /*i*/, const Vector3& /*vel*/)
 	{
 	}
 
-	virtual void add_actor_impulse(ActorInstance /*i*/, const Vector3& /*impulse*/)
+	virtual void actor_add_impulse(ActorInstance /*i*/, const Vector3& /*impulse*/)
 	{
 	}
 
-	virtual void add_actor_impulse_at(ActorInstance /*i*/, const Vector3& /*impulse*/, const Vector3& /*pos*/)
+	virtual void actor_add_impulse_at(ActorInstance /*i*/, const Vector3& /*impulse*/, const Vector3& /*pos*/)
 	{
 	}
 
-	virtual void add_actor_torque_impulse(ActorInstance /*i*/, const Vector3& /*imp*/)
+	virtual void actor_add_actor_torque_impulse(ActorInstance /*i*/, const Vector3& /*imp*/)
 	{
 	}
 
-	virtual void push_actor(ActorInstance /*i*/, const Vector3& /*vel*/, f32 /*mass*/)
+	virtual void actor_push(ActorInstance /*i*/, const Vector3& /*vel*/, f32 /*mass*/)
 	{
 	}
 
-	virtual void push_actor_at(ActorInstance /*i*/, const Vector3& /*vel*/, f32 /*mass*/, const Vector3& /*pos*/)
+	virtual void actor_push_at(ActorInstance /*i*/, const Vector3& /*vel*/, f32 /*mass*/, const Vector3& /*pos*/)
 	{
 	}
 
-	virtual bool is_sleeping(ActorInstance /*i*/)
+	virtual bool actor_is_sleeping(ActorInstance /*i*/)
 	{
 		return false;
 	}
 
-	virtual void wake_up(ActorInstance /*i*/)
+	virtual void actor_wake_up(ActorInstance /*i*/)
 	{
 	}
 
-	virtual ControllerInstance create_controller(UnitId /*id*/, const ControllerDesc& /*cd*/, const Matrix4x4& /*tm*/)
+	virtual ControllerInstance controller_create(UnitId /*id*/, const ControllerDesc& /*cd*/, const Matrix4x4& /*tm*/)
 	{
 		return make_controller_instance(UINT32_MAX);
 	}
 
-	virtual void destroy_controller(ControllerInstance /*id*/)
+	virtual void controller_destroy(ControllerInstance /*id*/)
 	{
 	}
 
@@ -227,40 +227,40 @@ public:
 		return make_controller_instance(UINT32_MAX);
 	}
 
-	virtual Vector3 position(ControllerInstance /*i*/) const
+	virtual Vector3 controller_position(ControllerInstance /*i*/) const
 	{
 		return VECTOR3_ZERO;
 	}
 
-	virtual void move_controller(ControllerInstance /*i*/, const Vector3& /*pos*/)
+	virtual void controller_move(ControllerInstance /*i*/, const Vector3& /*pos*/)
 	{
 	}
 
-	virtual void set_height(ControllerInstance /*i*/, f32 /*height*/)
+	virtual void controller_set_height(ControllerInstance /*i*/, f32 /*height*/)
 	{
 	}
 
-	virtual bool collides_up(ControllerInstance /*i*/) const
+	virtual bool controller_collides_up(ControllerInstance /*i*/) const
 	{
 		return false;
 	}
 
-	virtual bool collides_down(ControllerInstance /*i*/) const
+	virtual bool controller_collides_down(ControllerInstance /*i*/) const
 	{
 		return false;
 	}
 
-	virtual bool collides_sides(ControllerInstance /*i*/) const
+	virtual bool controller_collides_sides(ControllerInstance /*i*/) const
 	{
 		return false;
 	}
 
-	virtual JointInstance create_joint(ActorInstance /*a0*/, ActorInstance /*a1*/, const JointDesc& /*jd*/)
+	virtual JointInstance joint_create(ActorInstance /*a0*/, ActorInstance /*a1*/, const JointDesc& /*jd*/)
 	{
 		return make_joint_instance(UINT32_MAX);
 	}
 
-	virtual void destroy_joint(JointInstance /*i*/)
+	virtual void joint_destroy(JointInstance /*i*/)
 	{
 	}
 

src/world/world.cpp

@@ -564,7 +564,7 @@ void spawn_units(World& w, const UnitResource& ur, const Vector3& pos, const Qua
 			const ColliderDesc* cd = (const ColliderDesc*)data;
 			for (u32 i = 0; i < component->num_instances; ++i)
 			{
-				physics_world->create_collider(unit_lookup[unit_index[i]], cd);
+				physics_world->collider_create(unit_lookup[unit_index[i]], cd);
 				cd = (ColliderDesc*)((char*)(cd + 1) + cd->size);
 			}
 		}
@@ -574,7 +574,7 @@ void spawn_units(World& w, const UnitResource& ur, const Vector3& pos, const Qua
 			for (u32 i = 0; i < component->num_instances; ++i, ++ar)
 			{
 				Matrix4x4 tm = scene_graph->world_pose(scene_graph->get(unit_lookup[unit_index[i]]));
-				physics_world->create_actor(unit_lookup[unit_index[i]], ar, tm);
+				physics_world->actor_create(unit_lookup[unit_index[i]], ar, tm);
 			}
 		}
 		else if (component->type == COMPONENT_TYPE_CONTROLLER)
@@ -583,7 +583,7 @@ void spawn_units(World& w, const UnitResource& ur, const Vector3& pos, const Qua
 			for (u32 i = 0; i < component->num_instances; ++i, ++cd)
 			{
 				Matrix4x4 tm = scene_graph->world_pose(scene_graph->get(unit_lookup[unit_index[i]]));
-				physics_world->create_controller(unit_lookup[unit_index[i]], *cd, tm);
+				physics_world->controller_create(unit_lookup[unit_index[i]], *cd, tm);
 			}
 		}
 		else if (component->type == COMPONENT_TYPE_MESH_RENDERER)