Convert renderer-related enums to the new style

engine/RenderWorld.cpp

@@ -90,13 +90,13 @@ RenderWorld::RenderWorld()
 {
 	Renderer* r = device()->renderer();
 
-	default_vs = r->create_shader(SHADER_VERTEX, default_vertex);
-	default_fs = r->create_shader(SHADER_FRAGMENT, default_fragment);
-	texture_fs = r->create_shader(SHADER_FRAGMENT, texture_fragment);
+	default_vs = r->create_shader(ShaderType::VERTEX, default_vertex);
+	default_fs = r->create_shader(ShaderType::FRAGMENT, default_fragment);
+	texture_fs = r->create_shader(ShaderType::FRAGMENT, texture_fragment);
 
-	u_albedo_0 = r->create_uniform("u_albedo_0", UNIFORM_INTEGER_1, 1);
-	u_lightmap_0 = r->create_uniform("u_lightmap_0", UNIFORM_INTEGER_1, 1);
-	u_brightness = r->create_uniform("u_brightness", UNIFORM_FLOAT_1, 1);
+	u_albedo_0 = r->create_uniform("u_albedo_0", UniformType::INTEGER_1, 1);
+	u_lightmap_0 = r->create_uniform("u_lightmap_0", UniformType::INTEGER_1, 1);
+	u_brightness = r->create_uniform("u_brightness", UniformType::FLOAT_1, 1);
 
 	default_program = r->create_gpu_program(default_vs, default_fs);
 	texture_program = r->create_gpu_program(default_vs, texture_fs);

engine/compilers/mesh/MeshCompiler.cpp

@@ -173,7 +173,7 @@ void MeshCompiler::write_impl(File* out_file)
 {
 	MeshData data;
 	data.vertices.num_vertices = m_vertices.size();
-	data.vertices.format = VERTEX_P3_N3_T2;
+	data.vertices.format = VertexFormat::P3_N3_T2;
 	data.vertices.offset = sizeof(MeshHeader) + sizeof(MeshData);
 
 	data.indices.num_indices = m_indices.size();

engine/compilers/texture/TextureCompiler.cpp

@@ -76,7 +76,7 @@ size_t TextureCompiler::compile_impl(Filesystem& fs, const char* resource_path)
 		case 2:
 		case 3:
 		{
-			m_texture_header.format = PIXEL_RGB_8;
+			m_texture_header.format = PixelFormat::RGB_8;
 
 			m_texture_data_size = m_tga_size * 3;
 			m_texture_data = (uint8_t*)default_allocator().allocate(m_texture_data_size);
@@ -85,7 +85,7 @@ size_t TextureCompiler::compile_impl(Filesystem& fs, const char* resource_path)
 		}
 		case 4:
 		{
-			m_texture_header.format = PIXEL_RGBA_8;
+			m_texture_header.format = PixelFormat::RGBA_8;
 
 			m_texture_data_size = m_tga_size * m_tga_channels;
 			m_texture_data = (uint8_t*)default_allocator().allocate(m_texture_data_size);

engine/renderers/CommandBuffer.h

@@ -85,7 +85,7 @@ public:
 	//-----------------------------------------------------------------------------
 	void commit()
 	{
-		write(COMMAND_END);
+		write(CommandType::END);
 		m_size = 0;
 	}
 

engine/renderers/ConstantBuffer.h

@@ -32,7 +32,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 namespace crown
 {
 
-extern const size_t UNIFORM_SIZE_TABLE[UNIFORM_END];
+extern const size_t UNIFORM_SIZE_TABLE[UniformType::END];
 
 #define MAX_CONSTANT_BUFFER_SIZE 1024 * 1024
 
@@ -89,7 +89,7 @@ public:
 		m_size += size;		
 	}
 
-	void write_constant(UniformId id, UniformType type, void* data, uint8_t num)
+	void write_constant(UniformId id, UniformType::Enum type, void* data, uint8_t num)
 	{
 		size_t size = UNIFORM_SIZE_TABLE[type] * num;
 
@@ -101,7 +101,7 @@ public:
 
 	void commit()
 	{
-		write(UNIFORM_END);
+		write(UniformType::END);
 		m_size = 0;
 	}
 

engine/renderers/PixelFormat.h

@@ -37,28 +37,28 @@ class Pixel
 public:
 
 	/// Returns the bytes occupied by @a format
-	static size_t bytes_per_pixel(PixelFormat format)
+	static size_t bytes_per_pixel(PixelFormat::Enum format)
 	{
 		switch (format)
 		{
-			case PIXEL_RGB_8:
+			case PixelFormat::RGB_8:
 			{
 				return 3;
 			}
-			case PIXEL_RGBA_8:
+			case PixelFormat::RGBA_8:
 			{
 				return 4;
 			}
 			default:
 			{
-				CE_ASSERT(false, "Oops, unknown pixel format");
+				CE_FATAL("Oops, unknown pixel format");
 				return 0;
 			}
 		}
 	}
 
 	/// Returns the bits occupied by @a format
-	static size_t bits_per_pixel(PixelFormat format)
+	static size_t bits_per_pixel(PixelFormat::Enum format)
 	{
 		return bytes_per_pixel(format) * 8;
 	}

engine/renderers/RenderContext.h

@@ -208,7 +208,7 @@ struct RenderContext
 		m_state.ib = ib;
 	}
 
-	void set_uniform(UniformId id, UniformType type, void* value, uint8_t num)
+	void set_uniform(UniformId id, UniformType::Enum type, void* value, uint8_t num)
 	{
 		m_constants.write_constant(id, type, value, num);
 	}
@@ -221,7 +221,7 @@ struct RenderContext
 		sampler.sampler_id = texture;
 		sampler.flags |= SAMPLER_TEXTURE | flags;
 
-		set_uniform(sampler_uniform, UNIFORM_INTEGER_1, &unit, 1);
+		set_uniform(sampler_uniform, UniformType::INTEGER_1, &unit, 1);
 	}
 
 	void set_layer_render_target(uint8_t layer, RenderTargetId target)

engine/renderers/Renderer.h

@@ -38,7 +38,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 namespace crown
 {
 
-extern ShaderUniform name_to_stock_uniform(const char* uniform);
+extern ShaderUniform::Enum name_to_stock_uniform(const char* uniform);
 class RendererImplementation;
 
 class Renderer
@@ -52,8 +52,8 @@ public:
 	void shutdown_impl();
 	void render_impl();
 
-	void create_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat format, const void* vertices);
-	void create_dynamic_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat format);
+	void create_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat::Enum format, const void* vertices);
+	void create_dynamic_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat::Enum format);
 	void update_vertex_buffer_impl(VertexBufferId id, size_t offset, size_t count, const void* vertices);
 	void destroy_vertex_buffer_impl(VertexBufferId id);
 
