Cleanup.

examples/common/bgfx_utils.cpp

@@ -356,8 +356,6 @@ void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexLayout _la
 	delete [] tangents;
 }
 
-
-
 Group::Group()
 {
 	reset();
@@ -381,88 +379,91 @@ namespace bgfx
 
 void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 {
-#define BGFX_CHUNK_MAGIC_VB  BX_MAKEFOURCC('V', 'B', ' ', 0x1)
-#define BGFX_CHUNK_MAGIC_VBC BX_MAKEFOURCC('V', 'B', 'C', 0x0)
-#define BGFX_CHUNK_MAGIC_IB  BX_MAKEFOURCC('I', 'B', ' ', 0x0)
-#define BGFX_CHUNK_MAGIC_IBC BX_MAKEFOURCC('I', 'B', 'C', 0x1)
-#define BGFX_CHUNK_MAGIC_PRI BX_MAKEFOURCC('P', 'R', 'I', 0x0)
+	constexpr uint32_t kChunkVertexBuffer           = BX_MAKEFOURCC('V', 'B', ' ', 0x1);
+	constexpr uint32_t kChunkVertexBufferCompressed = BX_MAKEFOURCC('V', 'B', 'C', 0x0);
+	constexpr uint32_t kChunkIndexBuffer            = BX_MAKEFOURCC('I', 'B', ' ', 0x0);
+	constexpr uint32_t kChunkIndexBufferCompressed  = BX_MAKEFOURCC('I', 'B', 'C', 0x1);
+	constexpr uint32_t kChunkPrimitive              = BX_MAKEFOURCC('P', 'R', 'I', 0x0);
 
 	using namespace bx;
 	using namespace bgfx;
-	
+
 	Group group;
-	
+
 	bx::AllocatorI* allocator = entry::getAllocator();
-	
+
 	uint32_t chunk;
 	bx::Error err;
 	while (4 == bx::read(_reader, chunk, &err)
-		   &&     err.isOk() )
+	   &&  err.isOk() )
 	{
 		switch (chunk)
 		{
-			case BGFX_CHUNK_MAGIC_VB:
+			case kChunkVertexBuffer:
 			{
 				read(_reader, group.m_sphere);
 				read(_reader, group.m_aabb);
 				read(_reader, group.m_obb);
-				
+
 				read(_reader, m_layout);
-				
+
 				uint16_t stride = m_layout.getStride();
-				
+
 				read(_reader, group.m_numVertices);
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride);
 				read(_reader, mem->data, mem->size);
-				if ( _ramcopy )
+
+				if (_ramcopy)
 				{
 					group.m_vertices = (uint8_t*)BX_ALLOC(allocator, group.m_numVertices*stride);
 					bx::memCopy(group.m_vertices, mem->data, mem->size);
 				}
+
 				group.m_vbh = bgfx::createVertexBuffer(mem, m_layout);
 			}
 				break;
-				
-			case BGFX_CHUNK_MAGIC_VBC:
+
+			case kChunkVertexBufferCompressed:
 			{
 				read(_reader, group.m_sphere);
 				read(_reader, group.m_aabb);
 				read(_reader, group.m_obb);
-				
+
 				read(_reader, m_layout);
-				
+
 				uint16_t stride = m_layout.getStride();
-				
+
 				read(_reader, group.m_numVertices);
-				
+
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride);
-				
+
 				uint32_t compressedSize;
 				bx::read(_reader, compressedSize);
-				
+
 				void* compressedVertices = BX_ALLOC(allocator, compressedSize);
 				bx::read(_reader, compressedVertices, compressedSize);
-				
+
 				meshopt_decodeVertexBuffer(mem->data, group.m_numVertices, stride, (uint8_t*)compressedVertices, compressedSize);
-				
+
 				BX_FREE(allocator, compressedVertices);
 
-				if ( _ramcopy )
+				if (_ramcopy)
 				{
 					group.m_vertices = (uint8_t*)BX_ALLOC(allocator, group.m_numVertices*stride);
 					bx::memCopy(group.m_vertices, mem->data, mem->size);
 				}
-				
+
 				group.m_vbh = bgfx::createVertexBuffer(mem, m_layout);
 			}
 				break;
-				
-			case BGFX_CHUNK_MAGIC_IB:
+
+			case kChunkIndexBuffer:
 			{
 				read(_reader, group.m_numIndices);
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2);
 				read(_reader, mem->data, mem->size);
-				if ( _ramcopy )
+
+				if (_ramcopy)
 				{
 					group.m_indices = (uint16_t*)BX_ALLOC(allocator, group.m_numIndices*2);
 					bx::memCopy(group.m_indices, mem->data, mem->size);
@@ -471,54 +472,54 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 				group.m_ibh = bgfx::createIndexBuffer(mem);
 			}
 				break;
-				
-			case BGFX_CHUNK_MAGIC_IBC:
+
+			case kChunkIndexBufferCompressed:
 			{
 				bx::read(_reader, group.m_numIndices);
-				
+
 				const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2);
-				
+
 				uint32_t compressedSize;
 				bx::read(_reader, compressedSize);
-				
+
 				void* compressedIndices = BX_ALLOC(allocator, compressedSize);
-				
+
 				bx::read(_reader, compressedIndices, compressedSize);
-				
+
 				meshopt_decodeIndexBuffer(mem->data, group.m_numIndices, 2, (uint8_t*)compressedIndices, compressedSize);
-				
+
 				BX_FREE(allocator, compressedIndices);
-				
-				if ( _ramcopy )
+
+				if (_ramcopy)
 				{
 					group.m_indices = (uint16_t*)BX_ALLOC(allocator, group.m_numIndices*2);
 					bx::memCopy(group.m_indices, mem->data, mem->size);
 				}
-				
+
 				group.m_ibh = bgfx::createIndexBuffer(mem);
 			}
 				break;
