Comment out some code in order to build successfully

engine/renderers/DebugLine.cpp

@@ -28,8 +28,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "MathUtils.h"
 #include "Color4.h"
 #include "Vector3.h"
-#include "Device.h"
-#include "Renderer.h"
 #include "RenderWorld.h"
 
 namespace crown
@@ -102,30 +100,30 @@ void DebugLine::clear()
 //-----------------------------------------------------------------------------
 void DebugLine::commit()
 {
-	if (!m_num_lines)
-		return;
-
-	Renderer* r = device()->renderer();
-
-	TransientVertexBuffer tvb;
-	TransientIndexBuffer tib;
-	r->reserve_transient_vertex_buffer(&tvb, m_num_lines * 2, VertexFormat::P3_C4);
-	r->reserve_transient_index_buffer(&tib, m_num_lines * 2);
-
-	memcpy(tvb.data, m_lines, sizeof(Line) * m_num_lines);
-
-	uint16_t* indices = (uint16_t*) tib.data;
-	for (uint32_t i = 0; i < m_num_lines * 2; i++)
-	{
-		indices[i] = i;
-	}
-
-	r->set_state((m_depth_test ? STATE_DEPTH_TEST_LESS : 0) | STATE_COLOR_WRITE | STATE_CULL_CW | STATE_PRIMITIVE_LINES);
-	r->set_vertex_buffer(tvb);
-	r->set_index_buffer(tib);
-	r->set_program(render_world_globals::default_program());
-	r->set_pose(matrix4x4::IDENTITY);
-	r->commit(0);
+	// if (!m_num_lines)
+	// 	return;
+
+	// Renderer* r = device()->renderer();
+
+	// TransientVertexBuffer tvb;
+	// TransientIndexBuffer tib;
+	// r->reserve_transient_vertex_buffer(&tvb, m_num_lines * 2, VertexFormat::P3_C4);
+	// r->reserve_transient_index_buffer(&tib, m_num_lines * 2);
+
+	// memcpy(tvb.data, m_lines, sizeof(Line) * m_num_lines);
+
+	// uint16_t* indices = (uint16_t*) tib.data;
+	// for (uint32_t i = 0; i < m_num_lines * 2; i++)
+	// {
+	// 	indices[i] = i;
+	// }
+
+	// r->set_state((m_depth_test ? STATE_DEPTH_TEST_LESS : 0) | STATE_COLOR_WRITE | STATE_CULL_CW | STATE_PRIMITIVE_LINES);
+	// r->set_vertex_buffer(tvb);
+	// r->set_index_buffer(tib);
+	// r->set_program(render_world_globals::default_program());
+	// r->set_pose(matrix4x4::IDENTITY);
+	// r->commit(0);
 }
 
 } // namespace crown

engine/renderers/Gui.cpp

@@ -26,11 +26,9 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #include "Gui.h"
 #include "Assert.h"
-#include "Renderer.h"
 #include "Vector3.h"
 #include "Vector2.h"
 #include "RenderWorld.h"
-#include "RendererTypes.h"
 #include "Vector3.h"
 #include "Vector2.h"
 #include "Color4.h"
