update cube_atlas to bgfx naming style

examples/common/cube_atlas.cpp

@@ -12,13 +12,13 @@ class RectanglePacker
 { 
 public:
 	RectanglePacker();
-	RectanglePacker(uint32_t width, uint32_t height);
+	RectanglePacker(uint32_t _width, uint32_t _height);
 	
 	/// non constructor initialization
-	void init(uint32_t width, uint32_t height);
+	void init(uint32_t _width, uint32_t _height);
 	/// find a suitable position for the given rectangle 
 	/// @return true if the rectangle can be added, false otherwise	
-	bool addRectangle(uint16_t width, uint16_t height, uint16_t& outX, uint16_t& outY );
+	bool addRectangle(uint16_t _width, uint16_t _height, uint16_t& _outX, uint16_t& _outY );
 	/// return the used surface in squared unit
 	uint32_t getUsedSurface() { return m_usedSpace; }
 	/// return the total available surface in squared unit
@@ -29,25 +29,25 @@ public:
     void clear();
 
 private:
-	int32_t fit(uint32_t skylineNodeIndex, uint16_t width, uint16_t height);
+	int32_t fit(uint32_t _skylineNodeIndex, uint16_t _width, uint16_t _height);
 	/// Merges all skyline nodes that are at the same level.
 	void merge();
 
 	struct Node
 	{
-		Node(int16_t _x, int16_t _y, int16_t _width):x(_x), y(_y), width(_width) {} 
+		Node(int16_t _x, int16_t _y, int16_t _width):m_x(_x), m_y(_y), m_width(_width) {} 
     
 		/// The starting x-coordinate (leftmost).
-		int16_t x;
+		int16_t m_x;
 		/// The y-coordinate of the skyline level line.
-		int16_t y;
-		/// The line width. The ending coordinate (inclusive) will be x+width-1.
-		int32_t width; //32bit to avoid padding
+		int16_t m_y;
+		/// The line _width. The ending coordinate (inclusive) will be x+width-1.
+		int32_t m_width; //32bit to avoid padding
 	};
 
-	 /// Width (in pixels) of the underlying texture
+	 /// width (in pixels) of the underlying texture
     uint32_t m_width;
-    /// Height (in pixels) of the underlying texture
+    /// height (in pixels) of the underlying texture
     uint32_t m_height;
     /// Surface used in squared pixel
     uint32_t m_usedSpace;
@@ -59,35 +59,35 @@ RectanglePacker::RectanglePacker(): m_width(0), m_height(0), m_usedSpace(0)
 {	
 }
 
-RectanglePacker::RectanglePacker(uint32_t width, uint32_t height):m_width(width), m_height(height), m_usedSpace(0)
+RectanglePacker::RectanglePacker(uint32_t _width, uint32_t _height):m_width(_width), m_height(_height), m_usedSpace(0)
 {   
     // We want a one pixel border around the whole atlas to avoid any artefact when
     // sampling texture    
-    m_skyline.push_back(Node(1,1, width-2));
+    m_skyline.push_back(Node(1,1, _width-2));
 }
 
-void RectanglePacker::init(uint32_t width, uint32_t height)
+void RectanglePacker::init(uint32_t _width, uint32_t _height)
 {
-	assert(width > 2);
-	assert(height > 2);
-	m_width = width;
-	m_height = height;
+	assert(_width > 2);
+	assert(_height > 2);
+	m_width = _width;
+	m_height = _height;
 	m_usedSpace = 0;
 
 	m_skyline.clear();
 	// We want a one pixel border around the whole atlas to avoid any artifact when
     // sampling texture    
-    m_skyline.push_back(Node(1,1, width-2));
+    m_skyline.push_back(Node(1,1, _width-2));
 }
 
-bool RectanglePacker::addRectangle(uint16_t width, uint16_t height, uint16_t& outX, uint16_t& outY)
+bool RectanglePacker::addRectangle(uint16_t _width, uint16_t _height, uint16_t& _outX, uint16_t& _outY)
 {
 	int y, best_height, best_index;
     int32_t best_width;
     Node* node;
     Node* prev;
-    outX = 0;
-	outY = 0;
+    _outX = 0;
+	_outY = 0;
 	
 	size_t i;
 
@@ -96,18 +96,18 @@ bool RectanglePacker::addRectangle(uint16_t width, uint16_t height, uint16_t& ou
     best_width = INT_MAX;
 	for( i = 0; i < m_skyline.size(); ++i )
 	{
-        y = fit( i, width, height );
+        y = fit( i, _width, _height );
 		if( y >= 0 )
 		{
             node = &m_skyline[i];
-			if( ( (y + height) < best_height ) ||
-                ( ((y + height) == best_height) && (node->width < best_width)) )
+			if( ( (y + _height) < best_height ) ||
+                ( ((y + _height) == best_height) && (node->m_width < best_width)) )
 			{
-				best_height = y + height;
+				best_height = y + _height;
 				best_index = i;
-				best_width = node->width;
-				outX = node->x;
-				outY = y;
+				best_width = node->m_width;
+				_outX = node->m_x;
+				_outY = y;
 			}
         }
     }
@@ -117,19 +117,19 @@ bool RectanglePacker::addRectangle(uint16_t width, uint16_t height, uint16_t& ou
 		return false;
     }
     
-    Node newNode(outX,outY + height, width);
+    Node newNode(_outX, _outY + _height, _width);
     m_skyline.insert(m_skyline.begin() + best_index, newNode);
 
     for(i = best_index+1; i < m_skyline.size(); ++i)
     {
         node = &m_skyline[i];
         prev = &m_skyline[i-1];
-        if (node->x < (prev->x + prev->width) )
+        if (node->m_x < (prev->m_x + prev->m_width) )
         {
-            int shrink = prev->x + prev->width - node->x;
-            node->x += shrink;
-            node->width -= shrink;
-            if (node->width <= 0)
+            int shrink = prev->m_x + prev->m_width - node->m_x;
+            node->m_x += shrink;
+            node->m_width -= shrink;
+            if (node->m_width <= 0)
             {
                  m_skyline.erase(m_skyline.begin() + i);
                 --i;
@@ -146,7 +146,7 @@ bool RectanglePacker::addRectangle(uint16_t width, uint16_t height, uint16_t& ou
     }
 
     merge();
-    m_usedSpace += width * height;
+    m_usedSpace += _width * _height;
     return true;
 }
 		
@@ -169,34 +169,34 @@ void RectanglePacker::clear()
     m_skyline.push_back(Node(1,1, m_width-2));
 }
 
-int32_t RectanglePacker::fit(uint32_t skylineNodeIndex, uint16_t _width, uint16_t _height)
+int32_t RectanglePacker::fit(uint32_t _skylineNodeIndex, uint16_t _width, uint16_t _height)
 {
 	int32_t width = _width;
     int32_t height = _height;
     
-    const Node& baseNode = m_skyline[skylineNodeIndex];
+    const Node& baseNode = m_skyline[_skylineNodeIndex];
     
-    int32_t x = baseNode.x, y;
-	int32_t width_left = width;
-	int32_t i = skylineNodeIndex;
+    int32_t x = baseNode.m_x, y;
+	int32_t _width_left = width;
+	int32_t i = _skylineNodeIndex;
 
     if ( (x + width) > (int32_t)(m_width-1) )
     {
 		return -1;
     }
-    y = baseNode.y;
-	while( width_left > 0 )
+    y = baseNode.m_y;
+	while( _width_left > 0 )
 	{
         const Node& node = m_skyline[i];
-        if( node.y > y )
+        if( node.m_y > y )
         {
-            y = node.y;
+            y = node.m_y;
         }
 		if( (y + height) > (int32_t)(m_height-1) )
         {
 			return -1;
         }
-        width_left -= node.width;
+        _width_left -= node.m_width;
 		++i;
 	}
 	return y;
@@ -212,9 +212,9 @@ void RectanglePacker::merge()
     {
         node = (Node *) &m_skyline[i];
         next = (Node *) &m_skyline[i+1];
-		if( node->y == next->y )
+		if( node->m_y == next->m_y )
 		{
-			node->width += next->width;
+			node->m_width += next->m_width;
             m_skyline.erase(m_skyline.begin() + i + 1);
 			--i;
 		}
@@ -229,24 +229,24 @@ struct Atlas::PackedLayer
 	AtlasRegion faceRegion;
 };
 
-Atlas::Atlas(uint16_t textureSize, uint16_t maxRegionsCount )
+Atlas::Atlas(uint16_t _textureSize, uint16_t _maxRegionsCount )
 {
-	assert(textureSize >= 64 && textureSize <= 4096 && "suspicious texture size" );
-	assert(maxRegionsCount >= 64 && maxRegionsCount <= 32000 && "suspicious regions count" );
+	assert(_textureSize >= 64 && _textureSize <= 4096 && "suspicious texture size" );
+	assert(_maxRegionsCount >= 64 && _maxRegionsCount <= 32000 && "suspicious _regions count" );
 	m_layers = new PackedLayer[24];
 	for(int i=0; i<24;++i)
 	{
-		m_layers[i].packer.init(textureSize, textureSize);		
+		m_layers[i].packer.init(_textureSize, _textureSize);		
 	}
 	m_usedLayers = 0;
 	m_usedFaces = 0;
 
-	m_textureSize = textureSize;
+	m_textureSize = _textureSize;
 	m_regionCount = 0;
-	m_maxRegionCount = maxRegionsCount;
-	m_regions = new AtlasRegion[maxRegionsCount];
-	m_textureBuffer = new uint8_t[ textureSize * textureSize * 6 * 4 ];
-	memset(m_textureBuffer, 0,  textureSize * textureSize * 6 * 4);
+	m_maxRegionCount = _maxRegionsCount;
+	m_regions = new AtlasRegion[_maxRegionsCount];
+	m_textureBuffer = new uint8_t[ _textureSize * _textureSize * 6 * 4 ];
+	memset(m_textureBuffer, 0,  _textureSize * _textureSize * 6 * 4);
 	//BGFX_TEXTURE_MIN_POINT|BGFX_TEXTURE_MAG_POINT|BGFX_TEXTURE_MIP_POINT;
 	//BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC|BGFX_TEXTURE_MIP_POINT
 	//BGFX_TEXTURE_U_CLAMP|BGFX_TEXTURE_V_CLAMP
@@ -257,7 +257,7 @@ Atlas::Atlas(uint16_t textureSize, uint16_t maxRegionsCount )
 	//memset(mem->data, 255, mem->size);	
 	const bgfx::Memory* mem = NULL;	
 	m_textureHandle = bgfx::createTextureCube(6
-			, textureSize
+			, _textureSize
 			, 1
 			, bgfx::TextureFormat::BGRA8
 			, flags
@@ -265,29 +265,29 @@ Atlas::Atlas(uint16_t textureSize, uint16_t maxRegionsCount )
 			);
 }
 
-Atlas::Atlas(uint16_t textureSize, const uint8_t* textureBuffer , uint16_t regionCount, const uint8_t* regionBuffer, uint16_t maxRegionsCount)
+Atlas::Atlas(uint16_t _textureSize, const uint8_t* _textureBuffer , uint16_t _regionCount, const uint8_t* _regionBuffer, uint16_t _maxRegionsCount)
 {
-	assert(regionCount <= 64 && maxRegionsCount <= 4096);
+	assert(_regionCount <= 64 && _maxRegionsCount <= 4096);
 	//layers are frozen
 	m_usedLayers = 24;
 	m_usedFaces = 6;
 
-	m_textureSize = textureSize;
-	m_regionCount = regionCount;
+	m_textureSize = _textureSize;
+	m_regionCount = _regionCount;
 	//regions are frozen
-	m_maxRegionCount = regionCount;
-	m_regions = new AtlasRegion[regionCount];
+	m_maxRegionCount = _regionCount;
+	m_regions = new AtlasRegion[_regionCount];
 	m_textureBuffer = new uint8_t[getTextureBufferSize()];
 	
 	//BGFX_TEXTURE_MIN_POINT|BGFX_TEXTURE_MAG_POINT|BGFX_TEXTURE_MIP_POINT;
 	//BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC|BGFX_TEXTURE_MIP_POINT
 	//BGFX_TEXTURE_U_CLAMP|BGFX_TEXTURE_V_CLAMP
 	uint32_t flags = 0;//BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC|BGFX_TEXTURE_MIP_POINT;
-	memcpy(m_regions, regionBuffer, regionCount * sizeof(AtlasRegion));	
-	memcpy(m_textureBuffer, textureBuffer, getTextureBufferSize());
+	memcpy(m_regions, _regionBuffer, _regionCount * sizeof(AtlasRegion));	
+	memcpy(m_textureBuffer, _textureBuffer, getTextureBufferSize());
 
 	m_textureHandle = bgfx::createTextureCube(6
-			, textureSize
+			, _textureSize
 			, 1
 			, bgfx::TextureFormat::BGRA8
 			, flags
@@ -302,7 +302,7 @@ Atlas::~Atlas()
 	delete[] m_textureBuffer;
 }
 
-uint16_t Atlas::addRegion(uint16_t width, uint16_t height, const uint8_t* bitmapBuffer,  AtlasRegion::Type type)
+uint16_t Atlas::addRegion(uint16_t _width, uint16_t _height, const uint8_t* _bitmapBuffer,  AtlasRegion::Type _type)
 {
 	if (m_regionCount >= m_maxRegionCount)
 	{
@@ -315,9 +315,9 @@ uint16_t Atlas::addRegion(uint16_t width, uint16_t height, const uint8_t* bitmap
 	uint32_t idx = 0;
 	while(idx<m_usedLayers)
 	{
-		if(m_layers[idx].faceRegion.getType() == type)
+		if(m_layers[idx].faceRegion.getType() == _type)
 		{
-			if(m_layers[idx].packer.addRectangle(width+1,height+1,x,y)) break;			
+			if(m_layers[idx].packer.addRectangle(_width+1,_height+1,x,y)) break;			
 		}
 		idx++;
 	}
@@ -325,154 +325,154 @@ uint16_t Atlas::addRegion(uint16_t width, uint16_t height, const uint8_t* bitmap
 	if(idx >= m_usedLayers)
 	{
 		//do we have still room to add layers ?
-		if( (idx + type) > 24 || m_usedFaces>=6)
+		if( (idx + _type) > 24 || m_usedFaces>=6)
 		{
 				return UINT16_MAX;
 		}		
 		//create new layers
-		for(int i=0; i < type;++i)
+		for(int i=0; i < _type;++i)
 		{
-			m_layers[idx+i].faceRegion.setMask(type, m_usedFaces, i);			
+			m_layers[idx+i].faceRegion.setMask(_type, m_usedFaces, i);			
 		}
-		m_usedLayers += type;
+		m_usedLayers += _type;
 		m_usedFaces++;
 
 
 		//add it to the created layer
-		if(!m_layers[idx].packer.addRectangle(width+1,height+1,x,y))
+		if(!m_layers[idx].packer.addRectangle(_width+1, _height+1, x, y))
 		{
 			return UINT16_MAX;
 		}
 	}
 	
 	AtlasRegion& region = m_regions[m_regionCount];
-	region.x = x;
-	region.y = y;
-	region.width = width;
-	region.height = height;
-	region.mask = m_layers[idx].faceRegion.mask;
+	region.m_x = x;
+	region.m_y = y;
+	region.m_width = _width;
+	region.m_height = _height;
+	region.m_mask = m_layers[idx].faceRegion.m_mask;
 
-	updateRegion(region, bitmapBuffer);
+	updateRegion(region, _bitmapBuffer);
 	return m_regionCount++;
 }
 
-void Atlas::updateRegion(const AtlasRegion& region, const uint8_t* bitmapBuffer)
+void Atlas::updateRegion(const AtlasRegion& _region, const uint8_t* _bitmapBuffer)
 {	
-	const bgfx::Memory* mem = bgfx::alloc(region.width * region.height * 4);
+	const bgfx::Memory* mem = bgfx::alloc(_region.m_width * _region.m_height * 4);
 	//BAD!
 	memset(mem->data,0, mem->size);
-	if(region.getType() == AtlasRegion::TYPE_BGRA8)
+	if(_region.getType() == AtlasRegion::TYPE_BGRA8)
 	{	
-		const uint8_t* inLineBuffer = bitmapBuffer;
-		uint8_t* outLineBuffer = m_textureBuffer + region.getFaceIndex() * (m_textureSize*m_textureSize*4) + (((region.y *m_textureSize)+region.x)*4);
+		const uint8_t* inLineBuffer = _bitmapBuffer;
+		uint8_t* outLineBuffer = m_textureBuffer + _region.getFaceIndex() * (m_textureSize*m_textureSize*4) + (((_region.m_y *m_textureSize)+_region.m_x)*4);
 
 		//update the cpu buffer
-		for(int y = 0; y < region.height; ++y)
+		for(int y = 0; y < _region.m_height; ++y)
 		{
-			memcpy(outLineBuffer, inLineBuffer, region.width * 4);
-			inLineBuffer += region.width*4;
+			memcpy(outLineBuffer, inLineBuffer, _region.m_width * 4);
+			inLineBuffer += _region.m_width*4;
 			outLineBuffer += m_textureSize*4;
 		}
 		//update the GPU buffer
-		memcpy(mem->data, bitmapBuffer, mem->size);
+		memcpy(mem->data, _bitmapBuffer, mem->size);
 	}else
 	{
-		uint32_t layer = region.getComponentIndex();
-		uint32_t face = region.getFaceIndex();
-		const uint8_t* inLineBuffer = bitmapBuffer;
-		uint8_t* outLineBuffer = (m_textureBuffer + region.getFaceIndex() * (m_textureSize*m_textureSize*4) + (((region.y *m_textureSize)+region.x)*4));
+		uint32_t layer = _region.getComponentIndex();
+		uint32_t face = _region.getFaceIndex();
+		const uint8_t* inLineBuffer = _bitmapBuffer;
+		uint8_t* outLineBuffer = (m_textureBuffer + _region.getFaceIndex() * (m_textureSize*m_textureSize*4) + (((_region.m_y *m_textureSize)+_region.m_x)*4));
 		
 		//update the cpu buffer
-		for(int y = 0; y<region.height; ++y)
+		for(int y = 0; y<_region.m_height; ++y)
 		{
-			for(int x = 0; x<region.width; ++x)
+			for(int x = 0; x<_region.m_width; ++x)
 			{
 				outLineBuffer[(x*4) + layer] = inLineBuffer[x];
 			}
 			//update the GPU buffer
-			memcpy(mem->data + y*region.width*4, outLineBuffer, region.width*4);
-			inLineBuffer += region.width;
+			memcpy(mem->data + y*_region.m_width*4, outLineBuffer, _region.m_width*4);
+			inLineBuffer += _region.m_width;
 			outLineBuffer +=  m_textureSize*4;
 		}
 	}
-	bgfx::updateTextureCube(m_textureHandle, (uint8_t)region.getFaceIndex(), 0, region.x, region.y, region.width, region.height, mem);		
+	bgfx::updateTextureCube(m_textureHandle, (uint8_t)_region.getFaceIndex(), 0, _region.m_x, _region.m_y, _region.m_width, _region.m_height, mem);		
 }
 
-void Atlas::packFaceLayerUV(uint32_t idx, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride )
+void Atlas::packFaceLayerUV(uint32_t _idx, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride )
 {
-	packUV(m_layers[idx].faceRegion, vertexBuffer, offset, stride);
+	packUV(m_layers[_idx].faceRegion, _vertexBuffer, _offset, _stride);
 }
 
-void Atlas::packUV( uint16_t handle, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride )
+void Atlas::packUV( uint16_t handle, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride )
 {
 	const AtlasRegion& region = m_regions[handle];
-	packUV(region, vertexBuffer, offset, stride);
+	packUV(region, _vertexBuffer, _offset, _stride);
 }
 
-void Atlas::packUV( const AtlasRegion& region, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride )
+void Atlas::packUV( const AtlasRegion& _region, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride )
 {
 	float texMult = 65535.0f / ((float)(m_textureSize));
 	static const int16_t minVal = -32768;
 	static const int16_t maxVal = 32767;
 	
-	int16_t x0 = (int16_t)(region.x * texMult)-32768;
-	int16_t y0 = (int16_t)(region.y * texMult)-32768;
-	int16_t x1 = (int16_t)((region.x + region.width)* texMult)-32768;
-	int16_t y1 = (int16_t)((region.y + region.height)* texMult)-32768;
-	int16_t w =  (int16_t) ((32767.0f/4.0f) * region.getComponentIndex());
-
-	vertexBuffer+=offset;
-	switch(region.getFaceIndex())
+	int16_t x0 = (int16_t)(_region.m_x * texMult)-32768;
+	int16_t y0 = (int16_t)(_region.m_y * texMult)-32768;
+	int16_t x1 = (int16_t)((_region.m_x + _region.m_width)* texMult)-32768;
+	int16_t y1 = (int16_t)((_region.m_y + _region.m_height)* texMult)-32768;
+	int16_t w =  (int16_t) ((32767.0f/4.0f) * _region.getComponentIndex());
+
+	_vertexBuffer+=_offset;
+	switch(_region.getFaceIndex())
 	{
 	case 0: // +X
 		x0= -x0; 
 		x1= -x1;
 		y0= -y0; 
 		y1= -y1;
-		writeUV(vertexBuffer, maxVal, y0, x0, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, maxVal, y1, x0, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, maxVal, y1, x1, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, maxVal, y0, x1, w); vertexBuffer+=stride;
+		writeUV(_vertexBuffer, maxVal, y0, x0, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, maxVal, y1, x0, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, maxVal, y1, x1, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, maxVal, y0, x1, w); _vertexBuffer+=_stride;
 		break;
 	case 1: // -X		
 		y0= -y0; 
 		y1= -y1;
-		writeUV(vertexBuffer, minVal, y0, x0, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, minVal, y1, x0, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, minVal, y1, x1, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, minVal, y0, x1, w); vertexBuffer+=stride;	
+		writeUV(_vertexBuffer, minVal, y0, x0, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, minVal, y1, x0, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, minVal, y1, x1, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, minVal, y0, x1, w); _vertexBuffer+=_stride;	
 		break;
 	case 2: // +Y		
-		writeUV(vertexBuffer, x0, maxVal, y0, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x0, maxVal, y1, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, maxVal, y1, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, maxVal, y0, w); vertexBuffer+=stride;
+		writeUV(_vertexBuffer, x0, maxVal, y0, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x0, maxVal, y1, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, maxVal, y1, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, maxVal, y0, w); _vertexBuffer+=_stride;
 		break;
 	case 3: // -Y
 		y0= -y0; 
 		y1= -y1;
-		writeUV(vertexBuffer, x0, minVal, y0, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x0, minVal, y1, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, minVal, y1, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, minVal, y0, w); vertexBuffer+=stride;
+		writeUV(_vertexBuffer, x0, minVal, y0, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x0, minVal, y1, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, minVal, y1, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, minVal, y0, w); _vertexBuffer+=_stride;
 		break;
 	case 4: // +Z
 		y0= -y0; 
 		y1= -y1;
-		writeUV(vertexBuffer, x0, y0, maxVal, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x0, y1, maxVal, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, y1, maxVal, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, y0, maxVal, w); vertexBuffer+=stride;
+		writeUV(_vertexBuffer, x0, y0, maxVal, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x0, y1, maxVal, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, y1, maxVal, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, y0, maxVal, w); _vertexBuffer+=_stride;
 		break;
 	case 5: // -Z
 		x0= -x0; 
 		x1= -x1;
 		y0= -y0; 
 		y1= -y1;
-		writeUV(vertexBuffer, x0, y0, minVal, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x0, y1, minVal, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, y1, minVal, w); vertexBuffer+=stride;
-		writeUV(vertexBuffer, x1, y0, minVal, w); vertexBuffer+=stride;
+		writeUV(_vertexBuffer, x0, y0, minVal, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x0, y1, minVal, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, y1, minVal, w); _vertexBuffer+=_stride;
+		writeUV(_vertexBuffer, x1, y0, minVal, w); _vertexBuffer+=_stride;
 		break;
 	}
 }

examples/common/cube_atlas.h

@@ -22,14 +22,14 @@ struct AtlasRegion
 		TYPE_BGRA8 = 4  // 4 components
 	};	
 
-	uint16_t x, y;
-	uint16_t width, height;
-	uint32_t mask; //encode the region type, the face index and the component index in case of a gray region
-
-	Type getType()const           { return (Type) ((mask >> 0) & 0x0000000F); }
-	uint32_t getFaceIndex()const  { return         (mask >> 4) & 0x0000000F; }
-	uint32_t getComponentIndex()const { return         (mask >> 8) & 0x0000000F; }
-	void setMask(Type type, uint32_t faceIndex, uint32_t componentIndex) { mask = (componentIndex << 8) +  (faceIndex << 4) + (uint32_t)type; }
+	uint16_t m_x, m_y;
+	uint16_t m_width, m_height;
+	uint32_t m_mask; //encode the region type, the face index and the component index in case of a gray region
+
+	Type getType()const           { return (Type) ((m_mask >> 0) & 0x0000000F); }
+	uint32_t getFaceIndex()const  { return         (m_mask >> 4) & 0x0000000F; }
+	uint32_t getComponentIndex()const { return         (m_mask >> 8) & 0x0000000F; }
+	void setMask(Type _type, uint32_t _faceIndex, uint32_t _componentIndex) { m_mask = (_componentIndex << 8) +  (_faceIndex << 4) + (uint32_t)_type; }
 };
 
 class Atlas
@@ -38,7 +38,7 @@ public:
 	/// create an empty dynamic atlas (region can be updated and added)
 	/// @param textureSize an atlas creates a texture cube of 6 faces with size equal to (textureSize*textureSize * sizeof(RGBA))
 	/// @param maxRegionCount maximum number of region allowed in the atlas	
-	Atlas(uint16_t textureSize, uint16_t _maxRegionsCount = 4096);
+	Atlas(uint16_t _textureSize, uint16_t _maxRegionsCount = 4096);
 		
 	/// initialize a static atlas with serialized data	(region can be updated but not added)
 	/// @param textureSize an atlas creates a texture cube of 6 faces with size equal to (textureSize*textureSize * sizeof(RGBA))
@@ -46,14 +46,14 @@ public:
 	/// @param regionCount number of region in the Atlas
 	/// @param regionBuffer buffer containing the region (will be copied)
 	/// @param maxRegionCount maximum number of region allowed in the atlas
-	Atlas(uint16_t textureSize, const uint8_t * textureBuffer, uint16_t regionCount, const uint8_t* regionBuffer, uint16_t maxRegionsCount = 4096);
+	Atlas(uint16_t _textureSize, const uint8_t * _textureBuffer, uint16_t _regionCount, const uint8_t* _regionBuffer, uint16_t _maxRegionsCount = 4096);
 	~Atlas();
 	
 	/// add a region to the atlas, and copy the content of mem to the underlying texture
-	uint16_t addRegion(uint16_t width, uint16_t height, const uint8_t* bitmapBuffer, AtlasRegion::Type type = AtlasRegion::TYPE_BGRA8);
+	uint16_t addRegion(uint16_t _width, uint16_t _height, const uint8_t* _bitmapBuffer, AtlasRegion::Type _type = AtlasRegion::TYPE_BGRA8);
 
 	/// update a preallocated region
-	void updateRegion(const AtlasRegion& region, const uint8_t* bitmapBuffer);
+	void updateRegion(const AtlasRegion& _region, const uint8_t* _bitmapBuffer);
 
 	/// Pack the UV coordinates of the four corners of a region to a vertex buffer using the supplied vertex format.
 	/// v0 -- v3
@@ -65,28 +65,28 @@ public:
 	/// @param vertexBuffer address of the first vertex we want to update. Must be valid up to vertexBuffer + offset + 3*stride + 4*sizeof(int16_t), which means the buffer must contains at least 4 vertex includind the first.
 	/// @param offset byte offset to the first uv coordinate of the vertex in the buffer
 	/// @param stride stride between tho UV coordinates, usually size of a Vertex.
-	void packUV( uint16_t regionHandle, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride );
-	void packUV( const AtlasRegion& region, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride );
+	void packUV( uint16_t _regionHandle, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride );
+	void packUV( const AtlasRegion& _region, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride );
 	
 	/// Same as packUV but pack a whole face of the atlas cube, mostly used for debugging and visualizing atlas
-	void packFaceLayerUV(uint32_t idx, uint8_t* vertexBuffer, uint32_t offset, uint32_t stride );
+	void packFaceLayerUV(uint32_t _idx, uint8_t* _vertexBuffer, uint32_t _offset, uint32_t _stride );
 
 	/// Pack the vertex index of the region as 2 quad into an index buffer
-	void packIndex(uint16_t* indexBuffer, uint32_t startIndex, uint32_t startVertex )
+	void packIndex(uint16_t* _indexBuffer, uint32_t _startIndex, uint32_t _startVertex )
 	{
-		indexBuffer[startIndex+0] = startVertex+0;
-		indexBuffer[startIndex+1] = startVertex+1;
-		indexBuffer[startIndex+2] = startVertex+2;
-		indexBuffer[startIndex+3] = startVertex+0;
-		indexBuffer[startIndex+4] = startVertex+2;
-		indexBuffer[startIndex+5] = startVertex+3;
+		_indexBuffer[_startIndex+0] = _startVertex+0;
+		_indexBuffer[_startIndex+1] = _startVertex+1;
+		_indexBuffer[_startIndex+2] = _startVertex+2;
+		_indexBuffer[_startIndex+3] = _startVertex+0;
+		_indexBuffer[_startIndex+4] = _startVertex+2;
+		_indexBuffer[_startIndex+5] = _startVertex+3;
 	}
 
 	/// return the TextureHandle (cube) of the atlas
 	bgfx::TextureHandle getTextureHandle() const { return m_textureHandle; }
 
 	//retrieve a region info
-	const AtlasRegion& getRegion(uint16_t handle) const { return m_regions[handle]; }
+	const AtlasRegion& getRegion(uint16_t _handle) const { return m_regions[_handle]; }
 	
 	/// retrieve the size of side of a texture in pixels
 	uint16_t getTextureSize(){ return m_textureSize; }
@@ -108,12 +108,12 @@ public:
 
 private:
 
-	void writeUV( uint8_t* vertexBuffer, int16_t x, int16_t y, int16_t z, int16_t w) 
+	void writeUV( uint8_t* _vertexBuffer, int16_t _x, int16_t _y, int16_t _z, int16_t _w) 
 	{
-		((uint16_t*) vertexBuffer)[0] = x;
-		((uint16_t*) vertexBuffer)[1] = y; 
-		((uint16_t*) vertexBuffer)[2] = z; 
-		((uint16_t*) vertexBuffer)[3] = w; 
+		((uint16_t*) _vertexBuffer)[0] = _x;
+		((uint16_t*) _vertexBuffer)[1] = _y; 
+		((uint16_t*) _vertexBuffer)[2] = _z; 
+		((uint16_t*) _vertexBuffer)[3] = _w;
 	}
 	struct PackedLayer;	
 	PackedLayer* m_layers;