Update to reflect IdArray/IdTable changes

engine/ConsoleServer.cpp

@@ -63,7 +63,7 @@ void ConsoleServer::init(uint16_t port, bool wait)
 //-----------------------------------------------------------------------------
 void ConsoleServer::shutdown()
 {
-	for (uint32_t i = 0; i < m_clients.size(); i++)
+	for (uint32_t i = 0; i < id_array::size(m_clients); i++)
 	{
 		m_clients[i].close();
 	}
@@ -108,7 +108,7 @@ void ConsoleServer::send(TCPSocket client, const char* message)
 //-----------------------------------------------------------------------------
 void ConsoleServer::send_to_all(const char* message)
 {
-	for (uint32_t i = 0; i < m_clients.size(); i++)
+	for (uint32_t i = 0; i < id_array::size(m_clients); i++)
 	{
 		send(m_clients[i].socket, message);
 	}
@@ -118,7 +118,7 @@ void ConsoleServer::send_to_all(const char* message)
 void ConsoleServer::update()
 {
 	// Check for new clients only if we have room for them
-	if (m_clients.size() < CE_MAX_CONSOLE_CLIENTS - 1)
+	if (id_array::size(m_clients) < CE_MAX_CONSOLE_CLIENTS - 1)
 	{
 		TCPSocket client;
 		AcceptResult result = m_server.accept_nonblock(client);
@@ -132,7 +132,7 @@ void ConsoleServer::update()
 	Array<Id> to_remove(alloc);
 
 	// Update all clients
-	for (uint32_t i = 0; i < m_clients.size(); i++)
+	for (uint32_t i = 0; i < id_array::size(m_clients); i++)
 	{
 		ReadResult rr = update_client(m_clients[i].socket);
 		if (rr.error != ReadResult::NO_ERROR) array::push_back(to_remove, m_clients[i].id);
@@ -141,8 +141,8 @@ void ConsoleServer::update()
 	// Remove clients
 	for (uint32_t i = 0; i < array::size(to_remove); i++)
 	{
-		m_clients.lookup(to_remove[i]).socket.close();
-		m_clients.destroy(to_remove[i]);
+		id_array::get(m_clients, to_remove[i]).socket.close();
+		id_array::destroy(m_clients, to_remove[i]);
 	}
 }
 
@@ -151,8 +151,8 @@ void ConsoleServer::add_client(TCPSocket socket)
 {
 	Client client;
 	client.socket = socket;
-	Id id = m_clients.create(client);
-	m_clients.lookup(id).id = id;
+	Id id = id_array::create(m_clients, client);
+	id_array::get(m_clients, id).id = id;
 }
 
 //-----------------------------------------------------------------------------

engine/Device.cpp

@@ -495,7 +495,7 @@ void Device::reload(const char* type, const char* name)
 			{
 				Log::d("Reloading unit: %s", name);
 				/// Reload unit in all worlds
-				for (uint32_t i = 0; i < m_world_manager->worlds().size(); i++)
+				for (uint32_t i = 0; i < id_array::size(m_world_manager->worlds()); i++)
 				{
 					m_world_manager->worlds()[i]->reload_units((UnitResource*) old_res, (UnitResource*) new_res);
 				}
@@ -504,7 +504,7 @@ void Device::reload(const char* type, const char* name)
 			case SOUND_TYPE:
 			{
 				Log::d("Reloading sound: %s", name);
-				for (uint32_t i = 0; i < m_world_manager->worlds().size(); i++)
+				for (uint32_t i = 0; i < id_array::size(m_world_manager->worlds()); i++)
 				{
 					m_world_manager->worlds()[i]->sound_world()->reload_sounds((SoundResource*) old_res, (SoundResource*) new_res);
 				}

engine/audio/backend/ALSoundWorld.cpp

@@ -243,27 +243,27 @@ public:
 	{
 		SoundInstance instance;
 		instance.create(sr, pos);
-		SoundInstanceId id = m_playing_sounds.create(instance);
-		m_playing_sounds.lookup(id).m_id = id;
+		SoundInstanceId id = id_array::create(m_playing_sounds, instance);
+		id_array::get(m_playing_sounds, id).m_id = id;
 		instance.play(loop, volume);
 		return id;
 	}
 
 	virtual void stop(SoundInstanceId id)
 	{
-		SoundInstance& instance = m_playing_sounds.lookup(id);
+		SoundInstance& instance = id_array::get(m_playing_sounds, id);
 		instance.destroy();
-		m_playing_sounds.destroy(id);
+		id_array::destroy(m_playing_sounds, id);
 	}
 
 	virtual bool is_playing(SoundInstanceId id)
 	{
-		return m_playing_sounds.has(id) && m_playing_sounds.lookup(id).is_playing();
+		return id_array::has(m_playing_sounds, id) && id_array::get(m_playing_sounds, id).is_playing();
 	}
 
 	virtual void stop_all()
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].stop();
 		}
@@ -271,7 +271,7 @@ public:
 
 	virtual void pause_all()
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].pause();
 		}
@@ -279,7 +279,7 @@ public:
 
 	virtual void resume_all()
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].resume();
 		}
@@ -287,7 +287,7 @@ public:
 
 	virtual void set_sound_positions(uint32_t count, const SoundInstanceId* ids, const Vector3* positions)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].set_position(positions[i]);
 		}
