Use 'get' instead of 'lookup'

engine/lua/LuaPhysicsWorld.cpp

@@ -67,7 +67,7 @@ static int physics_world_make_raycast(lua_State* L)
 
 	RaycastId raycast = world->create_raycast((CollisionMode::Enum) mode, (CollisionType::Enum) filter);
 
-	stack.push_raycast(world->lookup_raycast(raycast));
+	stack.push_raycast(world->get_raycast(raycast));
 	return 1;
 }
 

engine/lua/LuaSprite.cpp

@@ -110,6 +110,16 @@ static int sprite_set_local_pose(lua_State* L)
 	return 0;
 }
 
+//-----------------------------------------------------------------------------
+static int sprite_set_frame(lua_State* L)
+{
+	LuaStack stack(L);
+
+	Sprite* sprite = stack.get_sprite(1);
+	sprite->set_frame(stack.get_int(2));
+	return 0;
+}
+
 //-----------------------------------------------------------------------------
 void load_sprite(LuaEnvironment& env)
 {
@@ -119,6 +129,7 @@ void load_sprite(LuaEnvironment& env)
 	env.load_module_function("Sprite", "set_local_position", 	sprite_set_local_position);
 	env.load_module_function("Sprite", "set_local_rotation", 	sprite_set_local_rotation);
 	env.load_module_function("Sprite", "set_local_pose", 		sprite_set_local_pose);
+	env.load_module_function("Sprite", "set_frame",				sprite_set_frame);
 }
 
 } // namespace crown

engine/lua/LuaWorld.cpp

@@ -47,7 +47,7 @@ static int world_spawn_unit(lua_State* L)
 
 	UnitId unit = world->spawn_unit(name, pos, rot);
 
-	stack.push_unit(world->lookup_unit(unit));
+	stack.push_unit(world->get_unit(unit));
 	return 1;
 }
 
@@ -90,7 +90,7 @@ static int world_units(lua_State* L)
 	for (uint32_t i = 0; i < array::size(all_units); i++)
 	{
 		stack.push_key_begin((int32_t) i + 1);
-		stack.push_unit(world->lookup_unit(all_units[i]));
+		stack.push_unit(world->get_unit(all_units[i]));
 		stack.push_key_end();
 	}
 
@@ -200,7 +200,7 @@ static int world_create_window_gui(lua_State* L)
 	World* world = stack.get_world(1);
 	GuiId id = world->create_window_gui(stack.get_int(2), stack.get_int(3));
 
-	stack.push_gui(world->lookup_gui(id));
+	stack.push_gui(world->get_gui(id));
 	return 1;
 }
 

engine/physics/Actor.cpp

@@ -550,7 +550,7 @@ UnitId Actor::unit_id() const
 //-----------------------------------------------------------------------------
 Unit* Actor::unit()
 {
-	return (m_unit.id == INVALID_ID) ? NULL : m_world.world().lookup_unit(m_unit);
+	return (m_unit.id == INVALID_ID) ? NULL : m_world.world().get_unit(m_unit);
 }
 
 //-----------------------------------------------------------------------------

engine/physics/PhysicsWorld.cpp

@@ -358,19 +358,19 @@ void PhysicsWorld::destroy_raycast(RaycastId id)
 }
 
 //-----------------------------------------------------------------------------
-Actor* PhysicsWorld::lookup_actor(ActorId id)
+Actor* PhysicsWorld::get_actor(ActorId id)
 {
 	return id_array::get(m_actors, id);
 }
 
 //-----------------------------------------------------------------------------
-Controller* PhysicsWorld::lookup_controller(ControllerId id)
+Controller* PhysicsWorld::get_controller(ControllerId id)
 {
 	return id_array::get(m_controllers, id);
 }
 
 //-----------------------------------------------------------------------------
-Raycast* PhysicsWorld::lookup_raycast(RaycastId id)
+Raycast* PhysicsWorld::get_raycast(RaycastId id)
 {
 	return id_array::get(m_raycasts, id);
 }

engine/physics/PhysicsWorld.h

@@ -113,9 +113,9 @@ public:
 	/// Draws debug lines.
 	void draw_debug();
 
-	Actor* lookup_actor(ActorId id);
-	Controller* lookup_controller(ControllerId id);
-	Raycast* lookup_raycast(RaycastId id);
+	Actor* get_actor(ActorId id);
+	Controller* get_controller(ControllerId id);
+	Raycast* get_raycast(RaycastId id);
 
 	World& world() { return m_world; }
 	EventStream& events() { return m_events; }

engine/renderers/RenderWorld.cpp

