Merge branch 'world' of https://github.com/taylor001/crown into world

Conflicts:
	engine/resource/UnitResource.h

engine/Mesh.cpp

@@ -41,8 +41,8 @@ Mesh::Mesh(SceneGraph& sg, int32_t node, const MeshResource* mr)
 	, m_node(node)
 	, m_resource(mr)
 {
-	m_vbuffer = mr->m_vbuffer;
-	m_ibuffer = mr->m_ibuffer;
+	m_vbuffer = mr->vertex_buffer();
+	m_ibuffer = mr->index_buffer();
 }
 
 //-----------------------------------------------------------------------------

engine/Sprite.cpp

@@ -42,12 +42,18 @@ Sprite::Sprite(SceneGraph& sg, int32_t node, const SpriteResource* sr)
 	, m_node(node)
 	, m_resource(sr)
 {
-	m_vb = sr->m_vb;
-	m_ib = sr->m_ib;
-	m_texture = ((TextureResource*)device()->resource_manager()->data(sr->texture()))->m_texture;
+	m_vb = sr->vertex_buffer();
+	m_ib = sr->index_buffer();
+	m_texture = ((TextureResource*)device()->resource_manager()->data(sr->texture()))->texture();
 	m_animator = CE_NEW(default_allocator(), SpriteAnimator)(sr);
 }
 