@@ -143,47 +141,47 @@ Vector2 Gui::screen_to_gui(const Vector2& pos)
 //-----------------------------------------------------------------------------
 void Gui::draw_rectangle(const Vector3& pos, const Vector2& size, const Color4& color)
 {
-	Renderer* r = device()->renderer();
-	TransientVertexBuffer tvb;
-	TransientIndexBuffer tib;
-
-	r->reserve_transient_vertex_buffer(&tvb, 4, VertexFormat::P2);
-	r->reserve_transient_index_buffer(&tib, 6);
-
-	float* verts = (float*) tvb.data;
-	verts[0] = pos.x;
-	verts[1] = pos.y;
-
-	verts[2] = pos.x + size.x;
-	verts[3] = pos.y;
-
-	verts[4] = pos.x + size.x;
-	verts[5] = pos.y + size.y;
-
-	verts[6] = pos.x;
-	verts[7] = pos.y + size.y;
-
-	uint16_t* inds = (uint16_t*) tib.data;
-	inds[0] = 0;
-	inds[1] = 1;
-	inds[2] = 2;
-	inds[3] = 0;
-	inds[4] = 2;
-	inds[5] = 3;
-
-	r->set_layer_view(1, matrix4x4::IDENTITY);
-	r->set_layer_projection(1, m_projection);
-	r->set_layer_viewport(1, 0, 0, m_width, m_height);
-	r->set_state(STATE_COLOR_WRITE
-					| STATE_CULL_CW
-					| STATE_BLEND_EQUATION_ADD 
-					| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
-	r->set_pose(m_pose);
-	r->set_program(render_world_globals::default_color_program());
-	r->set_uniform(render_world_globals::default_color_uniform(), UniformType::FLOAT_4, color4::to_float_ptr(color), 1);
-	r->set_vertex_buffer(tvb);
-	r->set_index_buffer(tib);
-	r->commit(1, (int32_t) pos.z);
+	// Renderer* r = device()->renderer();
+	// TransientVertexBuffer tvb;
+	// TransientIndexBuffer tib;
+
+	// r->reserve_transient_vertex_buffer(&tvb, 4, VertexFormat::P2);
+	// r->reserve_transient_index_buffer(&tib, 6);
+
+	// float* verts = (float*) tvb.data;
+	// verts[0] = pos.x;
+	// verts[1] = pos.y;
+
+	// verts[2] = pos.x + size.x;
+	// verts[3] = pos.y;
+
+	// verts[4] = pos.x + size.x;
+	// verts[5] = pos.y + size.y;
+
+	// verts[6] = pos.x;
+	// verts[7] = pos.y + size.y;
+
+	// uint16_t* inds = (uint16_t*) tib.data;
+	// inds[0] = 0;
+	// inds[1] = 1;
+	// inds[2] = 2;
+	// inds[3] = 0;
+	// inds[4] = 2;
+	// inds[5] = 3;
+
+	// r->set_layer_view(1, matrix4x4::IDENTITY);
+	// r->set_layer_projection(1, m_projection);
+	// r->set_layer_viewport(1, 0, 0, m_width, m_height);
+	// r->set_state(STATE_COLOR_WRITE
+	// 				| STATE_CULL_CW
+	// 				| STATE_BLEND_EQUATION_ADD 
+	// 				| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
+	// r->set_pose(m_pose);
+	// r->set_program(render_world_globals::default_color_program());
+	// r->set_uniform(render_world_globals::default_color_uniform(), UniformType::FLOAT_4, color4::to_float_ptr(color), 1);
+	// r->set_vertex_buffer(tvb);
+	// r->set_index_buffer(tib);
+	// r->commit(1, (int32_t) pos.z);
 }
 
 //-----------------------------------------------------------------------------
@@ -195,187 +193,187 @@ void Gui::draw_image(const char* material, const Vector3& pos, const Vector2& si
 //-----------------------------------------------------------------------------
 void Gui::draw_image_uv(const char* material, const Vector3& pos, const Vector2& size, const Vector2& uv0, const Vector2& uv1, const Color4& color)
 {
-	Renderer* r = device()->renderer();
-	TransientVertexBuffer tvb;
-	TransientIndexBuffer tib;
-
-	r->reserve_transient_vertex_buffer(&tvb, 4, VertexFormat::P2_T2);
-	r->reserve_transient_index_buffer(&tib, 6);
-
-	float* verts = (float*) tvb.data;
-	verts[0] = pos.x;
-	verts[1] = pos.y;
-	verts[2] = uv0.x;
-	verts[3] = uv0.y;
-
-	verts[4] = pos.x + size.x;
-	verts[5] = pos.y;
-	verts[6] = uv1.x;
-	verts[7] = uv0.y;
-
-	verts[8] = pos.x + size.x;
-	verts[9] = pos.y + size.y;
-	verts[10] = uv1.x;
-	verts[11] = uv1.y;
-
-	verts[12] = pos.x;
-	verts[13] = pos.y + size.y;
-	verts[14] = uv0.x;
-	verts[15] = uv1.y;
-
-	uint16_t* inds = (uint16_t*) tib.data;
-	inds[0] = 0;
-	inds[1] = 1;
-	inds[2] = 2;
-	inds[3] = 0;
-	inds[4] = 2;
-	inds[5] = 3;
-
-	const MaterialResource* mr = (MaterialResource*) device()->resource_manager()->get("material", material);
-	const TextureResource* tr = (TextureResource*) device()->resource_manager()->get(mr->get_texture_layer(0));
-
-	r->set_layer_view(1, matrix4x4::IDENTITY);
-	r->set_layer_projection(1, m_projection);
-	r->set_layer_viewport(1, 0, 0, m_width, m_height);
-	r->set_state(STATE_COLOR_WRITE
-					| STATE_CULL_CW
-					| STATE_BLEND_EQUATION_ADD 
-					| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
-	r->set_pose(m_pose);
-	r->set_program(render_world_globals::default_texture_program());
-	r->set_texture(0, render_world_globals::default_albedo_uniform(), tr->texture(),
-					TEXTURE_FILTER_LINEAR | TEXTURE_WRAP_U_CLAMP_REPEAT | TEXTURE_WRAP_V_CLAMP_REPEAT);
-	r->set_uniform(render_world_globals::default_color_uniform(), UniformType::FLOAT_4, color4::to_float_ptr(color), 1);
-	r->set_vertex_buffer(tvb);
-	r->set_index_buffer(tib);
-	r->commit(1, (int32_t) pos.z);
+	// Renderer* r = device()->renderer();
+	// TransientVertexBuffer tvb;
+	// TransientIndexBuffer tib;
+
+	// r->reserve_transient_vertex_buffer(&tvb, 4, VertexFormat::P2_T2);
+	// r->reserve_transient_index_buffer(&tib, 6);
+
+	// float* verts = (float*) tvb.data;
+	// verts[0] = pos.x;
+	// verts[1] = pos.y;
+	// verts[2] = uv0.x;
+	// verts[3] = uv0.y;
+
+	// verts[4] = pos.x + size.x;
+	// verts[5] = pos.y;
+	// verts[6] = uv1.x;
+	// verts[7] = uv0.y;
+
+	// verts[8] = pos.x + size.x;
+	// verts[9] = pos.y + size.y;
+	// verts[10] = uv1.x;
+	// verts[11] = uv1.y;
+
+	// verts[12] = pos.x;
+	// verts[13] = pos.y + size.y;
+	// verts[14] = uv0.x;
+	// verts[15] = uv1.y;
+
+	// uint16_t* inds = (uint16_t*) tib.data;
+	// inds[0] = 0;
+	// inds[1] = 1;
+	// inds[2] = 2;
+	// inds[3] = 0;
+	// inds[4] = 2;
+	// inds[5] = 3;
+
+	// const MaterialResource* mr = (MaterialResource*) device()->resource_manager()->get("material", material);
+	// const TextureResource* tr = (TextureResource*) device()->resource_manager()->get(mr->get_texture_layer(0));
+
+	// r->set_layer_view(1, matrix4x4::IDENTITY);
+	// r->set_layer_projection(1, m_projection);
+	// r->set_layer_viewport(1, 0, 0, m_width, m_height);
+	// r->set_state(STATE_COLOR_WRITE
+	// 				| STATE_CULL_CW
+	// 				| STATE_BLEND_EQUATION_ADD 
+	// 				| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
+	// r->set_pose(m_pose);
+	// r->set_program(render_world_globals::default_texture_program());
+	// r->set_texture(0, render_world_globals::default_albedo_uniform(), tr->texture(),
+	// 				TEXTURE_FILTER_LINEAR | TEXTURE_WRAP_U_CLAMP_REPEAT | TEXTURE_WRAP_V_CLAMP_REPEAT);
+	// r->set_uniform(render_world_globals::default_color_uniform(), UniformType::FLOAT_4, color4::to_float_ptr(color), 1);
+	// r->set_vertex_buffer(tvb);
+	// r->set_index_buffer(tib);
+	// r->commit(1, (int32_t) pos.z);
 }
 
 //-----------------------------------------------------------------------------
 void Gui::draw_text(const char* str, const char* font, uint32_t font_size, const Vector3& pos, const Color4& color)
 {
-	Renderer* r = device()->renderer();
-
-	const FontResource* resource = (FontResource*) device()->resource_manager()->get("font", font);
-	Vector2 m_pen;
-
-	const float scale = ((float)font_size / (float)resource->font_size());
-	const uint32_t str_len = string::strlen(str);
-
-	TransientVertexBuffer vb;
-	TransientIndexBuffer ib;
-
-	r->reserve_transient_vertex_buffer(&vb, 4 * str_len, VertexFormat::P2_T2);
-	r->reserve_transient_index_buffer(&ib, 6 * str_len);
-
-	uint16_t index = 0;
-	float x_pen_advance = 0.0f;
-	float y_pen_advance = 0.0f;
-
-	uint32_t state = 0;
-	uint32_t code_point = 0;
-	for (uint32_t i = 0; i < str_len; i++)
-	{
-		switch (str[i])
-		{
-			case '\n':
-			{
-				x_pen_advance = 0.0f;
-				y_pen_advance -= resource->font_size();
-				continue;
-			}
-			case '\t':
-			{
-				x_pen_advance += font_size * 4;
-				continue;
-			}
-		}
+	// Renderer* r = device()->renderer();
+
+	// const FontResource* resource = (FontResource*) device()->resource_manager()->get("font", font);
+	// Vector2 m_pen;
+
+	// const float scale = ((float)font_size / (float)resource->font_size());
+	// const uint32_t str_len = string::strlen(str);
+
+	// TransientVertexBuffer vb;
+	// TransientIndexBuffer ib;
+
+	// r->reserve_transient_vertex_buffer(&vb, 4 * str_len, VertexFormat::P2_T2);
+	// r->reserve_transient_index_buffer(&ib, 6 * str_len);
+
+	// uint16_t index = 0;
+	// float x_pen_advance = 0.0f;
+	// float y_pen_advance = 0.0f;
+
+	// uint32_t state = 0;
+	// uint32_t code_point = 0;
+	// for (uint32_t i = 0; i < str_len; i++)
+	// {
+	// 	switch (str[i])
+	// 	{
+	// 		case '\n':
+	// 		{
+	// 			x_pen_advance = 0.0f;
+	// 			y_pen_advance -= resource->font_size();
+	// 			continue;
+	// 		}
+	// 		case '\t':
+	// 		{
+	// 			x_pen_advance += font_size * 4;
+	// 			continue;
+	// 		}
+	// 	}
 		
-		if (utf8_decode(&state, &code_point, str[i]) == UTF8_ACCEPT)
-		{
-			FontGlyphData g = resource->get_glyph(code_point);
-
-			const float baseline = g.height - g.y_offset;
-
-			// Set pen position
-			m_pen.x = pos.x + g.x_offset;
-			m_pen.y = pos.y - baseline;
-
-			// Position coords
-			const float x0 = (m_pen.x + x_pen_advance) * scale;
-			const float y0 = (m_pen.y + y_pen_advance) * scale;
-			const float x1 = (m_pen.x + g.width + x_pen_advance) * scale;
-			const float y1 = (m_pen.y + g.height + y_pen_advance) * scale;
-
-			// Texture coords
-			const float u0 = (float) g.x / 512;
-			const float v0 = (float) g.y / 512;
-			const float u1 = u0 + ((float) g.width) / 512;
-			const float v1 = v0 - ((float) g.height) / 512;
-
-			// Fill vertex buffer
-			(*(VertexData*)(vb.data)).x		= x0;
-			(*(VertexData*)(vb.data)).y		= y0;
-			(*(VertexData*)(vb.data)).u		= u0;
-			(*(VertexData*)(vb.data)).v		= v1;
-			vb.data += sizeof(VertexData);
-
-			(*(VertexData*)(vb.data)).x		= x1;
-			(*(VertexData*)(vb.data)).y		= y0;
-			(*(VertexData*)(vb.data)).u		= u1;
-			(*(VertexData*)(vb.data)).v		= v1;
-			vb.data += sizeof(VertexData);
-
-			(*(VertexData*)(vb.data)).x		= x1;
-			(*(VertexData*)(vb.data)).y		= y1;
-			(*(VertexData*)(vb.data)).u		= u1;
-			(*(VertexData*)(vb.data)).v		= v0;
-			vb.data += sizeof(VertexData);
-
-			(*(VertexData*)(vb.data)).x		= x0;
-			(*(VertexData*)(vb.data)).y		= y1;
-			(*(VertexData*)(vb.data)).u		= u0;
-			(*(VertexData*)(vb.data)).v		= v0;
-			vb.data += sizeof(VertexData);
-
-			// Fill index buffer
-			(*(IndexData*)(ib.data)).a		= index;
-			(*(IndexData*)(ib.data)).b		= index + 1;
-			ib.data += sizeof(IndexData);
-
-			(*(IndexData*)(ib.data)).a		= index + 2;
-			(*(IndexData*)(ib.data)).b		= index;
-			ib.data += sizeof(IndexData);
-
-			(*(IndexData*)(ib.data)).a		= index + 2;
-			(*(IndexData*)(ib.data)).b		= index + 3;
-			ib.data += sizeof(IndexData);
-
-			// Advance pen position
-			x_pen_advance += g.x_advance;
-
-			index += 4;
-		}
-	}
-
-	const MaterialResource* mr = (MaterialResource*) device()->resource_manager()->get(resource->material());
-	const TextureResource* tr = (TextureResource*) device()->resource_manager()->get(mr->get_texture_layer(0));
-
-	r->set_layer_view(1, matrix4x4::IDENTITY);
-	r->set_layer_projection(1, m_projection);
-	r->set_layer_viewport(1, 0, 0, 1000, 625);
-	r->set_state(STATE_COLOR_WRITE
-					| STATE_CULL_CW
-					| STATE_BLEND_EQUATION_ADD 
-					| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
-	r->set_pose(m_pose);
-	r->set_program(render_world_globals::default_font_program());
-	r->set_texture(0, render_world_globals::default_font_uniform(), tr->texture(),
-					TEXTURE_FILTER_LINEAR | TEXTURE_WRAP_U_CLAMP_REPEAT | TEXTURE_WRAP_V_CLAMP_REPEAT);
-	r->set_uniform(render_world_globals::default_color_uniform(), UniformType::FLOAT_4, color4::to_float_ptr(color), 1);
-	r->set_vertex_buffer(vb);
-	r->set_index_buffer(ib);
-	r->commit(1, (int32_t) pos.z);
+	// 	if (utf8_decode(&state, &code_point, str[i]) == UTF8_ACCEPT)
+	// 	{
+	// 		FontGlyphData g = resource->get_glyph(code_point);
+
+	// 		const float baseline = g.height - g.y_offset;
+
+	// 		// Set pen position
+	// 		m_pen.x = pos.x + g.x_offset;
+	// 		m_pen.y = pos.y - baseline;
+
+	// 		// Position coords
+	// 		const float x0 = (m_pen.x + x_pen_advance) * scale;
+	// 		const float y0 = (m_pen.y + y_pen_advance) * scale;
+	// 		const float x1 = (m_pen.x + g.width + x_pen_advance) * scale;
+	// 		const float y1 = (m_pen.y + g.height + y_pen_advance) * scale;
+
+	// 		// Texture coords
+	// 		const float u0 = (float) g.x / 512;
+	// 		const float v0 = (float) g.y / 512;
+	// 		const float u1 = u0 + ((float) g.width) / 512;
+	// 		const float v1 = v0 - ((float) g.height) / 512;
+
+	// 		// Fill vertex buffer
+	// 		(*(VertexData*)(vb.data)).x		= x0;
+	// 		(*(VertexData*)(vb.data)).y		= y0;
+	// 		(*(VertexData*)(vb.data)).u		= u0;
+	// 		(*(VertexData*)(vb.data)).v		= v1;
+	// 		vb.data += sizeof(VertexData);
+
+	// 		(*(VertexData*)(vb.data)).x		= x1;
+	// 		(*(VertexData*)(vb.data)).y		= y0;
+	// 		(*(VertexData*)(vb.data)).u		= u1;
+	// 		(*(VertexData*)(vb.data)).v		= v1;
+	// 		vb.data += sizeof(VertexData);
+
+	// 		(*(VertexData*)(vb.data)).x		= x1;
+	// 		(*(VertexData*)(vb.data)).y		= y1;
+	// 		(*(VertexData*)(vb.data)).u		= u1;
+	// 		(*(VertexData*)(vb.data)).v		= v0;
+	// 		vb.data += sizeof(VertexData);
+
+	// 		(*(VertexData*)(vb.data)).x		= x0;
+	// 		(*(VertexData*)(vb.data)).y		= y1;
+	// 		(*(VertexData*)(vb.data)).u		= u0;
+	// 		(*(VertexData*)(vb.data)).v		= v0;
+	// 		vb.data += sizeof(VertexData);
+
+	// 		// Fill index buffer
+	// 		(*(IndexData*)(ib.data)).a		= index;
+	// 		(*(IndexData*)(ib.data)).b		= index + 1;
+	// 		ib.data += sizeof(IndexData);
+
+	// 		(*(IndexData*)(ib.data)).a		= index + 2;
+	// 		(*(IndexData*)(ib.data)).b		= index;
+	// 		ib.data += sizeof(IndexData);
+
+	// 		(*(IndexData*)(ib.data)).a		= index + 2;
+	// 		(*(IndexData*)(ib.data)).b		= index + 3;
+	// 		ib.data += sizeof(IndexData);
+
+	// 		// Advance pen position
+	// 		x_pen_advance += g.x_advance;
+
+	// 		index += 4;
+	// 	}
+	// }
+
+	// const MaterialResource* mr = (MaterialResource*) device()->resource_manager()->get(resource->material());
+	// const TextureResource* tr = (TextureResource*) device()->resource_manager()->get(mr->get_texture_layer(0));
+
+	// r->set_layer_view(1, matrix4x4::IDENTITY);
+	// r->set_layer_projection(1, m_projection);
+	// r->set_layer_viewport(1, 0, 0, 1000, 625);
+	// r->set_state(STATE_COLOR_WRITE
+	// 				| STATE_CULL_CW
+	// 				| STATE_BLEND_EQUATION_ADD 
+	// 				| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
+	// r->set_pose(m_pose);
+	// r->set_program(render_world_globals::default_font_program());
+	// r->set_texture(0, render_world_globals::default_font_uniform(), tr->texture(),
+	// 				TEXTURE_FILTER_LINEAR | TEXTURE_WRAP_U_CLAMP_REPEAT | TEXTURE_WRAP_V_CLAMP_REPEAT);
+	// r->set_uniform(render_world_globals::default_color_uniform(), UniformType::FLOAT_4, color4::to_float_ptr(color), 1);
+	// r->set_vertex_buffer(vb);
+	// r->set_index_buffer(ib);
+	// r->commit(1, (int32_t) pos.z);
 }
 
 } // namespace crown

engine/renderers/Material.cpp

@@ -26,8 +26,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #include "Material.h"
 #include "MaterialResource.h"
-#include "Renderer.h"
-#include "Device.h"
 #include "ResourceManager.h"
 #include "TextureResource.h"
 
@@ -52,12 +50,12 @@ const MaterialResource* Material::resource()
 }
 
 //-----------------------------------------------------------------------------
-void Material::bind(Renderer& r, UniformId uniform)
-{
-	const ResourceId tr_id = m_resource->get_texture_layer(0);
-	const TextureResource* tr = (TextureResource*) device()->resource_manager()->get(tr_id);
+// void Material::bind(Renderer& r, UniformId uniform)
+// {
+// 	const ResourceId tr_id = m_resource->get_texture_layer(0);
+// 	const TextureResource* tr = (TextureResource*) device()->resource_manager()->get(tr_id);
 
-	r.set_texture(0, uniform, tr->texture(), TEXTURE_FILTER_LINEAR | TEXTURE_WRAP_U_CLAMP_REPEAT | TEXTURE_WRAP_V_CLAMP_REPEAT);
-}
+// 	r.set_texture(0, uniform, tr->texture(), TEXTURE_FILTER_LINEAR | TEXTURE_WRAP_U_CLAMP_REPEAT | TEXTURE_WRAP_V_CLAMP_REPEAT);
+// }
 
 } // namespace crown

engine/renderers/Material.h

@@ -26,8 +26,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #pragma once
 
-#include "RendererTypes.h"
-
 namespace crown
 {
 
@@ -41,7 +39,7 @@ struct Material
 
 	const MaterialResource* resource();
 
-	void bind(Renderer& r, UniformId uniform);
+	// void bind(Renderer& r, UniformId uniform);
 
 private:
 

engine/renderers/Mesh.cpp

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

engine/renderers/Mesh.h

@@ -26,7 +26,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #pragma once
 
-#include "RendererTypes.h"
 #include "Matrix4x4.h"
 
 namespace crown
@@ -40,28 +39,25 @@ struct Vector3;
 
 struct Mesh
 {
-							Mesh(SceneGraph& sg, int32_t node, const MeshResource* mr);
+	Mesh(SceneGraph& sg, int32_t node, const MeshResource* mr);
 
-	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);
 
 public:
 
-	SceneGraph&				m_scene_graph;
-	int32_t					m_node;
-	const MeshResource*		m_resource;
-
-	VertexBufferId			m_vbuffer;
-	IndexBufferId			m_ibuffer;
+	SceneGraph& m_scene_graph;
+	int32_t m_node;
+	const MeshResource* m_resource;
 };
 
 } // namespace crown