@@ -254,7 +254,7 @@ void RenderWorld::destroy_mesh(MeshId id)
 }
 
 //-----------------------------------------------------------------------------
-Mesh* RenderWorld::lookup_mesh(MeshId mesh)
+Mesh* RenderWorld::get_mesh(MeshId mesh)
 {
 	return id_array::get(m_mesh, mesh);
 }
@@ -274,7 +274,7 @@ void RenderWorld::destroy_sprite(SpriteId id)
 }
 
 //-----------------------------------------------------------------------------
-Sprite*	RenderWorld::lookup_sprite(SpriteId id)
+Sprite*	RenderWorld::get_sprite(SpriteId id)
 {
 	return id_array::get(m_sprite, id);
 }
@@ -294,7 +294,7 @@ void RenderWorld::destroy_material(MaterialId id)
 }
 
 //-----------------------------------------------------------------------------
-Material* RenderWorld::lookup_material(MaterialId id)
+Material* RenderWorld::get_material(MaterialId id)
 {
 	return id_array::get(m_materials, id);
 }
@@ -316,7 +316,7 @@ void RenderWorld::destroy_gui(GuiId id)
 }
 
 //-----------------------------------------------------------------------------
-Gui* RenderWorld::lookup_gui(GuiId id)
+Gui* RenderWorld::get_gui(GuiId id)
 {
 	return id_array::get(m_guis, id);
 }

engine/renderers/RenderWorld.h

@@ -77,19 +77,19 @@ public:
 
 	MeshId create_mesh(MeshResource* mr, SceneGraph& sg, int32_t node);
 	void destroy_mesh(MeshId id);
-	Mesh* lookup_mesh(MeshId mesh);
+	Mesh* get_mesh(MeshId mesh);
 
 	SpriteId create_sprite(SpriteResource* sr, SceneGraph& sg, int32_t node);
 	void destroy_sprite(SpriteId id);
-	Sprite* lookup_sprite(SpriteId id);
+	Sprite* get_sprite(SpriteId id);
 
 	MaterialId create_material(MaterialResource* mr);
 	void destroy_material(MaterialId id);
-	Material* lookup_material(MaterialId id);
+	Material* get_material(MaterialId id);
 
 	GuiId create_gui(uint16_t width, uint16_t height);
 	void destroy_gui(GuiId id);
-	Gui* lookup_gui(GuiId id);
+	Gui* get_gui(GuiId id);
 
 	void update(const Matrix4x4& view, const Matrix4x4& projection, uint16_t x, uint16_t y, uint16_t width, uint16_t height, float dt);
 

engine/renderers/Sprite.cpp