@@ -62,21 +62,21 @@ public:
 	void update_index_buffer_impl(IndexBufferId id, size_t offset, size_t count, const void* indices);
 	void destroy_index_buffer_impl(IndexBufferId id);
 
-	void create_texture_impl(TextureId id, uint32_t width, uint32_t height, PixelFormat format, const void* data);
+	void create_texture_impl(TextureId id, uint32_t width, uint32_t height, PixelFormat::Enum format, const void* data);
 	void update_texture_impl(TextureId id, uint32_t x, uint32_t y, uint32_t width, uint32_t height, const void* data);
 	void destroy_texture_impl(TextureId id);
 
-	void create_shader_impl(ShaderId id, ShaderType type, const char* text);
+	void create_shader_impl(ShaderId id, ShaderType::Enum type, const char* text);
 	void destroy_shader_impl(ShaderId id);
 
 	void create_gpu_program_impl(GPUProgramId id, ShaderId vertex, ShaderId pixel);
 	void destroy_gpu_program_impl(GPUProgramId id);
 
-	void create_uniform_impl(UniformId id, const char* name, UniformType type, uint8_t num);
+	void create_uniform_impl(UniformId id, const char* name, UniformType::Enum type, uint8_t num);
 	void update_uniform_impl(UniformId id, size_t size, const void* data);
 	void destroy_uniform_impl(UniformId id);
 
-	void create_render_target_impl(RenderTargetId id, uint16_t width, uint16_t height, RenderTargetFormat format);
+	void create_render_target_impl(RenderTargetId id, uint16_t width, uint16_t height, RenderTargetFormat::Enum format);
 	void destroy_render_target_impl(RenderTargetId id);
 
 	inline void init()
@@ -84,7 +84,7 @@ public:
 		m_should_run = true;
 		m_thread.start(render_thread, this);
 
-		m_submit->m_commands.write(COMMAND_INIT_RENDERER);
+		m_submit->m_commands.write(CommandType::INIT_RENDERER);
 		frame();
 	}
 