engine/renderers/Sprite.cpp

@@ -31,7 +31,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Allocator.h"
 #include "SceneGraph.h"
 #include "Unit.h"
-#include "Renderer.h"
 #include "Material.h"
 #include "RenderWorld.h"
 
@@ -49,8 +48,17 @@ Sprite::Sprite(RenderWorld& render_world, SceneGraph& sg, int32_t node, const Sp
 	, m_time(0)
 	, m_loop(false)
 {
-	m_vb = sr->vertex_buffer();
-	m_ib = sr->index_buffer();
+	Blob vmem = sr->get_vertices();
+	Blob imem = sr->get_indices();
+
+	bgfx::VertexDecl decl;
+	decl.begin()
+		.add(bgfx::Attrib::Position, 2, bgfx::AttribType::Float)
+		.add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float, true)
+		.end();
+
+	m_vb = bgfx::createVertexBuffer(bgfx::makeRef((void*) vmem.m_data, vmem.m_size), decl);
+	m_ib = bgfx::createIndexBuffer(bgfx::makeRef((void*) imem.m_data, imem.m_size));
 }
 
 //-----------------------------------------------------------------------------
@@ -170,21 +178,47 @@ void Sprite::update(float dt)
 }
 
 //-----------------------------------------------------------------------------
-void Sprite::render(Renderer& r, UniformId uniform, float dt)
-{
-	Material* material = m_render_world.get_material(m_material);
-	material->bind(r, uniform);
-
-	r.set_state(STATE_DEPTH_WRITE 
-		| STATE_COLOR_WRITE 
-		| STATE_ALPHA_WRITE 
-		| STATE_CULL_CW 
-		| 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, m_frame * 6, 6);
-	r.set_pose(world_pose());
-	r.commit(0);
+void Sprite::render()
+{
+	// Material* material = m_render_world.get_material(m_material);
+	// material->bind(r, uniform);
+
+	///
+	/// @param _state State flags. Default state for primitive type is
+	///   triangles. See: BGFX_STATE_DEFAULT.
+	///
+	///   BGFX_STATE_ALPHA_WRITE - Enable alpha write.
+	///   BGFX_STATE_DEPTH_WRITE - Enable depth write.
+	///   BGFX_STATE_DEPTH_TEST_* - Depth test function.
+	///   BGFX_STATE_BLEND_* - See NOTE 1: BGFX_STATE_BLEND_FUNC.
+	///   BGFX_STATE_BLEND_EQUATION_* - See NOTE 2.
+	///   BGFX_STATE_CULL_* - Backface culling mode.
+	///   BGFX_STATE_RGB_WRITE - Enable RGB write.
+	///   BGFX_STATE_MSAA - Enable MSAA.
+	///   BGFX_STATE_PT_[LINES/POINTS] - Primitive type.
+	///
+	/// @param _rgba Sets blend factor used by BGFX_STATE_BLEND_FACTOR and
+	///   BGFX_STATE_BLEND_INV_FACTOR blend modes.
+	///
+	/// NOTE:
+	///   1. Use BGFX_STATE_ALPHA_REF, BGFX_STATE_POINT_SIZE and
+	///      BGFX_STATE_BLEND_FUNC macros to setup more complex states.
+	///   2. BGFX_STATE_BLEND_EQUATION_ADD is set when no other blend
+	///      equation is specified.
+	///
+	bgfx::setState(BGFX_STATE_DEFAULT);
+
+	// r.set_state(STATE_DEPTH_WRITE 
+	// 	| STATE_COLOR_WRITE 
+	// 	| STATE_ALPHA_WRITE 
+	// 	| STATE_CULL_CW 
+	// 	| STATE_BLEND_EQUATION_ADD 
+	// 	| STATE_BLEND_FUNC(STATE_BLEND_FUNC_SRC_ALPHA, STATE_BLEND_FUNC_ONE_MINUS_SRC_ALPHA));
+
+	bgfx::setVertexBuffer(m_vb);
+	bgfx::setIndexBuffer(m_ib, m_frame * 6, 6);
+	bgfx::setTransform(matrix4x4::to_float_ptr(world_pose()));
+	bgfx::submit(0);
 }
 
 } // namespace crown