@@ -44,6 +44,8 @@ Sprite::Sprite(RenderWorld& render_world, SceneGraph& sg, int32_t node, const Sp
 	, m_scene_graph(sg)
 	, m_node(node)
 	, m_resource(sr)
+	, m_frame(0)
+	// , m_animator(this)
 {
 	m_vb = sr->vertex_buffer();
 	m_ib = sr->index_buffer();
@@ -114,10 +116,34 @@ void Sprite::set_material(MaterialId mat)
 	m_material = mat;
 }
 
+//-----------------------------------------------------------------------------
+void Sprite::set_frame(uint32_t i)
+{
+	m_frame = i;
+}
+
+//-----------------------------------------------------------------------------
+void Sprite::play_animation(const char* name, bool loop)
+{
+	// m_animator.play_animation(name, loop);
+}
+
+//-----------------------------------------------------------------------------
+void Sprite::stop_animation()
+{
+	// m_animator.stop_animation();
+}
+
+//-----------------------------------------------------------------------------
+void Sprite::update(float dt)
+{
+	// m_animator.update(dt);
+}
+
 //-----------------------------------------------------------------------------
 void Sprite::render(Renderer& r, UniformId uniform, float dt)
 {
-	Material* material = m_render_world.lookup_material(m_material);
+	Material* material = m_render_world.get_material(m_material);
 	material->bind(r, uniform);
 
 	r.set_state(STATE_DEPTH_WRITE 
@@ -127,7 +153,7 @@ void Sprite::render(Renderer& r, UniformId uniform, float dt)
 		| STATE_BLEND_EQUATION_ADD 
 		| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
 	r.set_vertex_buffer(m_vb);
-	r.set_index_buffer(m_ib, 0, 6);
+	r.set_index_buffer(m_ib, m_frame * 6, 6);
 	r.set_pose(world_pose());
 	r.commit(0);
 }

engine/renderers/Sprite.h

@@ -31,6 +31,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Vector3.h"
 #include "Matrix4x4.h"
 #include "Quaternion.h"
+// #include "SpriteAnimator.h"
 
 namespace crown
 {
@@ -44,23 +45,29 @@ struct Unit;
 //-----------------------------------------------------------------------------
 struct Sprite
 {
-							Sprite(RenderWorld& render_world, SceneGraph& sg, int32_t node, const SpriteResource* sr);
-							~Sprite();
+	Sprite(RenderWorld& render_world, SceneGraph& sg, int32_t node, const SpriteResource* sr);
+	~Sprite();
 
-	Vector3					local_position() const;
-	Quaternion				local_rotation() const;
-	Matrix4x4				local_pose() const;
+	Vector3 local_position() const;
+	Quaternion local_rotation() const;
+	Matrix4x4 local_pose() const;
 
-	Vector3					world_position() const;
-	Quaternion				world_rotation() const;
-	Matrix4x4				world_pose() const;
+	Vector3 world_position() const;
+	Quaternion world_rotation() const;
+	Matrix4x4 world_pose() const;
 
-	void					set_local_position(Unit* unit, const Vector3& pos);
-	void					set_local_rotation(Unit* unit, const Quaternion& rot);
-	void					set_local_pose(Unit* unit, const Matrix4x4& pose);
+	void set_local_position(Unit* unit, const Vector3& pos);
+	void set_local_rotation(Unit* unit, const Quaternion& rot);
+	void set_local_pose(Unit* unit, const Matrix4x4& pose);
 
-	void					set_material(MaterialId mat);
-	void					render(Renderer& r, UniformId uniform, float dt);
+	void set_material(MaterialId mat);
+	void render(Renderer& r, UniformId uniform, float dt);
+	void set_frame(uint32_t i);
+
+	void play_animation(const char* name, bool loop);
+	void stop_animation();
+
+	void update(float dt);
 
 public:
 
@@ -69,9 +76,12 @@ public:
 	int32_t					m_node;
 	const SpriteResource*	m_resource;
 
+	uint32_t				m_frame;
 	MaterialId				m_material;
 	VertexBufferId			m_vb;
 	IndexBufferId			m_ib;
+
+	// SpriteAnimator m_animator;
 };
 
-} // namespace crown
+} // namespace crown

engine/world/Unit.cpp

@@ -237,7 +237,7 @@ void Unit::set_default_material()
 
 	for (uint32_t i = 0; i < m_num_sprites; i++)
 	{
-		Sprite* s = m_world.render_world()->lookup_sprite(m_sprites[i].component);
+		Sprite* s = m_world.render_world()->get_sprite(m_sprites[i].component);
 		s->set_material(m_materials[0].component);
 	}
 }
@@ -443,7 +443,7 @@ Camera* Unit::camera(const char* name)
 
 	CE_ASSERT(cam.id != INVALID_ID, "Unit does not have camera with name '%s'", name);
 
-	return m_world.lookup_camera(cam);
+	return m_world.get_camera(cam);
 }
 
 //-----------------------------------------------------------------------------
@@ -453,7 +453,7 @@ Camera* Unit::camera(uint32_t i)
 
 	CE_ASSERT(cam.id != INVALID_ID, "Unit does not have camera with index '%d'", i);
 
-	return m_world.lookup_camera(cam);
+	return m_world.get_camera(cam);
 }
 
 //-----------------------------------------------------------------------------
@@ -463,7 +463,7 @@ Mesh* Unit::mesh(const char* name)
 
 	CE_ASSERT(mesh.id != INVALID_ID, "Unit does not have mesh with name '%s'", name);
 
-	return m_world.render_world()->lookup_mesh(mesh);
+	return m_world.render_world()->get_mesh(mesh);
 }
 
 //-----------------------------------------------------------------------------
@@ -473,7 +473,7 @@ Mesh* Unit::mesh(uint32_t i)
 
 	CE_ASSERT(mesh.id != INVALID_ID, "Unit does not have mesh with index '%d'", i);
 
-	return m_world.render_world()->lookup_mesh(mesh);
+	return m_world.render_world()->get_mesh(mesh);
 }
 
 //-----------------------------------------------------------------------------
@@ -483,7 +483,7 @@ Sprite*	Unit::sprite(const char* name)
 
 	CE_ASSERT(sprite.id != INVALID_ID, "Unit does not have sprite with name '%s'", name);
 
-	return m_world.render_world()->lookup_sprite(sprite);
+	return m_world.render_world()->get_sprite(sprite);
 }
 
 //-----------------------------------------------------------------------------