@@ -295,7 +295,7 @@ public:
 
 	virtual void set_sound_ranges(uint32_t count, const SoundInstanceId* ids, const float* ranges)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].set_range(ranges[i]);
 		}
@@ -303,7 +303,7 @@ public:
 
 	virtual void set_sound_volumes(uint32_t count, const SoundInstanceId* ids, const float* volumes)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].set_volume(volumes[i]);
 		}		
@@ -311,7 +311,7 @@ public:
 
 	virtual void reload_sounds(SoundResource* old_sr, SoundResource* new_sr)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			if (m_playing_sounds[i].resource() == old_sr)
 			{
@@ -340,7 +340,7 @@ public:
 		Array<SoundInstanceId> to_delete(alloc);
 
 		// Check what sounds finished playing
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			SoundInstance& instance = m_playing_sounds[i];
 			if (instance.finished())

engine/audio/backend/SLESSoundWorld.cpp

@@ -385,9 +385,9 @@ public:
 	SoundInstanceId play(SoundResource* sr, bool loop, float volume)
 	{
 		SoundInstance dummy;
-		SoundInstanceId id = m_playing_sounds.create(dummy);
+		SoundInstanceId id = id_array::create(m_playing_sounds, dummy);
 
-		SoundInstance& instance = m_playing_sounds.lookup(id);
+		SoundInstance& instance = id_array::get(m_playing_sounds, id);
 		instance.create(audio_system::s_sl_engine_itf, audio_system::s_sl_output_mix, id, sr);
 		instance.play(loop, volume);
 
@@ -396,19 +396,18 @@ public:
 
 	virtual void stop(SoundInstanceId id)
 	{
-		SoundInstance& instance = m_playing_sounds.lookup(id);
-		instance.destroy();
-		m_playing_sounds.destroy(id);
+		id_array::get(m_playing_sounds, id).destroy();
+		id_array::destroy(m_playing_sounds, id);
 	}
 
 	virtual bool is_playing(SoundInstanceId id)
 	{
-		return m_playing_sounds.has(id) && m_playing_sounds.lookup(id).is_playing();
+		return id_array::has(m_playing_sounds, id) && id_array::get(m_playing_sounds, id).is_playing();
 	}
 
 	virtual void stop_all()
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].stop();
 		}
@@ -416,7 +415,7 @@ public:
 
 	virtual void pause_all()
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].pause();
 		}
@@ -424,7 +423,7 @@ public:
 
 	virtual void resume_all()
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].resume();
 		}
@@ -432,7 +431,7 @@ public:
 
 	virtual void set_sound_positions(uint32_t count, const SoundInstanceId* ids, const Vector3* positions)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].set_position(positions[i]);
 		}
@@ -440,7 +439,7 @@ public:
 
 	virtual void set_sound_ranges(uint32_t count, const SoundInstanceId* ids, const float* ranges)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].set_range(ranges[i]);
 		}
@@ -448,7 +447,7 @@ public:
 
 	virtual void set_sound_volumes(uint32_t count, const SoundInstanceId* ids, const float* volumes)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			m_playing_sounds[i].set_volume(volumes[i]);
 		}