engine/renderers/Sprite.h

@@ -26,12 +26,12 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #pragma once
 
-#include "RendererTypes.h"
 #include "RenderWorldTypes.h"
 #include "Vector3.h"
 #include "Matrix4x4.h"
 #include "Quaternion.h"
 #include "SpriteResource.h"
+#include <bgfx.h>
 
 namespace crown
 {
@@ -60,7 +60,7 @@ struct Sprite
 	void set_local_pose(Unit* unit, const Matrix4x4& pose);
 
 	void set_material(MaterialId mat);
-	void render(Renderer& r, UniformId uniform, float dt);
+	void render();
 	void set_frame(uint32_t i);
 
 	void play_animation(const char* name, bool loop);
@@ -71,13 +71,13 @@ struct Sprite
 public:
 
 	RenderWorld&			m_render_world;
-	SceneGraph&				m_scene_graph;	
+	SceneGraph&				m_scene_graph;
 	int32_t					m_node;
 	const SpriteResource*	m_resource;
 
-	MaterialId				m_material;
-	VertexBufferId			m_vb;
-	IndexBufferId			m_ib;
+	MaterialId m_material;
+	bgfx::VertexBufferHandle m_vb;
+	bgfx::IndexBufferHandle m_ib;
 
 	uint32_t m_frame;
 

engine/resource/MeshResource.cpp

@@ -174,7 +174,7 @@ void compile(Filesystem& fs, const char* resource_path, File* out_file)
 
 	MeshData data;
 	data.vertices.num_vertices = array::size(m_vertices);
-	data.vertices.format = VertexFormat::P3_N3_T2;
+	// data.vertices.format = VertexFormat::P3_N3_T2;
 	data.vertices.offset = sizeof(MeshHeader) + sizeof(MeshData);
 
 	data.indices.num_indices = array::size(m_indices);

engine/resource/MeshResource.h

@@ -28,12 +28,10 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #include "Types.h"
 #include "Resource.h"
-#include "PixelFormat.h"
 #include "Allocator.h"
 #include "Bundle.h"
 #include "File.h"
 #include "Device.h"
-#include "Renderer.h"
 
 namespace crown
 {
@@ -43,8 +41,8 @@ const uint32_t MESH_VERSION = 1;
 
 struct MeshHeader
 {
-	VertexBufferId		vbuffer;
-	IndexBufferId		ibuffer;
+	uint32_t			vbuffer;
+	uint32_t			ibuffer;
 	uint32_t			version;
 	uint32_t			num_meshes;
 	uint32_t			num_joints;
@@ -54,7 +52,7 @@ struct MeshHeader
 struct VertexData
 {
 	uint32_t	    	num_vertices;
-	VertexFormat::Enum	format;
+	// VertexFormat::Enum	format;
 	uint32_t			offset;
 };
 
@@ -94,8 +92,8 @@ public:
 		MeshResource* m = (MeshResource*) resource;
 		MeshHeader* h = (MeshHeader*) m;
 
-		h->vbuffer = device()->renderer()->create_vertex_buffer(m->num_vertices() * Vertex::bytes_per_vertex(m->vertex_format()), m->vertices(), m->vertex_format());
-		h->ibuffer = device()->renderer()->create_index_buffer(m->num_indices() * sizeof(uint16_t), m->indices());
+		// h->vbuffer = device()->renderer()->create_vertex_buffer(m->num_vertices() * Vertex::bytes_per_vertex(m->vertex_format()), m->vertices(), m->vertex_format());
+		// h->ibuffer = device()->renderer()->create_index_buffer(m->num_indices() * sizeof(uint16_t), m->indices());
 	}
 
 	//-----------------------------------------------------------------------------
@@ -111,8 +109,8 @@ public:
 		MeshResource* m = (MeshResource*) resource;
 		MeshHeader* h = (MeshHeader*) m;
 
-		device()->renderer()->destroy_index_buffer(h->ibuffer);
-		device()->renderer()->destroy_vertex_buffer(h->vbuffer);
+		// device()->renderer()->destroy_index_buffer(h->ibuffer);
+		// device()->renderer()->destroy_vertex_buffer(h->vbuffer);
 	}
 
 	//-----------------------------------------------------------------------------
@@ -122,13 +120,6 @@ public:
 		return data->vertices.num_vertices;
 	}
 