@@ -493,7 +493,7 @@ Sprite*	Unit::sprite(uint32_t i)
 
 	CE_ASSERT(sprite.id != INVALID_ID, "Unit does not have sprite with index '%d'", i);
 
-	return m_world.render_world()->lookup_sprite(sprite);
+	return m_world.render_world()->get_sprite(sprite);
 }
 
 //-----------------------------------------------------------------------------
@@ -503,7 +503,7 @@ Actor* Unit::actor(const char* name)
 
 	CE_ASSERT(actor.id != INVALID_ID, "Unit does not have actor with name '%s'", name);
 
-	return m_world.physics_world()->lookup_actor(actor);
+	return m_world.physics_world()->get_actor(actor);
 }
 
 //-----------------------------------------------------------------------------
@@ -513,7 +513,7 @@ Actor* Unit::actor(uint32_t i)
 
 	CE_ASSERT(actor.id != INVALID_ID, "Unit does not have actor with index '%d'", i);
 
-	return m_world.physics_world()->lookup_actor(actor);
+	return m_world.physics_world()->get_actor(actor);
 }	
 
 //-----------------------------------------------------------------------------
@@ -523,7 +523,7 @@ Actor* Unit::actor_by_index(StringId32 name)
 
 	// CE_ASSERT(actor.id != INVALID_ID, "Unit does not have actor with name '%d'", name);
 
-	return m_world.physics_world()->lookup_actor(actor);
+	return m_world.physics_world()->get_actor(actor);
 }
 
 //-----------------------------------------------------------------------------
@@ -531,7 +531,7 @@ Controller* Unit::controller()
 {
 	if (m_controller.component.id != INVALID_ID)
 	{
-		return m_world.physics_world()->lookup_controller(m_controller.component);
+		return m_world.physics_world()->get_controller(m_controller.component);
 	}
 
 	return NULL;
@@ -544,7 +544,7 @@ Material* Unit::material(const char* name)
 
 	CE_ASSERT(material.id != INVALID_ID, "Unit does not have material with name '%s'", name);
 
-	return m_world.render_world()->lookup_material(material);
+	return m_world.render_world()->get_material(material);
 }
 
 //-----------------------------------------------------------------------------
@@ -554,7 +554,7 @@ Material* Unit::material(uint32_t i)
 
 	CE_ASSERT(material.id != INVALID_ID, "Unit does not have material with name '%d'", i);
 
-	return m_world.render_world()->lookup_material(material);
+	return m_world.render_world()->get_material(material);
 }
 
 //-----------------------------------------------------------------------------

engine/world/World.cpp

@@ -142,7 +142,7 @@ void World::units(Array<UnitId>& units) const
 //-----------------------------------------------------------------------------
 void World::link_unit(UnitId child, UnitId parent, int32_t node)
 {
-	Unit* parent_unit = lookup_unit(parent);
+	Unit* parent_unit = get_unit(parent);
 	parent_unit->link_node(0, node);
 }
 
@@ -152,13 +152,13 @@ void World::unlink_unit(UnitId /*child*/)
 }
 
 //-----------------------------------------------------------------------------
-Unit* World::lookup_unit(UnitId id)
+Unit* World::get_unit(UnitId id)
 {
 	return id_array::get(m_units, id);
 }
 
 //-----------------------------------------------------------------------------
-Camera* World::lookup_camera(CameraId id)
+Camera* World::get_camera(CameraId id)
 {
 	return id_array::get(m_cameras, id);
 }
@@ -253,9 +253,9 @@ void World::destroy_gui(GuiId id)
 }
 
 //-----------------------------------------------------------------------------
-Gui* World::lookup_gui(GuiId id)
+Gui* World::get_gui(GuiId id)
 {
-	return m_render_world.lookup_gui(id);
+	return m_render_world.get_gui(id);
 }
 
 //-----------------------------------------------------------------------------

engine/world/World.h

@@ -93,10 +93,10 @@ public:
 	void unlink_unit(UnitId id);
 
 	/// Returns the unit @a id.
-	Unit* lookup_unit(UnitId id);
+	Unit* get_unit(UnitId id);
 
 	/// Returns the camera @a id.
-	Camera* lookup_camera(CameraId id);
+	Camera* get_camera(CameraId id);
 
 	/// Updates all units and sub-systems with the given @a dt delta time.
 	void update(float dt);
@@ -139,7 +139,7 @@ public:
 	void destroy_gui(GuiId id);
 
 	/// Returns the gui @a id.
-	Gui* lookup_gui(GuiId id);
+	Gui* get_gui(GuiId id);
 
 	DebugLine* create_debug_line(bool depth_test);
 	void destroy_debug_line(DebugLine* line);