-				
-			case BGFX_CHUNK_MAGIC_PRI:
+
+			case kChunkPrimitive:
 			{
 				uint16_t len;
 				read(_reader, len);
-				
+
 				stl::string material;
 				material.resize(len);
 				read(_reader, const_cast<char*>(material.c_str() ), len);
-				
+
 				uint16_t num;
 				read(_reader, num);
-				
+
 				for (uint32_t ii = 0; ii < num; ++ii)
 				{
 					read(_reader, len);
-					
+
 					stl::string name;
 					name.resize(len);
 					read(_reader, const_cast<char*>(name.c_str() ), len);
-					
+
 					Primitive prim;
 					read(_reader, prim.m_startIndex);
 					read(_reader, prim.m_numIndices);
@@ -527,15 +528,15 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 					read(_reader, prim.m_sphere);
 					read(_reader, prim.m_aabb);
 					read(_reader, prim.m_obb);
-					
+
 					group.m_prims.push_back(prim);
 				}
-				
+
 				m_groups.push_back(group);
 				group.reset();
 			}
 				break;
-				
+
 			default:
 				DBG("%08x at %d", chunk, bx::skip(_reader, 0) );
 				break;
@@ -546,23 +547,23 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
 void Mesh::unload()
 {
 	bx::AllocatorI* allocator = entry::getAllocator();
-	
+
 	for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
 	{
 		const Group& group = *it;
 		bgfx::destroy(group.m_vbh);
-		
+
 		if (bgfx::isValid(group.m_ibh) )
 		{
 			bgfx::destroy(group.m_ibh);
 		}
-		
-		if ( NULL != group.m_vertices )
+
+		if (NULL != group.m_vertices)
 		{
 			BX_FREE(allocator, group.m_vertices);
 		}
 
-		if ( NULL != group.m_indices )
+		if (NULL != group.m_indices)
 		{
 			BX_FREE(allocator, group.m_indices);
 		}
@@ -575,22 +576,22 @@ void Mesh::submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _
 	if (BGFX_STATE_MASK == _state)
 	{
 		_state = 0
-		| BGFX_STATE_WRITE_RGB
-		| BGFX_STATE_WRITE_A
-		| BGFX_STATE_WRITE_Z
-		| BGFX_STATE_DEPTH_TEST_LESS
-		| BGFX_STATE_CULL_CCW
-		| BGFX_STATE_MSAA
-		;
+			| BGFX_STATE_WRITE_RGB
+			| BGFX_STATE_WRITE_A
+			| BGFX_STATE_WRITE_Z
+			| BGFX_STATE_DEPTH_TEST_LESS
+			| BGFX_STATE_CULL_CCW
+			| BGFX_STATE_MSAA
+			;
 	}
-	
+
 	bgfx::setTransform(_mtx);
 	bgfx::setState(_state);
-	
+
 	for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
 	{
 		const Group& group = *it;
-		
+
 		bgfx::setIndexBuffer(group.m_ibh);
 		bgfx::setVertexBuffer(0, group.m_vbh);
 		bgfx::submit(_id, _program, 0, (it == itEnd-1) ? (BGFX_DISCARD_INDEX_BUFFER | BGFX_DISCARD_VERTEX_STREAMS | BGFX_DISCARD_STATE) : BGFX_DISCARD_NONE);
@@ -600,31 +601,37 @@ void Mesh::submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _
 void Mesh::submit(const MeshState*const* _state, uint8_t _numPasses, const float* _mtx, uint16_t _numMatrices) const
 {
 	uint32_t cached = bgfx::setTransform(_mtx, _numMatrices);
-	
+
 	for (uint32_t pass = 0; pass < _numPasses; ++pass)
 	{
 		bgfx::setTransform(cached, _numMatrices);
-		
+
 		const MeshState& state = *_state[pass];
 		bgfx::setState(state.m_state);
-		
+
 		for (uint8_t tex = 0; tex < state.m_numTextures; ++tex)
 		{
 			const MeshState::Texture& texture = state.m_textures[tex];
-			bgfx::setTexture(texture.m_stage
-							 , texture.m_sampler
-							 , texture.m_texture
-							 , texture.m_flags
-							 );
+			bgfx::setTexture(
+				  texture.m_stage
+				, texture.m_sampler
+				, texture.m_texture
+				, texture.m_flags
+				);
 		}
-		
+
 		for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
 		{
 			const Group& group = *it;
-			
+
 			bgfx::setIndexBuffer(group.m_ibh);
 			bgfx::setVertexBuffer(0, group.m_vbh);
-			bgfx::submit(state.m_viewId, state.m_program, 0, (it == itEnd - 1) ? (BGFX_DISCARD_INDEX_BUFFER | BGFX_DISCARD_VERTEX_STREAMS | BGFX_DISCARD_STATE) : BGFX_DISCARD_NONE);
+			bgfx::submit(
+				  state.m_viewId
+				, state.m_program
+				, 0
+				, (it == itEnd - 1) ? (BGFX_DISCARD_INDEX_BUFFER | BGFX_DISCARD_VERTEX_STREAMS | BGFX_DISCARD_STATE) : BGFX_DISCARD_NONE
+				);
 		}
 	}
 }

tools/geometryc/geometryc.cpp

@@ -152,11 +152,11 @@ struct Mesh
 
 static uint32_t s_obbSteps = 17;
 
-#define BGFX_CHUNK_MAGIC_VB  BX_MAKEFOURCC('V', 'B', ' ', 0x1)
-#define BGFX_CHUNK_MAGIC_VBC BX_MAKEFOURCC('V', 'B', 'C', 0x0)
-#define BGFX_CHUNK_MAGIC_IB  BX_MAKEFOURCC('I', 'B', ' ', 0x0)
-#define BGFX_CHUNK_MAGIC_IBC BX_MAKEFOURCC('I', 'B', 'C', 0x1)
-#define BGFX_CHUNK_MAGIC_PRI BX_MAKEFOURCC('P', 'R', 'I', 0x0)
+constexpr uint32_t kChunkVertexBuffer           = BX_MAKEFOURCC('V', 'B', ' ', 0x1);
+constexpr uint32_t kChunkVertexBufferCompressed = BX_MAKEFOURCC('V', 'B', 'C', 0x0);
+constexpr uint32_t kChunkIndexBuffer            = BX_MAKEFOURCC('I', 'B', ' ', 0x0);
+constexpr uint32_t kChunkIndexBufferCompressed  = BX_MAKEFOURCC('I', 'B', 'C', 0x1);
+constexpr uint32_t kChunkPrimitive              = BX_MAKEFOURCC('P', 'R', 'I', 0x0);
 
 void optimizeVertexCache(uint16_t* _indices, uint32_t _numIndices, uint32_t _numVertices)
 {
@@ -349,7 +349,7 @@ void write(bx::WriterI* _writer
 
 	if (_compress)
 	{
-		write(_writer, BGFX_CHUNK_MAGIC_VBC);
+		write(_writer, kChunkVertexBufferCompressed);
 		write(_writer, _vertices, _numVertices, stride);
 
 		write(_writer, _layout);
@@ -359,7 +359,7 @@ void write(bx::WriterI* _writer
 	}
 	else
 	{
-		write(_writer, BGFX_CHUNK_MAGIC_VB);
+		write(_writer, kChunkVertexBuffer);
 		write(_writer, _vertices, _numVertices, stride);
 
 		write(_writer, _layout);
@@ -370,18 +370,18 @@ void write(bx::WriterI* _writer
 
 	if (_compress)
 	{
-		write(_writer, BGFX_CHUNK_MAGIC_IBC);
+		write(_writer, kChunkIndexBufferCompressed);
 		write(_writer, _numIndices);
 		writeCompressedIndices(_writer, _indices, _numIndices, _numVertices);
 	}
 	else
 	{
-		write(_writer, BGFX_CHUNK_MAGIC_IB);
+		write(_writer, kChunkIndexBuffer);
 		write(_writer, _numIndices);
 		write(_writer, _indices, _numIndices*2);
 	}
 
-	write(_writer, BGFX_CHUNK_MAGIC_PRI);
+	write(_writer, kChunkPrimitive);
 	uint16_t nameLen = uint16_t(_material.size() );
 	write(_writer, nameLen);
 	write(_writer, _material.c_str(), nameLen);