@@ -456,7 +455,7 @@ public:
 
 	virtual void reload_sounds(SoundResource* old_sr, SoundResource* new_sr)
 	{
-		for (uint32_t i = 0; i < m_playing_sounds.size(); i++)
+		for (uint32_t i = 0; i < id_array::size(m_playing_sounds); i++)
 		{
 			if (m_playing_sounds[i].resource() == old_sr)
 			{
@@ -478,7 +477,7 @@ public:
 			const SoundInstanceId id = queue::front(*sles_sound_world::s_stop_queue);
 			queue::pop_front(*sles_sound_world::s_stop_queue);
 
-			if (!m_playing_sounds.has(id)) continue;
+			if (!id_array::has(m_playing_sounds, id)) continue;
 			stop(id);
 		}
 	}

engine/physics/PhysicsWorld.cpp

@@ -305,85 +305,74 @@ PhysicsWorld::~PhysicsWorld()
 ActorId	PhysicsWorld::create_actor(const PhysicsResource* res, const uint32_t index, SceneGraph& sg, int32_t node, UnitId unit_id)
 {
 	Actor* actor = CE_NEW(m_actors_pool, Actor)(*this, res, index, sg, node, unit_id);
-	return m_actors.create(actor);
+	return id_array::create(m_actors, actor);
 }
 
 //-----------------------------------------------------------------------------
 void PhysicsWorld::destroy_actor(ActorId id)
 {
-	CE_ASSERT(m_actors.has(id), "Actor does not exist");
-
-	CE_DELETE(m_actors_pool, m_actors.lookup(id));
-	m_actors.destroy(id);
+	CE_DELETE(m_actors_pool, id_array::get(m_actors, id));
+	id_array::destroy(m_actors, id);
 }
 
 //-----------------------------------------------------------------------------
 ControllerId PhysicsWorld::create_controller(const PhysicsResource* pr, SceneGraph& sg, int32_t node)
 {
 	Controller* controller = CE_NEW(m_controllers_pool, Controller)(pr, sg, node, physics_system::s_physics, m_controller_manager);
-	return m_controllers.create(controller);
+	return id_array::create(m_controllers, 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);
+	CE_DELETE(m_controllers_pool, id_array::get(m_controllers, id));
+	id_array::destroy(m_controllers, id);
 }
 
 //-----------------------------------------------------------------------------
 JointId	PhysicsWorld::create_joint(const PhysicsResource* pr, const uint32_t index, const Actor& actor_0, const Actor& actor_1)
 {
 	Joint* joint = CE_NEW(m_joints_pool, Joint)(physics_system::s_physics, pr, index, actor_0, actor_1);
-	return m_joints.create(joint);
+	return id_array::create(m_joints, joint);
 }
 
 //-----------------------------------------------------------------------------
 void PhysicsWorld::destroy_joint(JointId id)
 {
-	CE_ASSERT(m_joints.has(id), "Joint does not exist");
-
-	CE_DELETE(m_joints_pool, m_joints.lookup(id));
-	m_joints.destroy(id);
+	CE_DELETE(m_joints_pool, id_array::get(m_joints, id));
+	id_array::destroy(m_joints, id);
 }
 
 //-----------------------------------------------------------------------------
 RaycastId PhysicsWorld::create_raycast(CollisionMode::Enum mode, CollisionType::Enum filter)
 {
 	Raycast* raycast = CE_NEW(m_raycasts_pool, Raycast)(m_scene, mode, filter);
-	return m_raycasts.create(raycast);
+	return id_array::create(m_raycasts, raycast);
 }
 
 //-----------------------------------------------------------------------------
 void PhysicsWorld::destroy_raycast(RaycastId id)
 {
-	CE_ASSERT(m_raycasts.has(id), "Raycast does not exists");
-
-	CE_DELETE(m_raycasts_pool, m_raycasts.lookup(id));
-	m_raycasts.destroy(id);
+	CE_DELETE(m_raycasts_pool, id_array::get(m_raycasts, id));
+	id_array::destroy(m_raycasts, id);
 }
 
 //-----------------------------------------------------------------------------
 Actor* PhysicsWorld::lookup_actor(ActorId id)
 {
-	CE_ASSERT(m_actors.has(id), "Actor does not exist");
-	return m_actors.lookup(id);
+	return id_array::get(m_actors, id);
 }
 
 //-----------------------------------------------------------------------------
 Controller* PhysicsWorld::lookup_controller(ControllerId id)
 {
-	CE_ASSERT(m_controllers.has(id), "Controller does not exist");
-	return m_controllers.lookup(id);
+	return id_array::get(m_controllers, id);
 }
 
 //-----------------------------------------------------------------------------
 Raycast* PhysicsWorld::lookup_raycast(RaycastId id)
 {
-	CE_ASSERT(m_raycasts.has(id), "Raycast does not exists");
-	return m_raycasts.lookup(id);
+	return id_array::get(m_raycasts, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -462,7 +451,7 @@ void PhysicsWorld::update(float dt)
 	}
 
 	// Update controllers
-	for (uint32_t i = 0; i < m_controllers.size(); i++)
+	for (uint32_t i = 0; i < id_array::size(m_controllers); i++)
 	{
 		m_controllers[i]->update();
 	}

engine/renderers/RenderWorld.cpp

@@ -242,77 +242,68 @@ RenderWorld::~RenderWorld()
 MeshId RenderWorld::create_mesh(MeshResource* mr, SceneGraph& sg, int32_t node)
 {
 	Mesh* mesh = CE_NEW(m_mesh_pool, Mesh)(sg, node, mr);
-	return m_mesh.create(mesh);
+	return id_array::create(m_mesh, mesh);
 }
 
 //-----------------------------------------------------------------------------
 void RenderWorld::destroy_mesh(MeshId id)
 {
-	CE_ASSERT(m_mesh.has(id), "Mesh does not exist");
-
-	Mesh* mesh = m_mesh.lookup(id);
+	Mesh* mesh = id_array::get(m_mesh, id);
 	CE_DELETE(m_mesh_pool, mesh);
-	m_mesh.destroy(id);
+	id_array::destroy(m_mesh, id);
 }
 
 //-----------------------------------------------------------------------------
 Mesh* RenderWorld::lookup_mesh(MeshId mesh)
 {
-	CE_ASSERT(m_mesh.has(mesh), "Mesh does not exits");
-
-	return m_mesh.lookup(mesh);
+	return id_array::get(m_mesh, mesh);
 }
 
 //-----------------------------------------------------------------------------
 SpriteId RenderWorld::create_sprite(SpriteResource* sr, SceneGraph& sg, int32_t node)
 {
 	Sprite* sprite = CE_NEW(m_sprite_pool, Sprite)(*this, sg, node, sr);
-	return m_sprite.create(sprite);
+	return id_array::create(m_sprite, sprite);
 }
 
 //-----------------------------------------------------------------------------
 void RenderWorld::destroy_sprite(SpriteId id)
 {
-	CE_ASSERT(m_sprite.has(id), "Sprite does not exist");
-
-	Sprite* sprite = m_sprite.lookup(id);
-	CE_DELETE(m_sprite_pool, sprite);
-	m_sprite.destroy(id);
+	CE_DELETE(m_sprite_pool, id_array::get(m_sprite, id));
+	id_array::destroy(m_sprite, id);
 }
 
 //-----------------------------------------------------------------------------
 Sprite*	RenderWorld::lookup_sprite(SpriteId id)
 {
-	CE_ASSERT(m_sprite.has(id), "Sprite does not exist");
-
-	return m_sprite.lookup(id);
+	return id_array::get(m_sprite, id);
 }
 
 //-----------------------------------------------------------------------------
 MaterialId RenderWorld::create_material(MaterialResource* mr)
 {
 	Material* mat = CE_NEW(m_material_pool, Material)(mr);
-	return m_materials.create(mat);
+	return id_array::create(m_materials, mat);
 }
 
 //-----------------------------------------------------------------------------
 void RenderWorld::destroy_material(MaterialId id)
 {
-	CE_DELETE(m_material_pool, m_materials.lookup(id));
-	m_materials.destroy(id);
+	CE_DELETE(m_material_pool, id_array::get(m_materials, id));
+	id_array::destroy(m_materials, id);
 }
 
 //-----------------------------------------------------------------------------
 Material* RenderWorld::lookup_material(MaterialId id)
 {
-	return m_materials.lookup(id);
+	return id_array::get(m_materials, id);
 }
 
 //-----------------------------------------------------------------------------
 GuiId RenderWorld::create_gui(uint16_t width, uint16_t height)
 {
 	Gui* gui = CE_NEW(m_gui_pool, Gui)(*this, width, height);
-	GuiId id = m_guis.create(gui);
+	GuiId id = id_array::create(m_guis, gui);
 	gui->set_id(id);
 	return id;
 }
@@ -320,18 +311,14 @@ GuiId RenderWorld::create_gui(uint16_t width, uint16_t height)
 //-----------------------------------------------------------------------------
 void RenderWorld::destroy_gui(GuiId id)
 {
-	CE_ASSERT(m_guis.has(id), "Gui does not exist");
-
-	CE_DELETE(m_gui_pool, m_guis.lookup(id));
-	m_guis.destroy(id);
+	CE_DELETE(m_gui_pool, id_array::get(m_guis, id));
+	id_array::destroy(m_guis, id);
 }
 
 //-----------------------------------------------------------------------------
 Gui* RenderWorld::lookup_gui(GuiId id)
 {
-	CE_ASSERT(m_guis.has(id), "Gui does not exist");
-	
-	return m_guis.lookup(id);
+	return id_array::get(m_guis, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -351,7 +338,7 @@ void RenderWorld::update(const Matrix4x4& view, const Matrix4x4& projection, uin
 	r->commit(0);
 
 	// Draw all meshes
-	for (uint32_t m = 0; m < m_mesh.size(); m++)
+	for (uint32_t m = 0; m < id_array::size(m_mesh); m++)
 	{
 		const Mesh* mesh = m_mesh.m_objects[m];
 
@@ -367,7 +354,7 @@ void RenderWorld::update(const Matrix4x4& view, const Matrix4x4& projection, uin
 	}
 
 	// Draw all sprites
-	for (uint32_t s = 0; s < m_sprite.size(); s++)
+	for (uint32_t s = 0; s < id_array::size(m_sprite); s++)
 	{
 		r->set_program(render_world_globals::default_texture_program());
 		// m_sprite[s]->update(dt);

engine/renderers/backend/Renderer.h

@@ -128,7 +128,7 @@ public:
 	/// @a data is the array containig @a size bytes of vertex data in the given @a format.
 	VertexBufferId create_vertex_buffer(size_t size, const void* data, VertexFormat::Enum format)
 	{
-		const VertexBufferId id = m_vertex_buffers.create();
+		const VertexBufferId id = id_table::create(m_vertex_buffers);
 
 		m_submit->m_commands.write(CommandType::CREATE_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -144,7 +144,7 @@ public:
 	/// use Renderer::update_vertex_buffer() to fill the buffer with actual data.
 	VertexBufferId create_dynamic_vertex_buffer(size_t size)
 	{
-		const VertexBufferId id = m_vertex_buffers.create();
+		const VertexBufferId id = id_table::create(m_vertex_buffers);
 
 		m_submit->m_commands.write(CommandType::CREATE_DYNAMIC_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -195,7 +195,7 @@ public:
 	/// at the given @a offset.
 	void update_vertex_buffer(VertexBufferId id, size_t offset, size_t size, const void* data)
 	{
-		CE_ASSERT(m_vertex_buffers.has(id), "Vertex buffer does not exist");
+		CE_ASSERT(id_table::has(m_vertex_buffers, id), "Vertex buffer does not exist");
 
 		m_submit->m_commands.write(CommandType::UPDATE_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -207,7 +207,7 @@ public:
 	/// Destroys the given vertex buffer @a id.
 	void destroy_vertex_buffer(VertexBufferId id)
 	{
-		CE_ASSERT(m_vertex_buffers.has(id), "Vertex buffer does not exist");
+		CE_ASSERT(id_table::has(m_vertex_buffers, id), "Vertex buffer does not exist");
 
 		m_submit->m_commands.write(CommandType::DESTROY_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -226,7 +226,7 @@ public:
 	/// @a data is the array containing @a size bytes of index data.
 	IndexBufferId create_index_buffer(size_t size, const void* data)
 	{
-		const IndexBufferId id = m_index_buffers.create();
+		const IndexBufferId id = id_table::create(m_index_buffers);
 
 		m_submit->m_commands.write(CommandType::CREATE_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -241,7 +241,7 @@ public:
 	/// use Renderer::update_index_buffer() to fill the buffer with actual data.
 	IndexBufferId create_dynamic_index_buffer(size_t size)
 	{
-		const IndexBufferId id = m_index_buffers.create();
+		const IndexBufferId id = id_table::create(m_index_buffers);
 
 		m_submit->m_commands.write(CommandType::CREATE_DYNAMIC_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -290,7 +290,7 @@ public:
 	/// at the given @a offset.
 	void update_index_buffer(IndexBufferId id, size_t offset, size_t size, const void* data)
 	{
-		CE_ASSERT(m_index_buffers.has(id), "Index buffer does not exist");
+		CE_ASSERT(id_table::has(m_index_buffers, id), "Index buffer does not exist");
 
 		m_submit->m_commands.write(CommandType::UPDATE_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -302,7 +302,7 @@ public:
 	/// Destroys the @a id index buffer.
 	void destroy_index_buffer(IndexBufferId id)
 	{
-		CE_ASSERT(m_index_buffers.has(id), "Index buffer does not exist");
+		CE_ASSERT(id_table::has(m_index_buffers, id), "Index buffer does not exist");
 
 		m_submit->m_commands.write(CommandType::DESTROY_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
@@ -321,7 +321,7 @@ public:
 	/// The array @a data should contain @a width * @a height elements of the given @a format.
 	TextureId create_texture(uint32_t width, uint32_t height, PixelFormat::Enum format, const void* data)
 	{
-		const TextureId id = m_textures.create();
+		const TextureId id = id_table::create(m_textures);
 
 		m_submit->m_commands.write(CommandType::CREATE_TEXTURE);
 		m_submit->m_commands.write(id);
@@ -338,7 +338,7 @@ public:
 	/// to Renderer::create_texture()
 	void update_texture(TextureId id, uint32_t x, uint32_t y, uint32_t width, uint32_t height, const void* data)
 	{
-		CE_ASSERT(m_textures.has(id), "Texture does not exist");
+		CE_ASSERT(id_table::has(m_textures, id), "Texture does not exist");
 
 		m_submit->m_commands.write(CommandType::UPDATE_TEXTURE);
 		m_submit->m_commands.write(id);
@@ -352,7 +352,7 @@ public:
 	/// Destroys the texture @æ id.
 	void destroy_texture(TextureId id)
 	{
-		CE_ASSERT(m_textures.has(id), "Texture does not exist");
+		CE_ASSERT(id_table::has(m_textures, id), "Texture does not exist");
 
 		m_submit->m_commands.write(CommandType::DESTROY_TEXTURE);
 		m_submit->m_commands.write(id);
@@ -361,7 +361,7 @@ public:
 	/// Creates a new shader of the given @a type from the string @a text.
 	ShaderId create_shader(ShaderType::Enum type, const char* text)
 	{
-		const ShaderId id = m_shaders.create();
+		const ShaderId id = id_table::create(m_shaders);
 
 		m_submit->m_commands.write(CommandType::CREATE_SHADER);
 		m_submit->m_commands.write(id);
@@ -374,7 +374,7 @@ public:
 	/// Destroy the shader @a id.
 	void destroy_shader(ShaderId id)
 	{
-		CE_ASSERT(m_shaders.has(id), "Shader does not exist");
+		CE_ASSERT(id_table::has(m_shaders, id), "Shader does not exist");
 
 		m_submit->m_commands.write(CommandType::DESTROY_SHADER);
 		m_submit->m_commands.write(id);
@@ -383,7 +383,7 @@ public:
 	/// Creates a new gpu program from @a vertex shader and @a pixel shader.
 	GPUProgramId create_gpu_program(ShaderId vertex, ShaderId pixel)
 	{
-		const GPUProgramId id = m_gpu_programs.create();
+		const GPUProgramId id = id_table::create(m_gpu_programs);
 
 		m_submit->m_commands.write(CommandType::CREATE_GPU_PROGRAM);
 		m_submit->m_commands.write(id);
@@ -396,7 +396,7 @@ public:
 	/// Destroys the gpu program @a id.
 	void destroy_gpu_program(GPUProgramId id)
 	{
-		CE_ASSERT(m_gpu_programs.has(id), "GPU program does not exist");
+		CE_ASSERT(id_table::has(m_gpu_programs, id), "GPU program does not exist");
 
 		m_submit->m_commands.write(CommandType::DESTROY_GPU_PROGRAM);
 		m_submit->m_commands.write(id);
@@ -408,7 +408,7 @@ public:
 	{
 		CE_ASSERT(name_to_stock_uniform(name) == ShaderUniform::COUNT, "Uniform name '%s' is a stock uniform.", name);
 
-		const UniformId id = m_uniforms.create();
+		const UniformId id = id_table::create(m_uniforms);
 		size_t len = string::strlen(name);
 
 		CE_ASSERT(len < CE_MAX_UNIFORM_NAME_LENGTH, "Max uniform name length is %d", CE_MAX_UNIFORM_NAME_LENGTH);
@@ -426,7 +426,7 @@ public:
 	/// Destroys the uniform @a id.
 	void destroy_uniform(UniformId id)
 	{
-		CE_ASSERT(m_uniforms.has(id), "Uniform does not exist");
+		CE_ASSERT(id_table::has(m_uniforms, id), "Uniform does not exist");
 
 		m_submit->m_commands.write(CommandType::DESTROY_UNIFORM);
 		m_submit->m_commands.write(id);
@@ -435,7 +435,7 @@ public:
 	/// Creates a new render target of size @a width and @a height with the given @a format.
 	RenderTargetId create_render_target(uint16_t width, uint16_t height, PixelFormat::Enum format, uint32_t flags = 0)
 	{
-		const RenderTargetId id = m_render_targets.create();
+		const RenderTargetId id = id_table::create(m_render_targets);
 
 		m_submit->m_commands.write(CommandType::CREATE_RENDER_TARGET);
 		m_submit->m_commands.write(id);
@@ -450,7 +450,7 @@ public:
 	/// Destroys the render target @a id.
 	void destroy_render_target(RenderTargetId id)
 	{
-		CE_ASSERT(m_render_targets.has(id), "Render target does not exist");
+		CE_ASSERT(id_table::has(m_render_targets, id), "Render target does not exist");
 
 		m_submit->m_commands.write(CommandType::DESTROY_RENDER_TARGET);
 		m_submit->m_commands.write(id);
@@ -767,13 +767,13 @@ public:
 
 	void set_program(GPUProgramId id)
 	{
-		CE_ASSERT(m_gpu_programs.has(id), "GPU program does not exist");
+		CE_ASSERT(id_table::has(m_gpu_programs, id), "GPU program does not exist");
 		m_submit->set_program(id);
 	}
 
 	void set_vertex_buffer(VertexBufferId id, uint32_t num_vertices = 0xFFFFFFFF)
 	{
-		CE_ASSERT(m_vertex_buffers.has(id), "Vertex buffer does not exist");
+		CE_ASSERT(id_table::has(m_vertex_buffers, id), "Vertex buffer does not exist");
 		m_submit->set_vertex_buffer(id, num_vertices);
 	}
 
@@ -784,7 +784,7 @@ public:
 
 	void set_index_buffer(IndexBufferId id, uint32_t start_index = 0, uint32_t num_indices = 0xFFFFFFFF)
 	{
-		CE_ASSERT(m_index_buffers.has(id), "Index buffer does not exist");
+		CE_ASSERT(id_table::has(m_index_buffers, id), "Index buffer does not exist");
 		m_submit->set_index_buffer(id, start_index, num_indices);
 	}
 
@@ -795,28 +795,28 @@ public:
 
 	void set_uniform(UniformId id, UniformType::Enum type, const void* value, uint8_t num)
 	{
-		CE_ASSERT(m_uniforms.has(id), "Uniform does not exist");
+		CE_ASSERT(id_table::has(m_uniforms, id), "Uniform does not exist");
 		CE_ASSERT_NOT_NULL(value);
 		m_submit->set_uniform(id, type, value, num);
 	}
 
 	void set_texture(uint8_t unit, UniformId sampler_uniform, TextureId texture, uint32_t flags)
 	{
-		CE_ASSERT(m_uniforms.has(sampler_uniform), "Uniform does not exist");
-		CE_ASSERT(m_textures.has(texture), "Texture does not exist");
+		CE_ASSERT(id_table::has(m_uniforms, sampler_uniform), "Uniform does not exist");
+		CE_ASSERT(id_table::has(m_textures, texture), "Texture does not exist");
 		m_submit->set_texture(unit, sampler_uniform, texture, flags);
 	}
 
 	void set_texture(uint8_t unit, UniformId sampler_uniform, RenderTargetId texture, uint8_t attachment, uint32_t texture_flags)
 	{
-		CE_ASSERT(m_uniforms.has(sampler_uniform), "Uniform does not exist");
-		CE_ASSERT(m_render_targets.has(texture), "Render target does not exist");
+		CE_ASSERT(id_table::has(m_uniforms, sampler_uniform), "Uniform does not exist");
+		CE_ASSERT(id_table::has(m_render_targets, texture), "Render target does not exist");
 		m_submit->set_texture(unit, sampler_uniform, texture, attachment, texture_flags);
 	}
 
 	void set_layer_render_target(uint8_t layer, RenderTargetId id)
 	{
-		CE_ASSERT(m_render_targets.has(id), "Render target does not exist");
+		CE_ASSERT(id_table::has(m_render_targets, id), "Render target does not exist");
 		m_submit->set_layer_render_target(layer, id);
 	}
 

engine/renderers/backend/gl/GLRenderer.cpp

@@ -1102,12 +1102,12 @@ Renderer::Renderer(Allocator& a)
 //-----------------------------------------------------------------------------
 Renderer::~Renderer()
 {
-	CE_ASSERT(m_vertex_buffers.size() == 0, "%d vertex buffers not freed", m_vertex_buffers.size());
-	CE_ASSERT(m_index_buffers.size() == 0, "%d index buffers not freed", m_index_buffers.size());
-	CE_ASSERT(m_textures.size() == 0, "%d textures not freed", m_textures.size());
-	CE_ASSERT(m_shaders.size() == 0, "%d shaders not freed", m_shaders.size());
-	CE_ASSERT(m_gpu_programs.size() == 0, "%d GPU programs not freed", m_gpu_programs.size());
-	CE_ASSERT(m_render_targets.size() == 0, "%d render targets not freed", m_render_targets.size());
+	CE_ASSERT(id_table::size(m_vertex_buffers) == 0, "%d vertex buffers not freed", id_table::size(m_vertex_buffers));
+	CE_ASSERT(id_table::size(m_index_buffers) == 0, "%d index buffers not freed", id_table::size(m_index_buffers));
+	CE_ASSERT(id_table::size(m_textures) == 0, "%d textures not freed", id_table::size(m_textures));
+	CE_ASSERT(id_table::size(m_shaders) == 0, "%d shaders not freed", id_table::size(m_shaders));
+	CE_ASSERT(id_table::size(m_gpu_programs) == 0, "%d GPU programs not freed", id_table::size(m_gpu_programs));
+	CE_ASSERT(id_table::size(m_render_targets) == 0, "%d render targets not freed", id_table::size(m_render_targets));
 
 	CE_DELETE(m_allocator, m_impl);
 }
@@ -1154,7 +1154,7 @@ void Renderer::update_vertex_buffer_impl(VertexBufferId id, size_t offset, size_
 void Renderer::destroy_vertex_buffer_impl(VertexBufferId id)
 {
 	m_impl->m_vertex_buffers[id.index].destroy();
-	m_vertex_buffers.destroy(id);
+	id_table::destroy(m_vertex_buffers, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -1179,7 +1179,7 @@ void Renderer::update_index_buffer_impl(IndexBufferId id, size_t offset, size_t
 void Renderer::destroy_index_buffer_impl(IndexBufferId id)
 {
 	m_impl->m_index_buffers[id.index].destroy();
-	m_index_buffers.destroy(id);
+	id_table::destroy(m_index_buffers, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -1198,7 +1198,7 @@ void Renderer::update_texture_impl(TextureId id, uint32_t x, uint32_t y, uint32_
 void Renderer::destroy_texture_impl(TextureId id)
 {
 	m_impl->m_textures[id.index].destroy();
-	m_textures.destroy(id);
+	id_table::destroy(m_textures, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -1211,7 +1211,7 @@ void Renderer::create_shader_impl(ShaderId id, ShaderType::Enum type, const char
 void Renderer::destroy_shader_impl(ShaderId id)
 {
 	m_impl->m_shaders[id.index].destroy();
-	m_shaders.destroy(id);
+	id_table::destroy(m_shaders, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -1226,7 +1226,7 @@ void Renderer::create_gpu_program_impl(GPUProgramId id, ShaderId vertex, ShaderI
 void Renderer::destroy_gpu_program_impl(GPUProgramId id)
 {
 	m_impl->m_gpu_programs[id.index].destroy();
-	m_gpu_programs.destroy(id);
+	id_table::destroy(m_gpu_programs, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -1248,7 +1248,7 @@ void Renderer::update_uniform_impl(UniformId id, size_t size, const void* data)
 void Renderer::destroy_uniform_impl(UniformId id)
 {
 	default_allocator().deallocate(m_impl->m_uniforms[id.index]);
-	m_uniforms.destroy(id);
+	id_table::destroy(m_uniforms, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -1261,7 +1261,7 @@ void Renderer::create_render_target_impl(RenderTargetId id, uint16_t width, uint
 void Renderer::destroy_render_target_impl(RenderTargetId id)
 {
 	m_impl->m_render_targets[id.index].destroy();
-	m_render_targets.destroy(id);
+	id_table::destroy(m_render_targets, id);
 }
 
 } // namespace crown

engine/world/World.cpp

@@ -53,7 +53,7 @@ World::World()
 World::~World()
 {
 	// Destroy all units
-	for (uint32_t i = 0; i < m_units.size(); i++)
+	for (uint32_t i = 0; i < id_array::size(m_units); i++)
 	{
 		CE_DELETE(m_unit_pool, m_units[i]);
 	}
@@ -91,7 +91,7 @@ UnitId World::spawn_unit(ResourceId id, const Vector3& pos, const Quaternion& ro
 UnitId World::spawn_unit(const ResourceId id, UnitResource* ur, const Vector3& pos, const Quaternion& rot)
 {
 	Unit* u = (Unit*) m_unit_pool.allocate(sizeof(Unit), CE_ALIGNOF(Unit));
-	const UnitId unit_id = m_units.create(u);
+	const UnitId unit_id = id_array::create(m_units, u);
 	new (u) Unit(*this, unit_id, id, ur, Matrix4x4(rot, pos));
 
 	// SpawnUnitEvent ev;
@@ -104,10 +104,8 @@ UnitId World::spawn_unit(const ResourceId id, UnitResource* ur, const Vector3& p
 //-----------------------------------------------------------------------------
 void World::destroy_unit(UnitId id)
 {
-	CE_ASSERT(m_units.has(id), "Unit does not exist");
-
-	CE_DELETE(m_unit_pool, m_units.lookup(id));
-	m_units.destroy(id);
+	CE_DELETE(m_unit_pool, id_array::get(m_units, id));
+	id_array::destroy(m_units, id);
 
 	// DestroyUnitEvent ev;
 	// ev.unit = id;
@@ -117,7 +115,7 @@ void World::destroy_unit(UnitId id)
 //-----------------------------------------------------------------------------
 void World::reload_units(UnitResource* old_ur, UnitResource* new_ur)
 {
-	for (uint32_t i = 0; i < m_units.size(); i++)
+	for (uint32_t i = 0; i < id_array::size(m_units); i++)
 	{
 		if (m_units[i]->resource() == old_ur)
 		{
@@ -129,13 +127,13 @@ void World::reload_units(UnitResource* old_ur, UnitResource* new_ur)
 //-----------------------------------------------------------------------------
 uint32_t World::num_units() const
 {
-	return m_units.size();
+	return id_array::size(m_units);
 }
 
 //-----------------------------------------------------------------------------
 void World::units(Array<UnitId>& units) const
 {
-	for (uint32_t i = 0; i < m_units.size(); i++)
+	for (uint32_t i = 0; i < id_array::size(m_units); i++)
 	{
 		array::push_back(units, m_units[i]->id());
 	}
@@ -144,33 +142,25 @@ void World::units(Array<UnitId>& units) const
 //-----------------------------------------------------------------------------
 void World::link_unit(UnitId child, UnitId parent, int32_t node)
 {
-	CE_ASSERT(m_units.has(child), "Child unit does not exist");
-	CE_ASSERT(m_units.has(parent), "Parent unit does not exist");
-
 	Unit* parent_unit = lookup_unit(parent);
 	parent_unit->link_node(0, node);
 }
 
 //-----------------------------------------------------------------------------
-void World::unlink_unit(UnitId child)
+void World::unlink_unit(UnitId /*child*/)
 {
-	CE_ASSERT(m_units.has(child), "Child unit does not exist");
 }
 
 //-----------------------------------------------------------------------------
-Unit* World::lookup_unit(UnitId unit)
+Unit* World::lookup_unit(UnitId id)
 {
-	CE_ASSERT(m_units.has(unit), "Unit does not exist");
-
-	return m_units.lookup(unit);
+	return id_array::get(m_units, id);
 }
 
 //-----------------------------------------------------------------------------
-Camera* World::lookup_camera(CameraId camera)
+Camera* World::lookup_camera(CameraId id)
 {
-	CE_ASSERT(m_cameras.has(camera), "Camera does not exist");
-
-	return m_cameras.lookup(camera);
+	return id_array::get(m_cameras, id);
 }
 
 //-----------------------------------------------------------------------------
@@ -197,22 +187,16 @@ void World::render(Camera* camera)
 //-----------------------------------------------------------------------------
 CameraId World::create_camera(SceneGraph& sg, int32_t node, ProjectionType::Enum type, float near, float far)
 {
-	// Allocate memory for camera
 	Camera* camera = CE_NEW(m_camera_pool, Camera)(sg, node, type, near, far);
 
-	// Create Id for the camera
-	const CameraId camera_id = m_cameras.create(camera);
-
-	return camera_id;
+	return id_array::create(m_cameras, camera);
 }
 
 //-----------------------------------------------------------------------------
 void World::destroy_camera(CameraId id)
 {
-	CE_ASSERT(m_cameras.has(id), "Camera does not exist");
-
-	CE_DELETE(m_camera_pool, m_cameras.lookup(id));
-	m_cameras.destroy(id);
+	CE_DELETE(m_camera_pool, id_array::get(m_cameras, id));
+	id_array::destroy(m_cameras, id);
 }
 
 //-----------------------------------------------------------------------------

engine/world/World.h

@@ -87,11 +87,11 @@ public:
 	/// After this call, @a child will follow the @a parent unit.
 	void link_unit(UnitId child, UnitId parent, int32_t node);
 
-	/// Unlinks the unit @a unit from its parent if it has any.
-	void unlink_unit(UnitId unit);
+	/// Unlinks the unit @a id from its parent if it has any.
+	void unlink_unit(UnitId id);
 
-	Unit* lookup_unit(UnitId unit);
-	Camera* lookup_camera(CameraId camera);
+	Unit* lookup_unit(UnitId id);
+	Camera* lookup_camera(CameraId id);
 
 	/// Updates all units and sub-systems with the given @a dt delta time.
 	void update(float dt);

engine/world/WorldManager.cpp

@@ -45,7 +45,7 @@ WorldManager::~WorldManager()
 WorldId WorldManager::create_world()
 {
 	World* w = CE_NEW(m_allocator, World)();
-	const WorldId w_id = m_worlds.create(w);
+	const WorldId w_id = id_array::create(m_worlds, w);
 	w->set_id(w_id);
 	return w_id;
 }
@@ -53,14 +53,14 @@ WorldId WorldManager::create_world()
 //-----------------------------------------------------------------------------
 void WorldManager::destroy_world(WorldId id)
 {
-	CE_DELETE(m_allocator, m_worlds.lookup(id));
-	m_worlds.destroy(id);
+	CE_DELETE(m_allocator, id_array::get(m_worlds, id));
+	id_array::destroy(m_worlds, id);
 }
 
 //-----------------------------------------------------------------------------
 World* WorldManager::lookup_world(WorldId id)
 {
-	return m_worlds.lookup(id);
+	return id_array::get(m_worlds, id);
 }
 
 //-----------------------------------------------------------------------------