-	//-----------------------------------------------------------------------------
-	VertexFormat::Enum vertex_format() const
-	{
-		MeshData* data = (MeshData*) ((char*) this) + sizeof(MeshHeader);
-		return data->vertices.format;
-	}
-
 	//-----------------------------------------------------------------------------
 	float* vertices() const
 	{
@@ -150,20 +141,6 @@ public:
 		return (uint16_t*) (((char*)this) + data->indices.offset);
 	}
 
-	//-----------------------------------------------------------------------------
-	VertexBufferId vertex_buffer() const
-	{
-		MeshHeader* h = (MeshHeader*) this;
-		return h->vbuffer;
-	}
-
-	//-----------------------------------------------------------------------------
-	IndexBufferId index_buffer() const
-	{
-		MeshHeader* h = (MeshHeader*) this;
-		return h->ibuffer;
-	}
-
 private:
 
 	// Disable construction

engine/resource/SpriteResource.h

@@ -38,9 +38,9 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Bundle.h"
 #include "Device.h"
 #include "ResourceManager.h"
-#include "RendererTypes.h"
-#include "Renderer.h"
 #include "TextureResource.h"
+#include "Blob.h"
+#include <bgfx.h>
 
 namespace crown
 {
@@ -49,8 +49,7 @@ const uint32_t SPRITE_VERSION = 1;
 
 struct SpriteHeader
 {
-	VertexBufferId 	vb;
-	IndexBufferId 	ib;
+	uint32_t		dummy[2];
 	uint32_t		num_animations;
 	uint32_t		animations_offset;
 	uint32_t		num_vertices;
@@ -85,15 +84,8 @@ struct SpriteResource
 	}
 
 	//-----------------------------------------------------------------------------
-	static void online(void* resource)
+	static void online(void* /*resource*/)
 	{
-		SpriteHeader* h = (SpriteHeader*) resource;
-
-		const float* vertices = (float*) (((char*) resource) + h->vertices_offset);
-		const uint16_t* indices = (uint16_t*) (((char*) resource) + h->indices_offset);
-
-		h->vb = device()->renderer()->create_vertex_buffer(h->num_vertices * Vertex::bytes_per_vertex(VertexFormat::P2_T2), vertices, VertexFormat::P2_T2);
-		h->ib = device()->renderer()->create_index_buffer(h->num_indices * sizeof(uint16_t), indices);
 	}
 
 	//-----------------------------------------------------------------------------
@@ -104,15 +96,8 @@ struct SpriteResource
 	}
 
 	//-----------------------------------------------------------------------------