+//-----------------------------------------------------------------------------
+Sprite::~Sprite()
+{
+	CE_DELETE(default_allocator(), m_animator);
+}
+
 //-----------------------------------------------------------------------------
 Vector3 Sprite::local_position() const
 {

engine/Sprite.h

@@ -43,6 +43,7 @@ struct Unit;
 struct Sprite
 {
 							Sprite(SceneGraph& sg, int32_t node, const SpriteResource* sr);
+							~Sprite();
 
 	Vector3					local_position() const;
 	Quaternion				local_rotation() const;

engine/SpriteAnimator.h

@@ -55,7 +55,7 @@ public:
 public:
 	//-----------------------------------------------------------------------------	
 	SpriteAnimator(const SpriteResource* sr)
-		: m_vb(sr->m_vb)
+		: m_vb(sr->vertex_buffer())
 		, m_num_frames(sr->num_frames())
 		, m_frame_rate(sr->frame_rate())
 		, m_playback_mode((Enum)sr->playback_mode())

engine/World.cpp

@@ -201,7 +201,7 @@ SoundId World::play_sound(const char* name, const bool loop, const float volume,
 	const SoundSourceId source = sr->create_sound_source();
 
 	Sound s;
-	s.buffer = sound->m_id;
+	s.buffer = sound->sound_buffer();
 	s.source = source;
 	s.world = Matrix4x4(Quaternion::IDENTITY, pos);
 	s.volume = volume;

engine/lua/LuaEnvironment.cpp

@@ -181,7 +181,7 @@ static int crown_lua_require(lua_State* L)
 	device()->resource_manager()->flush();
 
 	const LuaResource* lr = (LuaResource*) device()->resource_manager()->data(lua_res);
-	luaL_loadbuffer(L, (const char*) lr->code(), lr->size(), "");
+	luaL_loadbuffer(L, (const char*) lr->program(), lr->size(), "");
 
 	device()->resource_manager()->unload(lua_res);
 
@@ -314,7 +314,7 @@ bool LuaEnvironment::load_and_execute(const char* res_name)
 	
 	lua_getglobal(m_state, "debug");
 	lua_getfield(m_state, -1, "traceback");
-	if (luaL_loadbuffer(m_state, (const char*) lr->code(), lr->size(), res_name) == 0)
+	if (luaL_loadbuffer(m_state, (const char*) lr->program(), lr->size(), res_name) == 0)
 	{
 		if (lua_pcall(m_state, 0, 0, -2) == 0)
 		{

engine/resource/FontResource.h

@@ -42,35 +42,32 @@ public:
 	static void* load(Allocator& /*allocator*/, Bundle& /*bundle*/, ResourceId /*id*/)
 	{
 		return NULL;
+		// TODO
 	}
 
 	//-----------------------------------------------------------------------------
 	static void online(void* resource)
 	{
 		(void)resource;
+		// TODO
 	}
 
 	//-----------------------------------------------------------------------------
 	static void unload(Allocator& /*allocator*/, void* /*resource*/)
 	{
+		// TODO
 	}
 
 	//-----------------------------------------------------------------------------
 	static void offline(void* /*resource*/)
 	{
+		// TODO
 	}
 
-public:
-
-	inline uint32_t			mat_text_heigth() { return m_max_text_height; }
-	inline uint32_t			max_character_height() { return m_max_character_height; }
-	inline uint32_t			max_character_width() { return m_max_character_width; }
-
 private:
 
-	uint32_t				m_max_text_height;
-	uint32_t				m_max_character_height;
-	uint32_t				m_max_character_width;
+	// Disable construction
+	FontResource();
 };
 
 } // namespace crown

engine/resource/LuaResource.h

@@ -44,19 +44,16 @@ struct LuaHeader
 	uint32_t	size;		// Size of lua code
 };
 
-class LuaResource
+struct LuaResource
 {
-public:
-
 	//-----------------------------------------------------------------------------
 	static void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
 	{
 		File* file = bundle.open(id);
-
 		const size_t file_size = file->size() - 12;
-		LuaResource* res = (LuaResource*) allocator.allocate(sizeof(LuaResource));
-		res->m_data = (uint8_t*) allocator.allocate(file_size);
-		file->read(res->m_data, file_size);
+
+		void* res = allocator.allocate(file_size);
+		file->read(res, file_size);
 
 		bundle.close(file);
 
@@ -64,35 +61,38 @@ public:
 	}
 
 	//-----------------------------------------------------------------------------
-	static void online(void* /*resource*/) {}
+	static void online(void* /*resource*/)
+	{
+	}
 
 	//-----------------------------------------------------------------------------
 	static void unload(Allocator& allocator, void* resource)
 	{
 		CE_ASSERT_NOT_NULL(resource);
-
-		allocator.deallocate(((LuaResource*)resource)->m_data);
 		allocator.deallocate(resource);
 	}
 
 	//-----------------------------------------------------------------------------
-	static void offline(void* /*resource*/) {}
-
-public:
+	static void offline(void* /*resource*/)
+	{
+	}
 
+	/// Returns the size in bytes of the lua program.
 	uint32_t size() const
 	{
-		return ((LuaHeader*) m_data)->size;
+		return ((LuaHeader*) this)->size;
 	}
 
-	const uint8_t* code() const
+	/// Returns the lua program.
+	const char* program() const
 	{
-		return m_data + sizeof(LuaHeader);
+		return ((char*) this) + sizeof(LuaHeader);
 	}
 
 private:
 
-	uint8_t* m_data;
+	// Disable construction
+	LuaResource();
 };
 
 } // namespace crown

engine/resource/MaterialResource.h

@@ -68,6 +68,11 @@ public:
 	{
 		// TODO
 	}
+
+private:
+
+	// Disable construction
+	MaterialResource();
 };
 
 } // namespace crown

engine/resource/MeshResource.h