@@ -92,7 +92,7 @@ public:
 	{
 		if (m_should_run)
 		{
-			m_submit->m_commands.write(COMMAND_SHUTDOWN_RENDERER);
+			m_submit->m_commands.write(CommandType::SHUTDOWN_RENDERER);
 			frame();
 
 			m_thread.stop();		
@@ -101,11 +101,11 @@ public:
 
 	/// Creates a new vertex buffer optimized for rendering static vertex data.
 	/// @a vertices is the array containig @a count vertex data elements of the given @a format.
-	inline VertexBufferId create_vertex_buffer(size_t count, VertexFormat format, const void* vertices)
+	inline VertexBufferId create_vertex_buffer(size_t count, VertexFormat::Enum format, const void* vertices)
 	{
 		const VertexBufferId id = m_vertex_buffers.create();
 
-		m_submit->m_commands.write(COMMAND_CREATE_VERTEX_BUFFER);
+		m_submit->m_commands.write(CommandType::CREATE_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(count);
 		m_submit->m_commands.write(format);
@@ -114,11 +114,11 @@ public:
 		return id;
 	}
 
-	inline VertexBufferId create_dynamic_vertex_buffer(size_t count, VertexFormat format)
+	inline VertexBufferId create_dynamic_vertex_buffer(size_t count, VertexFormat::Enum format)
 	{
 		const VertexBufferId id = m_vertex_buffers.create();
 
-		m_submit->m_commands.write(COMMAND_CREATE_DYNAMIC_VERTEX_BUFFER);
+		m_submit->m_commands.write(CommandType::CREATE_DYNAMIC_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(count);
 		m_submit->m_commands.write(format);
@@ -134,7 +134,7 @@ public:
 	/// at the creation of the buffer.
 	inline void update_vertex_buffer(VertexBufferId id, size_t offset, size_t count, const void* vertices)
 	{
-		m_submit->m_commands.write(COMMAND_UPDATE_VERTEX_BUFFER);
+		m_submit->m_commands.write(CommandType::UPDATE_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(offset);
 		m_submit->m_commands.write(count);
@@ -144,7 +144,7 @@ public:
 	/// Destroys the given vertex buffer @a id.
 	inline void destroy_vertex_buffer(VertexBufferId id)
 	{
-		m_submit->m_commands.write(COMMAND_DESTROY_VERTEX_BUFFER);
+		m_submit->m_commands.write(CommandType::DESTROY_VERTEX_BUFFER);
 		m_submit->m_commands.write(id);
 	}
 
@@ -154,7 +154,7 @@ public:
 	{
 		const IndexBufferId id = m_index_buffers.create();
 
-		m_submit->m_commands.write(COMMAND_CREATE_INDEX_BUFFER);
+		m_submit->m_commands.write(CommandType::CREATE_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(count);
 		m_submit->m_commands.write(indices);
@@ -166,7 +166,7 @@ public:
 	{
 		const IndexBufferId id = m_index_buffers.create();
 
-		m_submit->m_commands.write(COMMAND_CREATE_DYNAMIC_INDEX_BUFFER);
+		m_submit->m_commands.write(CommandType::CREATE_DYNAMIC_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(count);
 
@@ -175,7 +175,7 @@ public:
 
 	inline void update_index_buffer(IndexBufferId id, size_t offset, size_t count, const void* indices)
 	{
-		m_submit->m_commands.write(COMMAND_UPDATE_INDEX_BUFFER);
+		m_submit->m_commands.write(CommandType::UPDATE_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(offset);
 		m_submit->m_commands.write(count);
@@ -185,15 +185,15 @@ public:
 	/// Destroys the @a id index buffer.
 	inline void destroy_index_buffer(IndexBufferId id)
 	{
-		m_submit->m_commands.write(COMMAND_DESTROY_INDEX_BUFFER);
+		m_submit->m_commands.write(CommandType::DESTROY_INDEX_BUFFER);
 		m_submit->m_commands.write(id);
 	}
 
-	inline TextureId create_texture(uint32_t width, uint32_t height, PixelFormat format, const void* data)
+	inline TextureId create_texture(uint32_t width, uint32_t height, PixelFormat::Enum format, const void* data)
 	{
 		const TextureId id = m_textures.create();
 
-		m_submit->m_commands.write(COMMAND_CREATE_TEXTURE);
+		m_submit->m_commands.write(CommandType::CREATE_TEXTURE);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(width);
 		m_submit->m_commands.write(height);
@@ -205,7 +205,7 @@ public:
 
 	inline void update_texture(TextureId id, uint32_t x, uint32_t y, uint32_t width, uint32_t height, const void* data)
 	{
-		m_submit->m_commands.write(COMMAND_UPDATE_TEXTURE);
+		m_submit->m_commands.write(CommandType::UPDATE_TEXTURE);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(x);
 		m_submit->m_commands.write(y);
@@ -216,15 +216,15 @@ public:
 
 	inline void destroy_texture(TextureId id)
 	{
-		m_submit->m_commands.write(COMMAND_DESTROY_TEXTURE);
+		m_submit->m_commands.write(CommandType::DESTROY_TEXTURE);
 		m_submit->m_commands.write(id);
 	}
 
-	inline ShaderId create_shader(ShaderType type, const char* text)
+	inline ShaderId create_shader(ShaderType::Enum type, const char* text)
 	{
 		const ShaderId id = m_shaders.create();
 
-		m_submit->m_commands.write(COMMAND_CREATE_SHADER);
+		m_submit->m_commands.write(CommandType::CREATE_SHADER);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(type);
 		m_submit->m_commands.write(text);
@@ -234,7 +234,7 @@ public:
 
 	inline void destroy_shader(ShaderId id)
 	{
-		m_submit->m_commands.write(COMMAND_DESTROY_SHADER);
+		m_submit->m_commands.write(CommandType::DESTROY_SHADER);
 		m_submit->m_commands.write(id);
 	}
 
@@ -242,7 +242,7 @@ public:
 	{
 		const GPUProgramId id = m_gpu_programs.create();
 
-		m_submit->m_commands.write(COMMAND_CREATE_GPU_PROGRAM);
+		m_submit->m_commands.write(CommandType::CREATE_GPU_PROGRAM);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(vertex);
 		m_submit->m_commands.write(pixel);
@@ -252,20 +252,20 @@ public:
 
 	inline void destroy_gpu_program(GPUProgramId id)
 	{
-		m_submit->m_commands.write(COMMAND_DESTROY_GPU_PROGRAM);
+		m_submit->m_commands.write(CommandType::DESTROY_GPU_PROGRAM);
 		m_submit->m_commands.write(id);
 	}
 
-	inline UniformId create_uniform(const char* name, UniformType type, uint8_t num)
+	inline UniformId create_uniform(const char* name, UniformType::Enum type, uint8_t num)
 	{
-		CE_ASSERT(name_to_stock_uniform(name) == UNIFORM_COUNT, "Uniform name '%s' is a stock uniform.", name);
+		CE_ASSERT(name_to_stock_uniform(name) == ShaderUniform::COUNT, "Uniform name '%s' is a stock uniform.", name);
 
 		const UniformId id = m_uniforms.create();
 		size_t len = string::strlen(name);
 
 		CE_ASSERT(len < CROWN_MAX_UNIFORM_NAME_LENGTH, "Max uniform name length is %d", CROWN_MAX_UNIFORM_NAME_LENGTH);
 
-		m_submit->m_commands.write(COMMAND_CREATE_UNIFORM);
+		m_submit->m_commands.write(CommandType::CREATE_UNIFORM);
 		m_submit->m_commands.write(id);
 		m_submit->m_commands.write(len);
 		m_submit->m_commands.write(name, len);
@@ -277,12 +277,12 @@ public:
 
 	inline void destroy_uniform(UniformId id)
 	{
-		m_submit->m_commands.write(COMMAND_DESTROY_UNIFORM);
+		m_submit->m_commands.write(CommandType::DESTROY_UNIFORM);
 		m_submit->m_commands.write(id);
 	}
 
 	// 
-	// RenderTargetId create_render_target(uint16_t width, uint16_t height, RenderTargetFormat format)
+	// RenderTargetId create_render_target(uint16_t width, uint16_t height, RenderTargetFormat::Enum format)
 	// {
 
 	// }
@@ -298,29 +298,29 @@ public:
 
 		do
 		{
-			CommandType command;
+			CommandType::Enum command;
 			cmds.read(command);
 
 			switch (command)
 			{
-				case COMMAND_INIT_RENDERER:
+				case CommandType::INIT_RENDERER:
 				{
 					init_impl();
 					m_is_initialized = true;
 					break;
 				}
-				case COMMAND_SHUTDOWN_RENDERER:
+				case CommandType::SHUTDOWN_RENDERER:
 				{
 					shutdown_impl();
 					m_is_initialized = false;
 					m_should_run = false;
 					break;
 				}
-				case COMMAND_CREATE_VERTEX_BUFFER:
+				case CommandType::CREATE_VERTEX_BUFFER:
 				{
 					VertexBufferId id;
 					size_t count;
-					VertexFormat format;
+					VertexFormat::Enum format;
 					void* vertices;
 
 					cmds.read(id);
@@ -331,11 +331,11 @@ public:
 					create_vertex_buffer_impl(id, count, format, vertices);
 					break;
 				}
-				case COMMAND_CREATE_DYNAMIC_VERTEX_BUFFER:
+				case CommandType::CREATE_DYNAMIC_VERTEX_BUFFER:
 				{
 					VertexBufferId id;
 					size_t count;
-					VertexFormat format;
+					VertexFormat::Enum format;
 
 					cmds.read(id);
 					cmds.read(count);
@@ -344,7 +344,7 @@ public:
 					create_dynamic_vertex_buffer_impl(id, count, format);
 					break;
 				}
-				case COMMAND_UPDATE_VERTEX_BUFFER:
+				case CommandType::UPDATE_VERTEX_BUFFER:
 				{
 					VertexBufferId id;
 					size_t offset;
@@ -359,7 +359,7 @@ public:
 					update_vertex_buffer_impl(id, offset, count, vertices);			
 					break;
 				}
-				case COMMAND_DESTROY_VERTEX_BUFFER:
+				case CommandType::DESTROY_VERTEX_BUFFER:
 				{
 					VertexBufferId id;
 					cmds.read(id);
@@ -367,7 +367,7 @@ public:
 					destroy_vertex_buffer_impl(id);
 					break;
 				}
-				case COMMAND_CREATE_INDEX_BUFFER:
+				case CommandType::CREATE_INDEX_BUFFER:
 				{
 					IndexBufferId id;
 					size_t count;
@@ -380,7 +380,7 @@ public:
 					create_index_buffer_impl(id, count, indices);
 					break;
 				}
-				case COMMAND_CREATE_DYNAMIC_INDEX_BUFFER:
+				case CommandType::CREATE_DYNAMIC_INDEX_BUFFER:
 				{
 					IndexBufferId id;
 					size_t count;
@@ -391,7 +391,7 @@ public:
 					create_dynamic_index_buffer_impl(id, count);
 					break;
 				}
-				case COMMAND_UPDATE_INDEX_BUFFER:
+				case CommandType::UPDATE_INDEX_BUFFER:
 				{
 					IndexBufferId id;
 					size_t offset;
@@ -406,7 +406,7 @@ public:
 					update_index_buffer_impl(id, offset, count, indices);
 					break;
 				}
-				case COMMAND_DESTROY_INDEX_BUFFER:
+				case CommandType::DESTROY_INDEX_BUFFER:
 				{
 					IndexBufferId id;
 					cmds.read(id);
@@ -414,12 +414,12 @@ public:
 					destroy_index_buffer_impl(id);
 					break;
 				}
-				case COMMAND_CREATE_TEXTURE:
+				case CommandType::CREATE_TEXTURE:
 				{
 					TextureId id;
 					uint32_t width;
 					uint32_t height;
-					PixelFormat format;
+					PixelFormat::Enum format;
 					void* data;
 
 					cmds.read(id);
@@ -431,7 +431,7 @@ public:
 					create_texture_impl(id, width, height, format, data);
 					break;
 				}
-				case COMMAND_UPDATE_TEXTURE:
+				case CommandType::UPDATE_TEXTURE:
 				{
 					TextureId id;
 					uint32_t x;
@@ -450,7 +450,7 @@ public:
 					update_texture_impl(id, x, y, width, height, data);
 					break;
 				}
-				case COMMAND_DESTROY_TEXTURE:
+				case CommandType::DESTROY_TEXTURE:
 				{
 					TextureId id;
 					cmds.read(id);
@@ -458,10 +458,10 @@ public:
 					destroy_texture_impl(id);
 					break;
 				}
-				case COMMAND_CREATE_SHADER:
+				case CommandType::CREATE_SHADER:
 				{
 					ShaderId id;
-					ShaderType type;
+					ShaderType::Enum type;
 					char* text;
 
 					cmds.read(id);
@@ -471,7 +471,7 @@ public:
 					create_shader_impl(id, type, text);
 					break;
 				}
-				case COMMAND_DESTROY_SHADER:
+				case CommandType::DESTROY_SHADER:
 				{
 					ShaderId id;
 					cmds.read(id);
@@ -479,7 +479,7 @@ public:
 					destroy_shader_impl(id);
 					break;
 				}
-				case COMMAND_CREATE_GPU_PROGRAM:
+				case CommandType::CREATE_GPU_PROGRAM:
 				{
 					GPUProgramId id;
 					ShaderId vertex;
@@ -492,7 +492,7 @@ public:
 					create_gpu_program_impl(id, vertex, pixel);
 					break;
 				}
-				case COMMAND_DESTROY_GPU_PROGRAM:
+				case CommandType::DESTROY_GPU_PROGRAM:
 				{
 					GPUProgramId id;
 					cmds.read(id);
@@ -500,12 +500,12 @@ public:
 					destroy_gpu_program_impl(id);
 					break;
 				}
-				case COMMAND_CREATE_UNIFORM:
+				case CommandType::CREATE_UNIFORM:
 				{
 					UniformId id;
 					size_t len;
 					char name[CROWN_MAX_UNIFORM_NAME_LENGTH];
-					UniformType type;
+					UniformType::Enum type;
 					uint8_t num;
 
 					cmds.read(id);
@@ -519,7 +519,7 @@ public:
 
 					break;
 				}
-				case COMMAND_DESTROY_UNIFORM:
+				case CommandType::DESTROY_UNIFORM:
 				{
 					UniformId id;
 					cmds.read(id);
@@ -528,7 +528,7 @@ public:
 
 					break;
 				}
-				case COMMAND_END:
+				case CommandType::END:
 				{
 					end = true;
 					break;
@@ -547,9 +547,9 @@ public:
 
 	inline void update_uniforms(ConstantBuffer& cbuf)
 	{
-		UniformType type;
+		UniformType::Enum type;
 
-		while ((type = (UniformType)cbuf.read()) != UNIFORM_END)
+		while ((type = (UniformType::Enum)cbuf.read()) != UniformType::END)
 		{
 			UniformId id;
 			size_t size;
@@ -589,7 +589,7 @@ public:
 		m_submit->set_index_buffer(ib);
 	}
 
-	inline void set_uniform(UniformId id, UniformType type, void* value, uint8_t num)
+	inline void set_uniform(UniformId id, UniformType::Enum type, void* value, uint8_t num)
 	{
 		m_submit->set_uniform(id, type, value, num);
 	}
@@ -647,7 +647,7 @@ public:
 
 	inline void swap_contexts()
 	{
-		// Ensure COMMAND_END at the end of submit command buffer
+		// Ensure CommandType::END at the end of submit command buffer
 		m_submit->push();
 
 		RenderContext* temp = m_submit;

engine/renderers/RendererTypes.h

@@ -39,74 +39,92 @@ typedef Id ShaderId;
 typedef Id GPUProgramId;
 typedef Id UniformId;
 
-enum ShaderType
+struct ShaderType
 {
-	SHADER_VERTEX,
-	SHADER_FRAGMENT
+	enum Enum
+	{
+		VERTEX,
+		FRAGMENT
+	};
 };
 
-enum UniformType
+struct UniformType
 {
-	UNIFORM_INTEGER_1,
-	UNIFORM_INTEGER_2,
-	UNIFORM_INTEGER_3,
-	UNIFORM_INTEGER_4,
-	UNIFORM_FLOAT_1,
-	UNIFORM_FLOAT_2,
-	UNIFORM_FLOAT_3,
-	UNIFORM_FLOAT_4,
-	UNIFORM_FLOAT_3_X_3,
-	UNIFORM_FLOAT_4_X_4,
-	UNIFORM_END
+	enum Enum
+	{
+		INTEGER_1,
+		INTEGER_2,
+		INTEGER_3,
+		INTEGER_4,
+		FLOAT_1,
+		FLOAT_2,
+		FLOAT_3,
+		FLOAT_4,
+		FLOAT_3x3,
+		FLOAT_4x4,
+		END
+	};
 };
 
-enum RenderTargetFormat
+struct RenderTargetFormat
 {
-	RTF_RGB_8,		///< RGB values, 8-bit each
-	RTF_RGBA_8,		///< RGBA values, 8-bit each
-	RTF_D24			///< Depth
+	enum Enum
+	{
+		RTF_RGB_8,		///< RGB values, 8-bit each
+		RTF_RGBA_8,		///< RGBA values, 8-bit each
+		RTF_D24			///< Depth
+	};
 };
 
-enum ShaderUniform
+struct ShaderUniform
 {
-	UNIFORM_VIEW					= 0,
-	UNIFORM_MODEL					= 1,
-	UNIFORM_MODEL_VIEW				= 2,
-	UNIFORM_MODEL_VIEW_PROJECTION	= 3,
-	UNIFORM_TIME_SINCE_START		= 4,
-	UNIFORM_COUNT
+	enum Enum
+	{
+		VIEW					= 0,
+		MODEL					= 1,
+		MODEL_VIEW				= 2,
+		MODEL_VIEW_PROJECTION	= 3,
+		TIME_SINCE_START		= 4,
+		COUNT
+	};
 };
 
-enum ShaderAttrib
+struct ShaderAttrib
 {
-	ATTRIB_POSITION			= 0,
-	ATTRIB_NORMAL			= 1,
-	ATTRIB_COLOR			= 2,
-	ATTRIB_TEX_COORD0		= 3,
-	ATTRIB_TEX_COORD1		= 4,
-	ATTRIB_TEX_COORD2		= 5,
-	ATTRIB_TEX_COORD3		= 6,
-	ATTRIB_COUNT
+	enum Enum
+	{
+		POSITION		= 0,
+		NORMAL			= 1,
+		COLOR			= 2,
+		TEX_COORD0		= 3,
+		TEX_COORD1		= 4,
+		TEX_COORD2		= 5,
+		TEX_COORD3		= 6,
+		COUNT
+	};
 };
 
-enum VertexFormat
+struct VertexFormat
 {
-	VERTEX_P2 = 0,
-	VERTEX_P2_N3,
-	VERTEX_P2_C4,
-	VERTEX_P2_T2,
-	VERTEX_P2_N3_C4,
-	VERTEX_P2_N3_C4_T2,
-
-	VERTEX_P3,
-	VERTEX_P3_N3,
-	VERTEX_P3_C4,
-	VERTEX_P3_T2,
-	VERTEX_P3_N3_C4,
-	VERTEX_P3_N3_T2,
-	VERTEX_P3_N3_C4_T2,
-
-	VERTEX_COUNT
+	enum Enum
+	{
+		P2 = 0,
+		P2_N3,
+		P2_C4,
+		P2_T2,
+		P2_N3_C4,
+		P2_N3_C4_T2,
+
+		P3,
+		P3_N3,
+		P3_C4,
+		P3_T2,
+		P3_N3_C4,
+		P3_N3_T2,
+		P3_N3_C4_T2,
+
+		COUNT
+	};
 };
 
 // [0 - 2]		-> 8-bit
@@ -119,43 +137,48 @@ enum VertexFormat
 // [36 - 39]	-> 128-bit
 // 40			-> Unknown (0-bit)
 /// Enumerates pixel formats.
-enum PixelFormat
+struct PixelFormat
 {
-	PIXEL_RGB_8 = 0,
-	PIXEL_RGBA_8,
-
-	PIXEL_COUNT
+	enum Enum
+	{
+		RGB_8 = 0,
+		RGBA_8,
+		COUNT
+	};
 };
 
-enum CommandType
+struct CommandType
 {
-	COMMAND_INIT_RENDERER,
-	COMMAND_SHUTDOWN_RENDERER,
+	enum Enum
+	{
+		INIT_RENDERER,
+		SHUTDOWN_RENDERER,
 
-	COMMAND_CREATE_VERTEX_BUFFER,
-	COMMAND_CREATE_DYNAMIC_VERTEX_BUFFER,
-	COMMAND_UPDATE_VERTEX_BUFFER,
-	COMMAND_DESTROY_VERTEX_BUFFER,
+		CREATE_VERTEX_BUFFER,
+		CREATE_DYNAMIC_VERTEX_BUFFER,
+		UPDATE_VERTEX_BUFFER,
+		DESTROY_VERTEX_BUFFER,
 
-	COMMAND_CREATE_INDEX_BUFFER,
-	COMMAND_CREATE_DYNAMIC_INDEX_BUFFER,
-	COMMAND_UPDATE_INDEX_BUFFER,
-	COMMAND_DESTROY_INDEX_BUFFER,
+		CREATE_INDEX_BUFFER,
+		CREATE_DYNAMIC_INDEX_BUFFER,
+		UPDATE_INDEX_BUFFER,
+		DESTROY_INDEX_BUFFER,
 
-	COMMAND_CREATE_TEXTURE,
-	COMMAND_UPDATE_TEXTURE,
-	COMMAND_DESTROY_TEXTURE,
+		CREATE_TEXTURE,
+		UPDATE_TEXTURE,
+		DESTROY_TEXTURE,
 
-	COMMAND_CREATE_SHADER,
-	COMMAND_DESTROY_SHADER,
+		CREATE_SHADER,
+		DESTROY_SHADER,
 
-	COMMAND_CREATE_GPU_PROGRAM,
-	COMMAND_DESTROY_GPU_PROGRAM,
+		CREATE_GPU_PROGRAM,
+		DESTROY_GPU_PROGRAM,
 
-	COMMAND_CREATE_UNIFORM,
-	COMMAND_DESTROY_UNIFORM,
+		CREATE_UNIFORM,
+		DESTROY_UNIFORM,
 
-	COMMAND_END
+		END
+	};
 };
 
 } // namespace crown

engine/renderers/VertexFormat.h

@@ -33,22 +33,22 @@ namespace crown
 
 struct VertexFormatInfo
 {
-	bool has_attrib(ShaderAttrib attrib) const
+	bool has_attrib(ShaderAttrib::Enum attrib) const
 	{
 		return sizes[attrib] != 0;
 	}
 
 	/// Returns the number of components per @a attrib
-	size_t num_components(ShaderAttrib attrib) const
+	size_t num_components(ShaderAttrib::Enum attrib) const
 	{
 		return (size_t) sizes[attrib];
 	}
 
 	/// Returns the byte offset between consecutive vertex @a attrib
-	size_t attrib_stride(ShaderAttrib /*attrib*/) const
+	size_t attrib_stride(ShaderAttrib::Enum /*attrib*/) const
 	{
 		size_t stride = 0;
-		for (uint8_t i = 0; i < ATTRIB_COUNT; i++)
+		for (uint8_t i = 0; i < ShaderAttrib::COUNT; i++)
 		{
 			stride += sizes[i];
 		}
@@ -57,7 +57,7 @@ struct VertexFormatInfo
 	}
 
 	/// Returns the byte offset of the first @a attrib in the format
-	size_t attrib_offset(ShaderAttrib attrib) const
+	size_t attrib_offset(ShaderAttrib::Enum attrib) const
 	{
 		size_t offset = 0;
 		for (uint8_t i = 0; i < attrib; i++)
@@ -70,11 +70,11 @@ struct VertexFormatInfo
 
 public:
 
-	uint8_t sizes[ATTRIB_COUNT];
+	uint8_t sizes[ShaderAttrib::COUNT];
 };
 
 // VertexFormat to VertexFormatInfo
-const VertexFormatInfo VERTEX_FORMAT_INFO[VERTEX_COUNT] =
+const VertexFormatInfo VERTEX_FORMAT_INFO[VertexFormat::COUNT] =
 {
 	{ 2, 0, 0, 0, 0, 0, 0 },
 	{ 2, 3, 0, 0, 0, 0, 0 },
@@ -97,12 +97,12 @@ class Vertex
 public:
 
 	/// Returns the bytes occupied by @a format
-	static size_t bytes_per_vertex(VertexFormat format)
+	static size_t bytes_per_vertex(VertexFormat::Enum format)
 	{
 		const VertexFormatInfo& info = VERTEX_FORMAT_INFO[format];
 		
 		size_t size = 0;
-		for (uint8_t i = 0; i < ATTRIB_COUNT; i++)
+		for (uint8_t i = 0; i < ShaderAttrib::COUNT; i++)
 		{
 			size += info.sizes[i];
 		}
@@ -112,12 +112,12 @@ public:
 	}
 
 	/// Returns the bits occupied by @a format
-	static size_t bits_per_vertex(VertexFormat format)
+	static size_t bits_per_vertex(VertexFormat::Enum format)
 	{
 		return bytes_per_vertex(format) * 8;
 	}
 
-	static const VertexFormatInfo& info(VertexFormat format)
+	static const VertexFormatInfo& info(VertexFormat::Enum format)
 	{
 		return VERTEX_FORMAT_INFO[format];
 	}

engine/renderers/gl/GLRenderer.cpp

@@ -87,14 +87,14 @@ const GLenum TEXTURE_WRAP_TABLE[] =
 };
 
 //-----------------------------------------------------------------------------
-const GLTextureFormatInfo TEXTURE_FORMAT_TABLE[PIXEL_COUNT] =
+const GLTextureFormatInfo TEXTURE_FORMAT_TABLE[PixelFormat::COUNT] =
 {
 	{ GL_RGB, GL_RGB },
 	{ GL_RGBA, GL_RGBA}
 };
 
 // Keep in sync with ShaderAttrib
-const char* const SHADER_ATTRIB_NAMES[ATTRIB_COUNT] =
+const char* const SHADER_ATTRIB_NAMES[ShaderAttrib::COUNT] =
 {
 	"a_position",
 	"a_normal",
@@ -105,7 +105,7 @@ const char* const SHADER_ATTRIB_NAMES[ATTRIB_COUNT] =
 	"a_tex_coord3"
 };
 
-const char* const SHADER_UNIFORM_NAMES[] =
+const char* const SHADER_UNIFORM_NAMES[ShaderUniform::COUNT] =
 {
 	"u_view",
 	"u_model",
@@ -114,7 +114,7 @@ const char* const SHADER_UNIFORM_NAMES[] =
 	"u_time_since_start"
 };
 
-const size_t UNIFORM_SIZE_TABLE[UNIFORM_END] =
+const size_t UNIFORM_SIZE_TABLE[UniformType::END] =
 {
 	sizeof(int32_t) * 1,
 	sizeof(int32_t) * 2,
@@ -128,17 +128,17 @@ const size_t UNIFORM_SIZE_TABLE[UNIFORM_END] =
 	sizeof(float) * 16
 };
 
-ShaderUniform name_to_stock_uniform(const char* uniform)
+ShaderUniform::Enum name_to_stock_uniform(const char* uniform)
 {
-	for (uint8_t i = 0; i < UNIFORM_COUNT; i++)
+	for (uint8_t i = 0; i < ShaderUniform::COUNT; i++)
 	{
 		if (string::strcmp(uniform, SHADER_UNIFORM_NAMES[i]) == 0)
 		{
-			return (ShaderUniform) i;
+			return (ShaderUniform::Enum) i;
 		}
 	}
 
-	return UNIFORM_COUNT;
+	return ShaderUniform::COUNT;
 }
 
 /// OpenGL renderer
@@ -314,29 +314,29 @@ public:
 
 					switch (gpu_program.m_stock_uniforms[uniform])
 					{
-						case UNIFORM_VIEW:
+						case ShaderUniform::VIEW:
 						{
 							GL_CHECK(glUniformMatrix4fv(uniform_location, 1, GL_FALSE, view.to_float_ptr()));
 							break;
 						}
-						case UNIFORM_MODEL:
+						case ShaderUniform::MODEL:
 						{
 							GL_CHECK(glUniformMatrix4fv(uniform_location, 1, GL_FALSE, cur_state.pose.to_float_ptr()));
 							break;
 						}
-						case UNIFORM_MODEL_VIEW:
+						case ShaderUniform::MODEL_VIEW:
 						{
 							GL_CHECK(glUniformMatrix4fv(uniform_location, 1, GL_FALSE, (view *
 															cur_state.pose).to_float_ptr()));
 							break;
 						}
-						case UNIFORM_MODEL_VIEW_PROJECTION:
+						case ShaderUniform::MODEL_VIEW_PROJECTION:
 						{
 							GL_CHECK(glUniformMatrix4fv(uniform_location, 1, GL_FALSE, (projection * view *
 															cur_state.pose).to_float_ptr()));
 							break;
 						}
-						case UNIFORM_TIME_SINCE_START:
+						case ShaderUniform::TIME_SINCE_START:
 						{
 							GL_CHECK(glUniform1f(uniform_location, device()->time_since_start()));
 							break;
@@ -480,13 +480,13 @@ void Renderer::render_impl()
 }
 
 //-----------------------------------------------------------------------------
-void Renderer::create_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat format, const void* vertices)
+void Renderer::create_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat::Enum format, const void* vertices)
 {
 	m_impl->m_vertex_buffers[id.index].create(count, format, vertices);
 }
 
 //-----------------------------------------------------------------------------
-void Renderer::create_dynamic_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat format)
+void Renderer::create_dynamic_vertex_buffer_impl(VertexBufferId id, size_t count, VertexFormat::Enum format)
 {
 	m_impl->m_vertex_buffers[id.index].create(count, format, NULL);
 }
@@ -528,7 +528,7 @@ void Renderer::destroy_index_buffer_impl(IndexBufferId id)
 }
 
 //-----------------------------------------------------------------------------
-void Renderer::create_texture_impl(TextureId id, uint32_t width, uint32_t height, PixelFormat format, const void* data)
+void Renderer::create_texture_impl(TextureId id, uint32_t width, uint32_t height, PixelFormat::Enum format, const void* data)
 {
 	m_impl->m_textures[id.index].create(width, height, format, data);
 }
@@ -546,7 +546,7 @@ void Renderer::destroy_texture_impl(TextureId id)
 }
 
 //-----------------------------------------------------------------------------
-void Renderer::create_shader_impl(ShaderId id, ShaderType type, const char* text)
+void Renderer::create_shader_impl(ShaderId id, ShaderType::Enum type, const char* text)
 {
 	m_impl->m_shaders[id.index].create(type, text);
 }
@@ -572,7 +572,7 @@ void Renderer::destroy_gpu_program_impl(GPUProgramId id)
 }
 
 //-----------------------------------------------------------------------------
-void Renderer::create_uniform_impl(UniformId id, const char* name, UniformType type, uint8_t num)
+void Renderer::create_uniform_impl(UniformId id, const char* name, UniformType::Enum type, uint8_t num)
 {
 	m_impl->m_uniforms[id.index].create(name, type, num);
 	m_impl->m_num_uniforms++;
@@ -592,7 +592,7 @@ void Renderer::destroy_uniform_impl(UniformId id)
 }
 
 // //-----------------------------------------------------------------------------
-// void Renderer::create_render_target_impl(RenderTargetId id, uint16_t width, uint16_t height, RenderTargetFormat format)
+// void Renderer::create_render_target_impl(RenderTargetId id, uint16_t width, uint16_t height, RenderTargetFormat::Enum format)
 // {
 
 // }

engine/renderers/gl/GLRenderer.h

@@ -57,11 +57,11 @@ struct GLTextureFormatInfo
 extern const GLenum TEXTURE_MIN_FILTER_TABLE[];
 extern const GLenum TEXTURE_MAG_FILTER_TABLE[];
 extern const GLenum TEXTURE_WRAP_TABLE[];
-extern const GLTextureFormatInfo TEXTURE_FORMAT_TABLE[PIXEL_COUNT];
-extern const char* const SHADER_ATTRIB_NAMES[ATTRIB_COUNT];
-extern const char* const SHADER_UNIFORM_NAMES[];
-extern const size_t UNIFORM_SIZE_TABLE[UNIFORM_END];
-extern ShaderUniform name_to_stock_uniform(const char* uniform);
+extern const GLTextureFormatInfo TEXTURE_FORMAT_TABLE[PixelFormat::COUNT];
+extern const char* const SHADER_ATTRIB_NAMES[ShaderAttrib::COUNT];
+extern const char* const SHADER_UNIFORM_NAMES[ShaderUniform::COUNT];
+extern const size_t UNIFORM_SIZE_TABLE[UniformType::END];
+extern ShaderUniform::Enum name_to_stock_uniform(const char* uniform);
 
 //-----------------------------------------------------------------------------
 static const char* gl_error_to_string(GLenum error)
@@ -91,7 +91,7 @@ static const char* gl_error_to_string(GLenum error)
 struct VertexBuffer
 {
 	//-----------------------------------------------------------------------------
-	void create(size_t count, VertexFormat format, const void* vertices)
+	void create(size_t count, VertexFormat::Enum format, const void* vertices)
 	{
 		GL_CHECK(glGenBuffers(1, &m_id));
 		GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, m_id));
@@ -123,7 +123,7 @@ public:
 
 	GLuint			m_id;
 	size_t			m_count;
-	VertexFormat	m_format;
+	VertexFormat::Enum	m_format;
 };
 
 //-----------------------------------------------------------------------------
@@ -171,7 +171,7 @@ struct Uniform
 		string::strncpy(m_name, "", CROWN_MAX_UNIFORM_NAME_LENGTH);
 	}
 
-	void create(const char* name, UniformType type, uint8_t num)
+	void create(const char* name, UniformType::Enum type, uint8_t num)
 	{
 		string::strncpy(m_name, name, CROWN_MAX_UNIFORM_NAME_LENGTH);
 		m_type = type;
@@ -198,7 +198,7 @@ struct Uniform
 public:
 
 	char m_name[CROWN_MAX_UNIFORM_NAME_LENGTH];
-	UniformType m_type;
+	UniformType::Enum m_type;
 	uint8_t m_num;
 	void* m_data;
 };
@@ -207,9 +207,9 @@ public:
 struct Shader
 {
 	//-----------------------------------------------------------------------------
-	void create(ShaderType type, const char* text)
+	void create(ShaderType::Enum type, const char* text)
 	{
-		m_id = GL_CHECK(glCreateShader(type == SHADER_VERTEX ? GL_VERTEX_SHADER : GL_FRAGMENT_SHADER));
+		m_id = GL_CHECK(glCreateShader(type == ShaderType::VERTEX ? GL_VERTEX_SHADER : GL_FRAGMENT_SHADER));
 
 		GL_CHECK(glShaderSource(m_id, 1, &text, NULL));
 		GL_CHECK(glCompileShader(m_id));
@@ -240,7 +240,7 @@ public:
 struct Texture
 {
 	//-----------------------------------------------------------------------------
-	void create(uint32_t width, uint32_t height, PixelFormat format, const void* data)
+	void create(uint32_t width, uint32_t height, PixelFormat::Enum format, const void* data)
 	{
 		GL_CHECK(glGenTextures(1, &m_id));
 		GL_CHECK(glBindTexture(GL_TEXTURE_2D, m_id));
@@ -302,11 +302,11 @@ struct Texture
 
 public:
 
-	GLuint			m_id;
-	GLenum			m_target;      // Always GL_TEXTURE_2D
-	uint32_t		m_width;
-	uint32_t		m_height;
-	PixelFormat		m_format;
+	GLuint				m_id;
+	GLenum				m_target;      // Always GL_TEXTURE_2D
+	uint32_t			m_width;
+	uint32_t			m_height;
+	PixelFormat::Enum	m_format;
 };
 
 //-----------------------------------------------------------------------------
@@ -367,12 +367,12 @@ struct GPUProgram
 		}
 
 		m_num_active_attribs = 0;
-		for (uint32_t attrib = 0; attrib < ATTRIB_COUNT; attrib++)
+		for (uint32_t attrib = 0; attrib < ShaderAttrib::COUNT; attrib++)
 		{
 			GLint loc = GL_CHECK(glGetAttribLocation(m_id, SHADER_ATTRIB_NAMES[attrib]));
 			if (loc != -1)
 			{
-				m_active_attribs[m_num_active_attribs] = (ShaderAttrib) attrib;
+				m_active_attribs[m_num_active_attribs] = (ShaderAttrib::Enum) attrib;
 				m_num_active_attribs++;
 				m_attrib_locations[attrib] = loc;
 			}
@@ -388,8 +388,8 @@ struct GPUProgram
 			GL_CHECK(glGetActiveUniform(m_id, uniform, max_uniform_length, NULL, &uniform_size, &uniform_type, uniform_name));
 			GLint uniform_location = GL_CHECK(glGetUniformLocation(m_id, uniform_name));
 
-			ShaderUniform stock_uniform = name_to_stock_uniform(uniform_name);
-			if (stock_uniform != UNIFORM_COUNT)
+			ShaderUniform::Enum stock_uniform = name_to_stock_uniform(uniform_name);
+			if (stock_uniform != ShaderUniform::COUNT)
 			{
 				m_stock_uniforms[m_num_stock_uniforms] = stock_uniform;
 				m_stock_uniform_locations[m_num_stock_uniforms] = uniform_location;
@@ -410,7 +410,7 @@ struct GPUProgram
 			}
 
 			Log::d("Uniform %d: name = '%s' location = '%d' stock = %s", uniform, uniform_name, uniform_location,
-						(stock_uniform != UNIFORM_COUNT) ? "yes" : "no");
+						(stock_uniform != ShaderUniform::COUNT) ? "yes" : "no");
 		}
 	}
 
@@ -422,12 +422,12 @@ struct GPUProgram
 	}
 
 	//-----------------------------------------------------------------------------
-	void bind_attributes(VertexFormat format) const
+	void bind_attributes(VertexFormat::Enum format) const
 	{
 		// Bind all active attributes
 		for (uint8_t i = 0; i < m_num_active_attribs; i++)
 		{
-			ShaderAttrib attrib = m_active_attribs[i];
+			ShaderAttrib::Enum attrib = m_active_attribs[i];
 			GLint loc = m_attrib_locations[attrib];
 
 			const VertexFormatInfo& info = Vertex::info(format);
@@ -446,23 +446,23 @@ struct GPUProgram
 	{
 		for (uint8_t i = 0; i < m_num_uniforms; i++)
 		{
-			const UniformType type = m_uniforms[i];
+			const UniformType::Enum type = m_uniforms[i];
 			const GLint loc = m_uniform_info[i].loc;
 			const void* data = m_uniform_info[i].data;
 
 			switch (type)
 			{
-				case UNIFORM_INTEGER_1:   GL_CHECK(glUniform1iv(loc, 1, (const GLint*)data)); break;
-				case UNIFORM_INTEGER_2:   GL_CHECK(glUniform2iv(loc, 2, (const GLint*)data)); break;
-				case UNIFORM_INTEGER_3:   GL_CHECK(glUniform3iv(loc, 3, (const GLint*)data)); break;				
-				case UNIFORM_INTEGER_4:   GL_CHECK(glUniform4iv(loc, 4, (const GLint*)data)); break;
-				case UNIFORM_FLOAT_1:     GL_CHECK(glUniform1fv(loc, 1, (const GLfloat*)data)); break;
-				case UNIFORM_FLOAT_2:     GL_CHECK(glUniform2fv(loc, 2, (const GLfloat*)data)); break;
-				case UNIFORM_FLOAT_3:     GL_CHECK(glUniform3fv(loc, 3, (const GLfloat*)data)); break;
-				case UNIFORM_FLOAT_4:     GL_CHECK(glUniform4fv(loc, 4, (const GLfloat*)data)); break;
-				case UNIFORM_FLOAT_3_X_3: GL_CHECK(glUniformMatrix3fv(loc, 9, GL_FALSE, (const GLfloat*)data)); break;
-				case UNIFORM_FLOAT_4_X_4: GL_CHECK(glUniformMatrix4fv(loc, 16, GL_FALSE, (const GLfloat*)data)); break;
-				default: CE_ASSERT(false, "Oops, unknown uniform type"); break;
+				case UniformType::INTEGER_1:   GL_CHECK(glUniform1iv(loc, 1, (const GLint*)data)); break;
+				case UniformType::INTEGER_2:   GL_CHECK(glUniform2iv(loc, 2, (const GLint*)data)); break;
+				case UniformType::INTEGER_3:   GL_CHECK(glUniform3iv(loc, 3, (const GLint*)data)); break;				
+				case UniformType::INTEGER_4:   GL_CHECK(glUniform4iv(loc, 4, (const GLint*)data)); break;
+				case UniformType::FLOAT_1:     GL_CHECK(glUniform1fv(loc, 1, (const GLfloat*)data)); break;
+				case UniformType::FLOAT_2:     GL_CHECK(glUniform2fv(loc, 2, (const GLfloat*)data)); break;
+				case UniformType::FLOAT_3:     GL_CHECK(glUniform3fv(loc, 3, (const GLfloat*)data)); break;
+				case UniformType::FLOAT_4:     GL_CHECK(glUniform4fv(loc, 4, (const GLfloat*)data)); break;
+				case UniformType::FLOAT_3x3:   GL_CHECK(glUniformMatrix3fv(loc, 9, GL_FALSE, (const GLfloat*)data)); break;
+				case UniformType::FLOAT_4x4:   GL_CHECK(glUniformMatrix4fv(loc, 16, GL_FALSE, (const GLfloat*)data)); break;
+				default: CE_FATAL("Oops, unknown uniform type"); break;
 			}
 		}
 	}
@@ -472,12 +472,12 @@ public:
 	GLuint				m_id;
 
 	uint8_t				m_num_active_attribs;
-	ShaderAttrib		m_active_attribs[ATTRIB_COUNT];
-	GLint				m_attrib_locations[ATTRIB_COUNT];
+	ShaderAttrib::Enum	m_active_attribs[ShaderAttrib::COUNT];
+	GLint				m_attrib_locations[ShaderAttrib::COUNT];
 
 	uint8_t				m_num_stock_uniforms;
-	ShaderUniform		m_stock_uniforms[UNIFORM_COUNT];
-	GLint				m_stock_uniform_locations[UNIFORM_COUNT];
+	ShaderUniform::Enum	m_stock_uniforms[ShaderUniform::COUNT];
+	GLint				m_stock_uniform_locations[ShaderUniform::COUNT];
 
 	struct LocAndData
 	{
@@ -486,7 +486,7 @@ public:
 	};
 
 	uint8_t				m_num_uniforms;
-	UniformType			m_uniforms[16];
+	UniformType::Enum	m_uniforms[16];
 	LocAndData			m_uniform_info[16];
 };
 

engine/resource/MeshResource.h

@@ -43,29 +43,29 @@ const uint32_t MESH_VERSION = 1;
 
 struct MeshHeader
 {
-	uint32_t		version;
-	uint32_t		num_meshes;
-	uint32_t		num_joints;
-	uint32_t		padding[16];
+	uint32_t			version;
+	uint32_t			num_meshes;
+	uint32_t			num_joints;
+	uint32_t			padding[16];
 };
 
 struct VertexData
 {
-	uint32_t	    num_vertices;
-	VertexFormat	format;
-	uint32_t		offset;
+	uint32_t	    	num_vertices;
+	VertexFormat::Enum	format;
+	uint32_t			offset;
 };
 
 struct IndexData
 {
-	uint32_t		num_indices;
-	uint32_t		offset;
+	uint32_t			num_indices;
+	uint32_t			offset;
 };
 
 struct MeshData
 {
-	VertexData		vertices;
-	IndexData		indices;
+	VertexData			vertices;
+	IndexData			indices;
 };
 
 class MeshResource
@@ -121,7 +121,7 @@ public:
 	}
 
 	//-----------------------------------------------------------------------------
-	VertexFormat vertex_format()
+	VertexFormat::Enum vertex_format()
 	{
 		MeshData* data = (MeshData*) (m_data + sizeof(MeshHeader));
 		return data->vertices.format;

engine/resource/TextureResource.h

@@ -100,9 +100,9 @@ public:
 
 public:
 
-	PixelFormat format() const
+	PixelFormat::Enum format() const
 	{
-		return (PixelFormat) m_header.format;
+		return (PixelFormat::Enum) m_header.format;
 	}
 
 	uint32_t width() const