-	static void offline(void* resource)
+	static void offline(void* /*resource*/)
 	{
-		CE_ASSERT_NOT_NULL(resource);
-
-		SpriteResource* sr = (SpriteResource*) resource;
-		SpriteHeader* h = (SpriteHeader*) sr;
-
-		device()->renderer()->destroy_vertex_buffer(h->vb);
-		device()->renderer()->destroy_index_buffer(h->ib);
 	}
 
 	//-----------------------------------------------------------------------------
@@ -139,16 +124,22 @@ struct SpriteResource
 		return begin[a->start_frame + frame];
 	}
 
-	//-----------------------------------------------------------------------------
-	VertexBufferId vertex_buffer() const
+	Blob get_vertices() const
 	{
-		return ((SpriteHeader*) this)->vb;
+		SpriteHeader* h = (SpriteHeader*) this;
+		Blob b;
+		b.m_size = ((SpriteHeader*) this)->num_vertices * 16;
+		b.m_data = (uintptr_t) (((char*) this) + h->vertices_offset);
+		return b;
 	}
 
-	//-----------------------------------------------------------------------------
-	IndexBufferId index_buffer() const
+	Blob get_indices() const
 	{
-		return ((SpriteHeader*) this)->ib;
+		SpriteHeader* h = (SpriteHeader*) this;
+		Blob b;
+		b.m_size = ((SpriteHeader*) this)->num_indices * 2;
+		b.m_data = (uintptr_t) (((char*) this) + h->indices_offset);
+		return b;
 	}
 
 private:

engine/resource/TextureResource.cpp

@@ -26,7 +26,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #include "Allocator.h"
 #include "Filesystem.h"
-#include "PixelFormat.h"
 #include "TextureResource.h"
 #include "ReaderWriter.h"
 #include "JSONParser.h"