@@ -43,6 +43,8 @@ const uint32_t MESH_VERSION = 1;
 
 struct MeshHeader
 {
+	VertexBufferId		vbuffer;
+	IndexBufferId		ibuffer;
 	uint32_t			version;
 	uint32_t			num_meshes;
 	uint32_t			num_joints;
@@ -76,11 +78,10 @@ public:
 	static void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
 	{
 		File* file = bundle.open(id);
-
 		const size_t file_size = file->size() - 12;
-		MeshResource* res = (MeshResource*) allocator.allocate(sizeof(MeshResource));
-		res->m_data = (uint8_t*) allocator.allocate(file_size);
-		file->read(res->m_data, file_size);
+
+		void* res = allocator.allocate(file_size);
+		file->read(res, file_size);
 
 		bundle.close(file);
 
@@ -91,69 +92,82 @@ public:
 	static void online(void* resource)
 	{
 		MeshResource* m = (MeshResource*) resource;
+		MeshHeader* h = (MeshHeader*) m;
 
-		m->m_vbuffer = device()->renderer()->create_vertex_buffer(m->num_vertices(), m->vertex_format(), m->vertices());
-		m->m_ibuffer = device()->renderer()->create_index_buffer(m->num_indices(), m->indices());
+		h->vbuffer = device()->renderer()->create_vertex_buffer(m->num_vertices(), m->vertex_format(), m->vertices());
+		h->ibuffer = device()->renderer()->create_index_buffer(m->num_indices(), m->indices());
 	}
 
 	//-----------------------------------------------------------------------------
 	static void unload(Allocator& a, void* res)
 	{
-		MeshResource* resource = (MeshResource*)res;
-		a.deallocate(resource->m_data);
-		a.deallocate(resource);
+		CE_ASSERT_NOT_NULL(res);
+		a.deallocate(res);
 	}
 
 	//-----------------------------------------------------------------------------
 	static void offline(void* resource)
 	{
 		MeshResource* m = (MeshResource*) resource;
+		MeshHeader* h = (MeshHeader*) m;
 
-		device()->renderer()->destroy_index_buffer(m->m_ibuffer);
-		device()->renderer()->destroy_vertex_buffer(m->m_vbuffer);
+		device()->renderer()->destroy_index_buffer(h->ibuffer);
+		device()->renderer()->destroy_vertex_buffer(h->vbuffer);
 	}
 
 	//-----------------------------------------------------------------------------
-	uint32_t num_vertices()
+	uint32_t num_vertices() const
 	{
-		MeshData* data = (MeshData*) (m_data + sizeof(MeshHeader));
+		MeshData* data = (MeshData*) ((char*) this) + sizeof(MeshHeader);
 		return data->vertices.num_vertices;
 	}
 
 	//-----------------------------------------------------------------------------
-	VertexFormat::Enum vertex_format()
+	VertexFormat::Enum vertex_format() const
 	{
-		MeshData* data = (MeshData*) (m_data + sizeof(MeshHeader));
+		MeshData* data = (MeshData*) ((char*) this) + sizeof(MeshHeader);
 		return data->vertices.format;
 	}
 
 	//-----------------------------------------------------------------------------
-	float* vertices()
+	float* vertices() const
 	{
-		MeshData* data = (MeshData*) (m_data + sizeof(MeshHeader));
-		return (float*) (m_data + data->vertices.offset);
+		MeshData* data = (MeshData*) ((char*) this) + sizeof(MeshHeader);
+		return (float*) (((char*)this) + data->vertices.offset);
 	}
 
 	//-----------------------------------------------------------------------------
-	uint32_t num_indices()
+	uint32_t num_indices() const
 	{
-		MeshData* data = (MeshData*) (m_data + sizeof(MeshHeader));
+		MeshData* data = (MeshData*) ((char*) this) + sizeof(MeshHeader);
 		return data->indices.num_indices;
 	}
 
 	//-----------------------------------------------------------------------------
-	uint16_t* indices()
+	uint16_t* indices() const
 	{
-		MeshData* data = (MeshData*) (m_data + sizeof(MeshHeader));
-		return (uint16_t*) (m_data + data->indices.offset);
+		MeshData* data = (MeshData*) ((char*) this) + sizeof(MeshHeader);
+		return (uint16_t*) (((char*)this) + data->indices.offset);
 	}
 
-public:
+	//-----------------------------------------------------------------------------
+	VertexBufferId vertex_buffer() const
+	{
+		MeshHeader* h = (MeshHeader*) this;
+		return h->vbuffer;
+	}
+
+	//-----------------------------------------------------------------------------
+	IndexBufferId index_buffer() const
+	{
+		MeshHeader* h = (MeshHeader*) this;
+		return h->ibuffer;
+	}
 
-	uint8_t* m_data;
+private:
 
-	VertexBufferId m_vbuffer;
-	IndexBufferId m_ibuffer;
+	// Disable construction
+	MeshResource();
 };
 
 } // namespace crown

engine/resource/PackageResource.h

@@ -52,19 +52,16 @@ struct PackageHeader
 	uint32_t sprites_offset;
 };
 
-class PackageResource
+struct PackageResource
 {
-public:
-
 	//-----------------------------------------------------------------------------
 	static void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
 	{
 		File* file = bundle.open(id);
-
 		const size_t file_size = file->size() - 12;
-		PackageResource* res = (PackageResource*) allocator.allocate(sizeof(PackageResource));
-		res->m_data = (char*) allocator.allocate(file_size);
-		file->read(res->m_data, file_size);
+
+		void* res = allocator.allocate(file_size);
+		file->read(res, file_size);
 
 		bundle.close(file);
 
@@ -80,8 +77,6 @@ public:
 	static void unload(Allocator& allocator, void* resource)
 	{
 		CE_ASSERT_NOT_NULL(resource);
-
-		allocator.deallocate(((PackageResource*)resource)->m_data);
 		allocator.deallocate(resource);
 	}
 
@@ -90,54 +85,40 @@ public:
 	{
 	}
 
-public:
-
 	//-----------------------------------------------------------------------------
 	uint32_t num_textures() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((PackageHeader*)m_data)->num_textures;
+		return ((PackageHeader*) this)->num_textures;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_scripts() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((PackageHeader*)m_data)->num_scripts;
+		return ((PackageHeader*) this)->num_scripts;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_sounds() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((PackageHeader*)m_data)->num_sounds;
+		return ((PackageHeader*) this)->num_sounds;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_meshes() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((PackageHeader*)m_data)->num_meshes;
+		return ((PackageHeader*) this)->num_meshes;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_units() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((PackageHeader*)m_data)->num_units;
+		return ((PackageHeader*) this)->num_units;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_sprites() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((PackageHeader*)m_data)->num_sprites;
+		return ((PackageHeader*) this)->num_sprites;
 	}
 
 	//-----------------------------------------------------------------------------
@@ -145,7 +126,7 @@ public:
 	{
 		CE_ASSERT(i < num_textures(), "Index out of bounds");
 
-		ResourceId* begin = (ResourceId*) (m_data + ((PackageHeader*)m_data)->textures_offset);
+		ResourceId* begin = (ResourceId*) ((char*) this + ((PackageHeader*) this)->textures_offset);
 		return begin[i];
 	}
 
@@ -154,7 +135,7 @@ public:
 	{
 		CE_ASSERT(i < num_scripts(), "Index out of bounds");
 
-		ResourceId* begin = (ResourceId*) (m_data + ((PackageHeader*)m_data)->scripts_offset);
+		ResourceId* begin = (ResourceId*) ((char*) this + ((PackageHeader*) this)->scripts_offset);
 		return begin[i];
 	}
 
@@ -163,7 +144,7 @@ public:
 	{
 		CE_ASSERT(i < num_sounds(), "Index out of bounds");
 
-		ResourceId* begin = (ResourceId*) (m_data + ((PackageHeader*)m_data)->sounds_offset);
+		ResourceId* begin = (ResourceId*) ((char*) this + ((PackageHeader*) this)->sounds_offset);
 		return begin[i];
 	}
 
@@ -172,7 +153,7 @@ public:
 	{
 		CE_ASSERT(i < num_meshes(), "Index out of bounds");
 
-		ResourceId* begin = (ResourceId*) (m_data + ((PackageHeader*)m_data)->meshes_offset);
+		ResourceId* begin = (ResourceId*) ((char*) this + ((PackageHeader*) this)->meshes_offset);
 		return begin[i];
 	}
 
@@ -181,7 +162,7 @@ public:
 	{
 		CE_ASSERT(i < num_units(), "Index out of bounds");
 
-		ResourceId* begin = (ResourceId*) (m_data + ((PackageHeader*)m_data)->units_offset);
+		ResourceId* begin = (ResourceId*) ((char*) this + ((PackageHeader*) this)->units_offset);
 		return begin[i];
 	}
 
@@ -190,13 +171,14 @@ public:
 	{
 		CE_ASSERT(i < num_sprites(), "Index out of bounds");
 
-		ResourceId* begin = (ResourceId*) (m_data + ((PackageHeader*)m_data)->sprites_offset);
+		ResourceId* begin = (ResourceId*) ((char*) this + ((PackageHeader*) this)->sprites_offset);
 		return begin[i];
 	}
 
 private:
 
-	char* m_data;
+	// Disable construction
+	PackageResource();
 };
 
 } // namespace crown

engine/resource/SoundResource.h

@@ -52,18 +52,18 @@ const uint32_t SOUND_VERSION = 1;
 //-----------------------------------------------------------------------------
 struct SoundHeader
 {
-	uint32_t	version;	// Sound file version
-	uint32_t	size;
-	uint32_t	sample_rate;
-	uint32_t	avg_bytes_ps;
-	uint32_t	channels;
-	uint16_t	block_size;
-	uint16_t 	bits_ps;
-	uint8_t		sound_type;
+	SoundBufferId	sb;
+	uint32_t		version;	// Sound file version
+	uint32_t		size;
+	uint32_t		sample_rate;
+	uint32_t		avg_bytes_ps;
+	uint32_t		channels;
+	uint16_t		block_size;
+	uint16_t 		bits_ps;
+	uint8_t			sound_type;
 };
 
-
-class SoundResource
+struct SoundResource
 {
 public:
 
@@ -71,70 +71,94 @@ public:
 	static void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
 	{
 		File* file = bundle.open(id);
+		const size_t file_size = file->size() - 12;
 
-		SoundResource* resource = (SoundResource*)allocator.allocate(sizeof(SoundResource));
-
-		file->read(&resource->m_header, sizeof(SoundHeader));
-
-		size_t size = resource->size();
-
-		resource->m_data = (uint8_t*)allocator.allocate(sizeof(uint8_t) * size);
-
-		file->read(resource->m_data, size);
+		void* res = allocator.allocate(file_size);
+		file->read(res, file_size);
 
 		bundle.close(file);
 
-		return resource;
+		return res;
 	}
 
 	//-----------------------------------------------------------------------------
 	static void online(void* resource)
 	{
-		CE_ASSERT(resource != NULL, "Resource not loaded");
+		CE_ASSERT_NOT_NULL(resource);
 
-		SoundResource* s = (SoundResource*)resource;
+		SoundResource* sr = (SoundResource*)resource;
+		SoundHeader* h = (SoundHeader*) sr;
 
-		SoundBufferId id = device()->sound_renderer()->create_sound_buffer((void*)s->data(), s->size(), s->sample_rate(), s->channels(), s->bits_ps());
-
-		s->m_id = id;
+		h->sb = device()->sound_renderer()->create_sound_buffer((void*)sr->data(), sr->size(), sr->sample_rate(), sr->channels(), sr->bits_ps());
 	}
 
 	//-----------------------------------------------------------------------------
 	static void unload(Allocator& allocator, void* resource)
 	{
-		CE_ASSERT(resource != NULL, "Resource not loaded");
-
-		allocator.deallocate(((SoundResource*)resource)->m_data);
+		CE_ASSERT_NOT_NULL(resource);
 		allocator.deallocate(resource);
 	}
 
 	//-----------------------------------------------------------------------------
 	static void offline(void* resource)
 	{
-		CE_ASSERT(resource != NULL, "Resource not loaded");
+		CE_ASSERT_NOT_NULL(resource);
 
-		SoundResource* s = (SoundResource*)resource;
-
-		device()->sound_renderer()->destroy_sound_buffer(s->m_id);
+		SoundHeader* s = (SoundHeader*) resource;
+		device()->sound_renderer()->destroy_sound_buffer(s->sb);
 	}
 
 public:
 
-	uint32_t 			size() const { return m_header.size; }
-	uint32_t			sample_rate() const { return m_header.sample_rate; }
-	uint32_t			avg_bytes_ps() const { return m_header.avg_bytes_ps; }
-	uint32_t			channels() const { return m_header.channels; }
-	uint16_t			block_size() const { return m_header.block_size; }
-	uint16_t			bits_ps() const { return m_header.bits_ps; }
-	uint8_t				sound_type() const { return m_header.sound_type; }
+	uint32_t size() const 
+	{
+		return ((SoundHeader*) this)->size;
+	}
 
-	const uint8_t*		data() const { return m_data; }
+	uint32_t sample_rate() const
+	{
+		return ((SoundHeader*) this)->sample_rate;
+	}
 
-public:
+	uint32_t avg_bytes_ps() const
+	{
+		return ((SoundHeader*) this)->avg_bytes_ps;
+	}
+
+	uint32_t channels() const
+	{
+		return ((SoundHeader*) this)->channels;
+	}
+
+	uint16_t block_size() const
+	{
+		return ((SoundHeader*) this)->block_size;
+	}
+
+	uint16_t bits_ps() const
+	{
+		return ((SoundHeader*) this)->bits_ps;
+	}
+
+	uint8_t sound_type() const
+	{
+		return ((SoundHeader*) this)->sound_type;
+	}
+
+	const char* data() const
+	{
+		return ((char*) this) + sizeof(SoundHeader);
+	}
+
+	SoundBufferId sound_buffer() const
+	{
+		return ((SoundHeader*) this)->sb;
+	}
+
+private:
 
-	SoundHeader		m_header;
-	uint8_t*		m_data;
-	SoundBufferId	m_id;
+	// Disable construction
+	SoundResource();
 };
 
 } // namespace crown

engine/resource/SpriteResource.h

@@ -53,29 +53,26 @@ const uint32_t SPRITE_VERSION = 1;
 //-----------------------------------------------------------------------------
 struct SpriteHeader
 {
-	char 		name[128];
-	ResourceId 	texture;
-	uint32_t 	num_frames;
-	uint32_t 	frame_rate;
-	uint32_t 	playback_mode;
+	VertexBufferId 	vb;
+	IndexBufferId 	ib;
+	char 			name[128];
+	ResourceId 		texture;
+	uint32_t 		num_frames;
+	uint32_t 		frame_rate;
+	uint32_t 		playback_mode;
 };
 
 //-----------------------------------------------------------------------------
-class SpriteResource
+struct SpriteResource
 {
-public:
-
 	//-----------------------------------------------------------------------------
 	static void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
 	{
 		File* file = bundle.open(id);
-
 		const size_t file_size = file->size() - 12;
 
-		SpriteResource* res = (SpriteResource*) allocator.allocate(sizeof(SpriteResource));
-		res->m_data = (uint8_t*) allocator.allocate(file_size);
-		res->m_data_size = file_size;
-		file->read(res->m_data, res->m_data_size);
+		void* res = allocator.allocate(file_size);
+		file->read(res, file_size);
 
 		bundle.close(file);
 
@@ -86,85 +83,91 @@ public:
 	static void online(void* resource)
 	{
 		SpriteResource* sr = (SpriteResource*)resource;
+		SpriteHeader* h = (SpriteHeader*) sr;
 
 		static uint16_t t_indices[] = {0, 1, 2, 0, 2, 3};
 
-		sr->m_vb = device()->renderer()->create_vertex_buffer(4, VertexFormat::P2_T2, sr->frame(0));
-		sr->m_ib = device()->renderer()->create_index_buffer(6, t_indices);
+		h->vb = device()->renderer()->create_vertex_buffer(4, VertexFormat::P2_T2, sr->frame(0));
+		h->ib = device()->renderer()->create_index_buffer(6, t_indices);
 	}
 
 	//-----------------------------------------------------------------------------
 	static void unload(Allocator& allocator, void* resource)
 	{
-		SpriteResource* res = (SpriteResource*)resource;
-		allocator.deallocate(res->m_data);
-		allocator.deallocate(res);
+		CE_ASSERT_NOT_NULL(resource);
+		allocator.deallocate(resource);
 	}
 
 	//-----------------------------------------------------------------------------
 	static void offline(void* resource)
 	{
-		SpriteResource* sprite = (SpriteResource*) resource;
+		CE_ASSERT_NOT_NULL(resource);
 
-		Renderer* r = device()->renderer();
+		SpriteResource* sr = (SpriteResource*) resource;
+		SpriteHeader* h = (SpriteHeader*) sr;
 
-		r->destroy_vertex_buffer(sprite->m_vb);
-		r->destroy_index_buffer(sprite->m_ib);
+		device()->renderer()->destroy_vertex_buffer(h->vb);
+		device()->renderer()->destroy_index_buffer(h->ib);
 	}
 
 	//-----------------------------------------------------------------------------
 	const char* name() const
 	{
-		SpriteHeader* header = (SpriteHeader*)m_data;
-		return header->name;
+		return ((SpriteHeader*) this)->name;
 	}
 
 	//-----------------------------------------------------------------------------
 	ResourceId texture() const
 	{
-		SpriteHeader* header = (SpriteHeader*)m_data;
-		return header->texture;
+		return ((SpriteHeader*) this)->texture;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_frames() const
 	{
-		SpriteHeader* header = (SpriteHeader*)m_data;
-		return header->num_frames;
+		return ((SpriteHeader*) this)->num_frames;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t frame_rate() const
 	{
-		SpriteHeader* header = (SpriteHeader*)m_data;
-		return header->frame_rate;
+		return ((SpriteHeader*) this)->frame_rate;
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t playback_mode() const
 	{
-		SpriteHeader* header = (SpriteHeader*)m_data;
-		return header->playback_mode;
+		return ((SpriteHeader*) this)->playback_mode;
+	}
+
+	//-----------------------------------------------------------------------------
+	const float* animation() const
+	{
+		return (float*) (((char*) this) + sizeof(SpriteHeader));
 	}
 
 	//-----------------------------------------------------------------------------
-	float* animation() const
+	const float* frame(uint32_t index) const
 	{
-		return (float*)(m_data + sizeof(SpriteHeader));
+		return (float*) (((char*) this) + sizeof(SpriteHeader) + SPRITE_FRAME_SIZE * index);
 	}
 
-	float* frame(uint32_t index)
+	//-----------------------------------------------------------------------------
+	VertexBufferId vertex_buffer() const
 	{
-		return (float*)(m_data + sizeof(SpriteHeader) + SPRITE_FRAME_SIZE * index);
+		return ((SpriteHeader*) this)->vb;
 	}
 
-public:
+	//-----------------------------------------------------------------------------
+	IndexBufferId index_buffer() const
+	{
+		return ((SpriteHeader*) this)->ib;
+	}
 
-	uint8_t*					m_data;
-	size_t						m_data_size;
+private:
 
-	VertexBufferId 				m_vb;
-	IndexBufferId 				m_ib;
+	// Disable construction
+	SpriteResource();
 };
 
 } // namespace crown

engine/resource/TextureResource.h

@@ -43,25 +43,23 @@ const uint32_t TEXTURE_VERSION = 1;
 
 struct TextureHeader
 {
+	TextureId	id;
 	uint32_t	version;	// Texture file version
 	uint32_t	format;		// Format of the pixels
 	uint32_t	width;		// Width in pixels
 	uint32_t	height;		// Height in pixels
 };
 
-class TextureResource
+struct TextureResource
 {
-public:
-
 	//-----------------------------------------------------------------------------
 	static void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
 	{
 		File* file = bundle.open(id);
 		const size_t file_size = file->size() - 12;
 
-		TextureResource* res = (TextureResource*) allocator.allocate(sizeof(TextureResource));
-		res->m_data = (char*) allocator.allocate(file_size);
-		file->read(res->m_data, file_size);
+		void* res = allocator.allocate(file_size);
+		file->read(res, file_size);
 
 		bundle.close(file);
 
@@ -72,8 +70,9 @@ public:
 	static void online(void* resource)
 	{
 		TextureResource* t = (TextureResource*) resource;
+		TextureHeader* h = (TextureHeader*) t;
 
-		t->m_texture = device()->renderer()->create_texture(t->width(), t->height(), t->format(), t->data());
+		h->id = device()->renderer()->create_texture(t->width(), t->height(), t->format(), t->data());
 	}
 
 	//-----------------------------------------------------------------------------
@@ -81,7 +80,6 @@ public:
 	{
 		CE_ASSERT(resource != NULL, "Resource not loaded");
 
-		allocator.deallocate(((TextureResource*)resource)->m_data);
 		allocator.deallocate(resource);
 	}
 
@@ -90,35 +88,38 @@ public:
 	{
 		TextureResource* t = (TextureResource*) resource;
 
-		device()->renderer()->destroy_texture(t->m_texture);
+		device()->renderer()->destroy_texture(t->texture());
 	}
 
-public:
-
 	PixelFormat::Enum format() const
 	{
-		return (PixelFormat::Enum) ((TextureHeader*)m_data)->format;
+		return (PixelFormat::Enum) ((TextureHeader*) this)->format;
 	}
 
 	uint32_t width() const
 	{
-		return ((TextureHeader*)m_data)->width;
+		return ((TextureHeader*) this)->width;
 	}
 
 	uint32_t height() const
 	{
-		return ((TextureHeader*)m_data)->height;
+		return ((TextureHeader*) this)->height;
 	}
 
 	const char* data() const
 	{
-		return m_data + sizeof(TextureHeader);
+		return (char*)this + sizeof(TextureHeader);
+	}
+
+	TextureId texture() const
+	{
+		return ((TextureHeader*) this)->id;
 	}
 
-public:
+private:
 
-	char*				m_data;
-	TextureId			m_texture;
+	// Disable construction
+	TextureResource();
 };
 
 } // namespace crown

engine/resource/UnitResource.h

@@ -67,19 +67,16 @@ struct UnitActor
 	bool active;
 };
 
-class UnitResource
+struct UnitResource
 {
-public:
-
 	//-----------------------------------------------------------------------------
 	static void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
 	{
 		File* file = bundle.open(id);
-
 		const size_t file_size = file->size() - 12;
-		UnitResource* res = (UnitResource*) allocator.allocate(sizeof(UnitResource));
-		res->m_data = (char*) allocator.allocate(file_size);
-		file->read(res->m_data, file_size);
+
+		void* res = allocator.allocate(file_size);
+		file->read(res, file_size);
 
 		bundle.close(file);
 
@@ -95,8 +92,6 @@ public:
 	static void unload(Allocator& allocator, void* resource)
 	{
 		CE_ASSERT_NOT_NULL(resource);
-
-		allocator.deallocate(((UnitResource*)resource)->m_data);
 		allocator.deallocate(resource);
 	}
 
@@ -105,48 +100,42 @@ public:
 	{
 	}
 
-public:
-
 	//-----------------------------------------------------------------------------
 	uint32_t num_renderables() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((UnitHeader*)m_data)->num_renderables;
+		return ((UnitHeader*) this)->num_renderables;
 	}
 
 	//-----------------------------------------------------------------------------
-	const UnitRenderable& get_renderable(uint32_t i) const
+	UnitRenderable get_renderable(uint32_t i) const
 	{
 		CE_ASSERT(i < num_renderables(), "Index out of bounds");
 
-		UnitRenderable* begin = (UnitRenderable*) (m_data + ((UnitHeader*)m_data)->renderables_offset);
+		UnitHeader* h = (UnitHeader*) this;
+		UnitRenderable* begin = (UnitRenderable*) (((char*) this) + h->renderables_offset);
 		return begin[i];
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_cameras() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((UnitHeader*)m_data)->num_cameras;
+		return ((UnitHeader*) this)->num_cameras;
 	}
 
 	//-----------------------------------------------------------------------------
-	const UnitCamera& get_camera(uint32_t i) const
+	UnitCamera get_camera(uint32_t i) const
 	{
 		CE_ASSERT(i < num_cameras(), "Index out of bounds");
 
-		UnitCamera* begin = (UnitCamera*) (m_data + ((UnitHeader*)m_data)->cameras_offset);
+		UnitHeader* h = (UnitHeader*) this;
+		UnitCamera* begin = (UnitCamera*) (((char*) this) + h->cameras_offset);
 		return begin[i];
 	}
 
 	//-----------------------------------------------------------------------------
 	uint32_t num_actors() const
 	{
-		CE_ASSERT_NOT_NULL(m_data);
-
-		return ((UnitHeader*)m_data)->num_actors;
+		return ((UnitHeader*) this)->num_actors;
 	}
 
 	//-----------------------------------------------------------------------------
@@ -154,13 +143,15 @@ public:
 	{
 		CE_ASSERT(i < num_actors(), "Index out of bounds");
 
-		UnitActor* begin = (UnitActor*)(m_data + ((UnitHeader*)m_data)->actors_offset);
+		UnitHeader* h = (UnitHeader*) this;
+		UnitActor* begin = (UnitActor*) (((char*) this) + h->actors_offset);
 		return begin[i];
 	}
 
 private:
 
-	char* m_data;
+	// Disable construction
+	UnitResource();
 };
 
 } // namespace crown