@@ -37,452 +36,10 @@ namespace crown
 namespace texture_resource
 {
 
-struct ImageData
-{
-	uint32_t width;
-	uint32_t height;
-	uint32_t pitch;
-	PixelFormat::Enum format;
-	uint32_t num_mips;
-	char* data;
-};
-
-struct MipData
-{
-	uint32_t width;
-	uint32_t height;
-	PixelFormat::Enum format;
-	uint32_t size;
-	char* data;
-};
-
-//-----------------------------------------------------------------------------
-void read_mip_image(const ImageData& image, uint8_t mip, MipData& data)
-{
-	uint32_t width = image.width;
-	uint32_t height = image.height;
-	//uint32_t pitch = image.pitch;
-	uint32_t cur_mip = 0;
-	char* src = image.data;
-
-	while (1)
-	{
-		const uint32_t size = width * height * pixel_format::size(image.format);
-
-		if (cur_mip == mip)
-		{
-			data.width = width;
-			data.height = height;
-			data.format = image.format;
-			data.size = size;
-			data.data = src;
-			return;
-		}
-		
-		width = math::max(1u, width >> 1);
-		height = math::max(1u, height >> 1);
-		cur_mip++;
-		src += size;
-	}
-}
-
-//-----------------------------------------------------------------------------
-void swap_red_blue(uint32_t width, uint32_t height, uint8_t channels, char* data)
-{
-	uint32_t i = 0;
-
-	for (uint32_t h = 0; h < height; h++)
-	{
-		for (uint32_t w = 0; w < width; w++)
-		{
-			const uint8_t tmp = data[i + 0];
-			data[i + 0] = data[i + 2];
-			data[i + 2] = tmp;
-
-			i += channels;
-		}
-	}
-}
-
-//-----------------------------------------------------------------------------
-void read_tga_uncompressed(BinaryReader& br, uint32_t width, uint32_t height, uint8_t channels, ImageData& image)
-{
-	if (channels == 2)
-	{
-		uint32_t i = 0;
-
-		for (uint32_t h = 0; h < height; h++)
-		{
-			for (uint32_t w = 0; w < width; w++)
-			{
-				uint16_t data;
-				br.read(data);
-
-				image.data[i + 0] = (data & 0x7c) >> 10;
-				image.data[i + 1] = (data & 0x3e) >> 5;
-				image.data[i + 2] = (data & 0x1f);
-
-				i += 3;
-			}
-		}
-	}
-	else
-	{
-		br.read(image.data, width * height * channels);
-		swap_red_blue(width, height, channels, image.data);
-	}
-}
-
-//-----------------------------------------------------------------------------
-void read_tga_compressed(BinaryReader& br, uint32_t width, uint32_t height, uint8_t channels, ImageData& image)
-{
-	uint8_t rle_id = 0;
-	uint32_t i = 0;
-	uint32_t colors_read = 0;
-
-	// Can't be more than 4 channels
-	uint8_t colors[4];
-
-	while (i < width * height)
-	{
-		br.read(rle_id);
-
-		// If MSB == 1
-		if (rle_id & 0x80)
-		{
-			rle_id -= 127;
-			
-			br.read(colors[0]);
-			br.read(colors[1]);
-			br.read(colors[2]);
-
-			if (channels == 4)
-				br.read(colors[3]);
-
-			while (rle_id)
-			{
-				image.data[colors_read + 0] = colors[2];
-				image.data[colors_read + 1] = colors[1];
-				image.data[colors_read + 2] = colors[0];
-
-				if (channels == 4)
-					image.data[colors_read + 3] = colors[3];
-
-				rle_id--;
-				colors_read += channels;
-				i++;
-			}
-		}
-		else
-		{
-			rle_id++;
-
-			while (rle_id)
-			{
-				br.read(colors[0]);
-				br.read(colors[1]);
-				br.read(colors[2]);
-
-				if (channels == 4)
-					br.read(colors[3]);
-				
-				image.data[colors_read + 0] = colors[2];
-				image.data[colors_read + 1] = colors[1];
-				image.data[colors_read + 2] = colors[0];
-
-				if (channels == 4)
-					image.data[colors_read + 3] = colors[3];
-
-				rle_id--;
-				colors_read += channels;
-				i++;
-			}
-		}
-	}
-}
-
-//-----------------------------------------------------------------------------
-void parse_tga(BinaryReader& br, ImageData& image)
-{
-	uint8_t id;
-	br.read(id);
-
-	uint8_t cmap_type;
-	br.read(cmap_type);
-
-	uint8_t image_type;
-	br.read(image_type);
-
-	uint8_t garbage;
-	for (uint32_t i = 0; i < 5; i++)
-		br.read(garbage);
-
-	uint16_t x_offt;
-	br.read(x_offt);
-
-	uint16_t y_offt;
-	br.read(y_offt);
-
-	uint16_t width;
-	br.read(width);
-
-	uint16_t height;
-	br.read(height);
-
-	uint8_t depth;
-	br.read(depth);
-
-	uint8_t desc;
-	br.read(desc);
-
-	// Skip TGA ID
-	br.skip(id);
-
-	CE_ASSERT(image_type != 0, "TGA does not contain image data");
-	CE_ASSERT(image_type == 2 || image_type == 10, "TGA image format not supported");
-
-	const uint32_t channels = depth / 8;
-
-	image.width = width;
-	image.height = height;
-	image.num_mips = 1;
-
-	switch (channels)
-	{
-		case 2: image.format = PixelFormat::R8G8B8; break;
-		case 3: image.format = PixelFormat::R8G8B8; break;
-		case 4: image.format = PixelFormat::R8G8B8A8; break;
-		default: CE_FATAL("TGA channels not supported"); break;
-	}
-
-	image.data = (char*) default_allocator().allocate(pixel_format::size(image.format) * width * height);
-
-	if (image_type == 2)
-	{
-		read_tga_uncompressed(br, width, height, channels, image);
-	}
-	else if (image_type == 10)
-	{
-		read_tga_compressed(br, width, height, channels, image);
-	}
-
-	return;
-}
-
-//-----------------------------------------------------------------------------
-void parse_dds(BinaryReader& br, ImageData& image)
-{
-	// Read header
-	uint32_t magic;
-	br.read(magic);
-	CE_ASSERT(magic == DDSD_MAGIC, "DDS bad magic number");
-
-	uint32_t hsize;
-	br.read(hsize);
-	CE_ASSERT(hsize == DDSD_HEADERSIZE, "DDS bas header size");
-
-	uint32_t flags;
-	br.read(flags);
-	CE_ASSERT(flags & (DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT), "DDS bad header flags");
-
-	uint32_t height;
-	br.read(height);
-
-	uint32_t width;
-	br.read(width);
-
-	uint32_t pitch;
-	br.read(pitch);
-
-	uint32_t depth;
-	br.read(depth);
-
-	uint32_t num_mips;
-	br.read(num_mips);
-
-	// Skip reserved bits
-	br.skip(sizeof(uint32_t) * 11);
-
-	// Read pixel format
-	uint32_t pf_hsize;
-	br.read(pf_hsize);
-	CE_ASSERT(pf_hsize == DDPF_HEADERSIZE, "DDS bad pf header size");
-
-	uint32_t pf_flags;
-	br.read(pf_flags);
-
-	uint32_t pf_fourcc;
-	br.read(pf_fourcc);
-
-	uint32_t pf_bitcount;
-	br.read(pf_bitcount);
-
-	uint32_t pf_rmask;
-	br.read(pf_rmask);
-
-	uint32_t pf_gmask;
-	br.read(pf_gmask);
-
-	uint32_t pf_bmask;
-	br.read(pf_bmask);
-
-	uint32_t pf_amask;
-	br.read(pf_amask);
-
-	uint32_t caps;
-	br.read(caps);
-	CE_ASSERT((caps & DDSCAPS_TEXTURE), "DDS bad caps");
-
-	uint32_t caps2;
-	br.read(caps2);
-
-	uint32_t caps3;
-	br.read(caps3);
-
-	uint32_t caps4;
-	br.read(caps4);
-
-	uint32_t reserved2;
-	br.read(reserved2);
-
-	CE_LOGD("width = %u", width);
-	CE_LOGD("height = %u", height);
-	CE_LOGD("mips = %u", num_mips);
-	CE_LOGD("pitch = %u (valid = %s)", pitch, flags & DDSD_PITCH ? "yes" : "no");
-	CE_LOGD("pfflags = %.8x", pf_flags);
-
-	image.width = width;
-	image.height = height;
-	image.pitch = pitch;
-	image.num_mips = (flags & DDSD_MIPMAPCOUNT) ? num_mips : 1;
-	image.data = (char*) (uintptr_t) DDS_DATA_OFFSET;
-
-	const uint32_t raw_fmt = (pf_flags & DDPF_FOURCC) ? pf_fourcc : pf_flags;
-	switch (raw_fmt)
-	{
-		case DDPF_FOURCC_DXT1: image.format = PixelFormat::DXT1; break;
-		case DDPF_FOURCC_DXT3: image.format = PixelFormat::DXT3; break;
-		case DDPF_FOURCC_DXT5: image.format = PixelFormat::DXT5; break;
-		case DDS_RGB: image.format = PixelFormat::R8G8B8; break;
-		case DDS_RGBA: image.format = PixelFormat::R8G8B8A8; break;
-		default: image.format = PixelFormat::COUNT; break;
-	} 
-
-	CE_ASSERT(image.format != PixelFormat::COUNT, "DDS pixel format not supported");
-	CE_LOGD("PixelFormat = %u", image.format);
-}
-
-//-----------------------------------------------------------------------------
-void write_dds(BinaryWriter& bw, const ImageData& image)
-{
-	bw.write(DDSD_MAGIC);
-
-	// Header
-	bw.write(DDSD_HEADERSIZE); // dwSize
-	bw.write(DDS_HEADER_FLAGS_TEXTURE
-		| DDSD_MIPMAPCOUNT
-		| (pixel_format::is_compressed(image.format) ? DDSD_LINEARSIZE : DDSD_PITCH)
-		| (image.num_mips ? DDSD_MIPMAPCOUNT : 0)); // dwFlags
-	bw.write(image.height); // dwHeight
-	bw.write(image.width); // dwWidth
-
-	const uint32_t pitch = pixel_format::is_compressed(image.format) ? 0 // fixme
-							: (image.width * pixel_format::size(image.format) * 8 + 7) / 8;
-
-	bw.write(pitch); // dwPitchOrLinearSize
-	bw.write(DDSD_UNUSED); // dwDepth
-	bw.write(image.num_mips); // dwMipMapCount;
-
-	for (uint32_t i = 0; i < 11; i++)
-		bw.write(DDSD_UNUSED); // dwReserved1[11];
-
-	// Pixel format
-	bw.write(DDPF_HEADERSIZE); // dwSize;
-	uint32_t pf = 0;
-	switch (image.format)
-	{
-		case PixelFormat::DXT1:     pf = DDPF_FOURCC_DXT1; break;
-		case PixelFormat::DXT3:     pf = DDPF_FOURCC_DXT3; break;
-		case PixelFormat::DXT5:     pf = DDPF_FOURCC_DXT5; break;
-		case PixelFormat::R8G8B8:   pf = DDS_RGB; break;
-		case PixelFormat::R8G8B8A8: pf = DDS_RGBA; break;
-		default: CE_FATAL("Pixel format unknown"); break;
-	}
-	bw.write(pixel_format::is_compressed(image.format) ? DDPF_FOURCC : pf); // dwFlags;
-	bw.write(pixel_format::is_compressed(image.format) ? pf : DDSD_UNUSED); // dwFourCC;
-	bw.write(uint32_t(pixel_format::size(image.format) * 8)); // dwRGBBitCount;
-	bw.write(uint32_t(0x00FF0000)); // dwRBitMask;
-	bw.write(uint32_t(0x0000FF00)); // dwGBitMask;
-	bw.write(uint32_t(0x000000FF)); // dwBBitMask;
-	bw.write(uint32_t(0xFF000000)); // dwABitMask;
-
-	bw.write(DDSCAPS_TEXTURE
-		| (image.num_mips > 1 ? DDSCAPS_COMPLEX : DDSD_UNUSED) // also for cubemap, depth mipmap
-		| (image.num_mips > 1 ? DDSCAPS_MIPMAP : DDSD_UNUSED)); // dwCaps;
-	bw.write(DDSD_UNUSED); // dwCaps2;
-	bw.write(DDSD_UNUSED); // dwCaps3;
-	bw.write(DDSD_UNUSED); // dwCaps4;
-	bw.write(DDSD_UNUSED); // dwReserved2;
-
-	// Image data
-	for (uint32_t i = 0; i < image.num_mips; i++)
-	{
-		MipData mip;
-		read_mip_image(image, i, mip);
-
-		CE_LOGD("Writing mip: (%ux%u) byes = %u", mip.width, mip.height, mip.size);
-		bw.write(mip.data, mip.size);
-	}
-}
-
 //-----------------------------------------------------------------------------
 void compile(Filesystem& fs, const char* resource_path, File* out_file)
 {
-	File* in_file = fs.open(resource_path, FOM_READ);
-	JSONParser json(*in_file);
-	fs.close(in_file);
-
-	// Read source file
-	JSONElement root = json.root();
-	DynamicString name;
-	root.key("source").to_string(name);
-
-	File* source = fs.open(name.c_str(), FOM_READ);
-	BinaryReader br(*source);
-	ImageData image;
-
-	if (name.ends_with(".tga"))
-	{
-		parse_tga(br, image);
-	}
-	else if (name.ends_with(".dds"))
-	{
-		// parse_dds(br, image);
-		// size_t size = source->size();
-		// image.data = (char*) default_allocator().allocate(size);
-		// source->seek(0);
-		// source->read(image.data, size);
-		// image.data += DDS_DATA_OFFSET;
-
-		// BinaryWriter bw(*out_file);
-		// write_dds(bw, image);
-	}
-	else
-	{
-		CE_FATAL("Source image not supported");
-	}
-
-	fs.close(source);
-
-	BinaryWriter bw(*out_file);
-	
-	// Write texture header
-	bw.write(uint32_t(0x00000000));
-
-	// Write DDS
-	write_dds(bw, image);
 
-	default_allocator().deallocate(image.data);
 }
 
 } // namespace texture_resource

engine/resource/TextureResource.h

@@ -28,12 +28,10 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #include "Types.h"
 #include "Resource.h"
-#include "PixelFormat.h"
 #include "Bundle.h"
 #include "Allocator.h"
 #include "File.h"
 #include "Device.h"
-#include "Renderer.h"
 
 namespace crown
 {
@@ -126,7 +124,7 @@ struct DdsHeader
 
 struct TextureHeader
 {
-	TextureId id;
+	uint32_t id;
 };
 
 #define DDS_HEADER_OFFSET	uint32_t(sizeof(TextureHeader))
@@ -151,10 +149,10 @@ struct TextureResource
 	//-----------------------------------------------------------------------------
 	static void online(void* resource)
 	{
-		TextureResource* t = (TextureResource*) resource;
-		TextureHeader* h = (TextureHeader*) t;
+		// TextureResource* t = (TextureResource*) resource;
+		// TextureHeader* h = (TextureHeader*) t;
 
-		h->id = device()->renderer()->create_texture(t->width(), t->height(), t->num_mipmaps(), t->format(), t->data());
+		// h->id = device()->renderer()->create_texture(t->width(), t->height(), t->num_mipmaps(), t->format(), t->data());
 	}
 
 	//-----------------------------------------------------------------------------
@@ -168,26 +166,26 @@ struct TextureResource
 	//-----------------------------------------------------------------------------
 	static void offline(void* resource)
 	{
-		TextureResource* t = (TextureResource*) resource;
+		// TextureResource* t = (TextureResource*) resource;
 
-		device()->renderer()->destroy_texture(t->texture());
+		// device()->renderer()->destroy_texture(t->texture());
 	}
 
-	PixelFormat::Enum format() const
-	{
-		const DdsPixelFormat& ddspf = ((DdsHeader*) (((char*) this) + DDS_HEADER_OFFSET))->ddspf;
-
-		const uint32_t fmt = ddspf.flags & DDPF_FOURCC ? ddspf.fourcc : ddspf.flags;
-		switch (fmt)
-		{
-			case DDPF_FOURCC_DXT1: return PixelFormat::DXT1; break;
-			case DDPF_FOURCC_DXT3: return PixelFormat::DXT3; break;
-			case DDPF_FOURCC_DXT5: return PixelFormat::DXT5; break;
-			case DDS_RGB: return PixelFormat::R8G8B8; break;
-			case DDS_RGBA: return PixelFormat::R8G8B8A8; break;
-			default: CE_FATAL("Unknown pixel format"); return PixelFormat::COUNT;
-		}
-	}
+	// PixelFormat::Enum format() const
+	// {
+	// 	const DdsPixelFormat& ddspf = ((DdsHeader*) (((char*) this) + DDS_HEADER_OFFSET))->ddspf;
+
+	// 	const uint32_t fmt = ddspf.flags & DDPF_FOURCC ? ddspf.fourcc : ddspf.flags;
+	// 	switch (fmt)
+	// 	{
+	// 		case DDPF_FOURCC_DXT1: return PixelFormat::DXT1; break;
+	// 		case DDPF_FOURCC_DXT3: return PixelFormat::DXT3; break;
+	// 		case DDPF_FOURCC_DXT5: return PixelFormat::DXT5; break;
+	// 		case DDS_RGB: return PixelFormat::R8G8B8; break;
+	// 		case DDS_RGBA: return PixelFormat::R8G8B8A8; break;
+	// 		default: CE_FATAL("Unknown pixel format"); return PixelFormat::COUNT;
+	// 	}
+	// }
 
 	uint32_t width() const
 	{
@@ -209,10 +207,10 @@ struct TextureResource
 		return (char*) this + DDS_DATA_OFFSET;
 	}
 
-	TextureId texture() const
-	{
-		return ((TextureHeader*) this)->id;
-	}
+	// TextureId texture() const
+	// {
+	// 	return ((TextureHeader*) this)->id;
+	// }
 
 private: