Updated ib-compress.

3rdparty/ib-compress/indexbuffercompressionformat.h

@@ -4,11 +4,11 @@
 
 enum IndexBufferCompressionFormat
 {
-	// Per indice encoding - handles degenerates, but has worse compression/decompression speed and compression.
-	IBCF_PER_INDICE_1 = 0,
+    // Per indice encoding - handles degenerates, but has worse compression/decompression speed and compression.
+    IBCF_PER_INDICE_1 = 0,
 
-	// Per triangle encoding - better compression/speed, does not handle degenerates.
-	IBCF_PER_TRIANGLE_1 = 1,
+    // Per triangle encoding - better compression/speed, does not handle degenerates.
+    IBCF_PER_TRIANGLE_1 = 1,
 
     // Automatically pick the best encoding dependent on whether degenerate triangles are detected in the mesh.
     // Will take longer to compress (due to the degenerate triangle check).

3rdparty/ib-compress/indexbufferdecompression.cpp

@@ -31,451 +31,451 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 template <typename Ty>
 void DecompressTriangleCodes1( Ty* triangles, uint32_t triangleCount, ReadBitstream& input )
 {
-	Edge      edgeFifo[ EDGE_FIFO_SIZE ];
-	uint32_t  vertexFifo[ VERTEX_FIFO_SIZE ];
-
-	uint32_t  edgesRead = 0;
-	uint32_t  verticesRead = 0;
-	uint32_t  newVertices = 0;
-	const Ty* triangleEnd = triangles + ( triangleCount * 3 );
-
-	// iterate through the triangles
-	for ( Ty* triangle = triangles; triangle < triangleEnd; triangle += 3 )
-	{
-		IndexBufferTriangleCodes code      = static_cast< IndexBufferTriangleCodes >( input.Read( IB_TRIANGLE_CODE_BITS ) );
-
-		switch ( code )
-		{
-		case IB_EDGE_NEW:
-		{
-			uint32_t    edgeFifoIndex = input.Read( CACHED_EDGE_BITS );
-
-			const Edge& edge          = edgeFifo[ ( ( edgesRead - 1 ) - edgeFifoIndex ) & EDGE_FIFO_MASK ];
-
-			triangle[ 0 ] = static_cast< Ty >( edge.second );
-			triangle[ 1 ] = static_cast< Ty >( edge.first );
-
-			vertexFifo[ verticesRead & EDGE_FIFO_MASK ] =
-			triangle[ 2 ]                               = static_cast< Ty >( newVertices );
-
-			++newVertices;
-			++verticesRead;
-
-			break;
-		}
-
-		case IB_EDGE_CACHED:
-		{
-			uint32_t    edgeFifoIndex   = input.Read( CACHED_EDGE_BITS );
-			uint32_t    vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
-
-			const Edge& edge            = edgeFifo[ ( ( edgesRead - 1 ) - edgeFifoIndex ) & EDGE_FIFO_MASK ];
-
-			triangle[ 0 ] = static_cast< Ty >( edge.second );
-			triangle[ 1 ] = static_cast< Ty >( edge.first );
-			triangle[ 2 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] );
-			
-			break;
-		}
-		case IB_EDGE_FREE:
-		{
-			uint32_t    edgeFifoIndex   = input.Read( CACHED_EDGE_BITS );
-			uint32_t    relativeVertex  = input.ReadVInt();
-
-			const Edge& edge            = edgeFifo[ ( ( edgesRead - 1 ) - edgeFifoIndex ) & EDGE_FIFO_MASK ];
-
-			triangle[ 0 ] = static_cast< Ty >( edge.second );
-			triangle[ 1 ] = static_cast< Ty >( edge.first );
-			
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                 = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
-			++verticesRead;
-			
-			break;
-		}
-		case IB_NEW_NEW_NEW:
-		{
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 1 ]                                         = static_cast< Ty >( newVertices + 1 );
-			vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                         = static_cast< Ty >( newVertices + 2 );
-
-			newVertices  += 3;
-			verticesRead += 3;
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-			break;
-		}
-		case IB_NEW_NEW_CACHED:
-		{
-			uint32_t vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
-
-			triangle[ 2 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] );
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 1 ]                                         = static_cast< Ty >( newVertices + 1 );
-
-			verticesRead += 2;
-			newVertices  += 2;
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-			break;
-		}
-		case IB_NEW_NEW_FREE:
-		{
-			uint32_t relativeVertex = input.ReadVInt();
-
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 1 ]                                         = static_cast< Ty >( newVertices + 1 );
-			vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
-
-			newVertices  += 2;
-			verticesRead += 3;
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-			break;
-		}
-		case IB_NEW_CACHED_CACHED:
-		{
-			uint32_t vertex1FifoIndex = input.Read( CACHED_VERTEX_BITS );
-			uint32_t vertex2FifoIndex = input.Read( CACHED_VERTEX_BITS );
-
-			triangle[ 1 ]                                 = static_cast< Ty >(  vertexFifo[ ( ( verticesRead - 1 ) - vertex1FifoIndex ) & VERTEX_FIFO_MASK ] );
-			triangle[ 2 ]                                 = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex2FifoIndex ) & VERTEX_FIFO_MASK ] );
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
-			triangle[ 0 ]                                 = static_cast< Ty >( newVertices );
-
-			++verticesRead;
-			++newVertices;
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-			break;
-		}
-		case IB_NEW_CACHED_FREE:
-		{
-			uint32_t vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
-			uint32_t relativeVertex  = input.ReadVInt();
-
-			triangle[ 1 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] );
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
-
-			verticesRead += 2;
-			++newVertices;
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-			break;
-		}
-		case IB_NEW_FREE_CACHED:
-		{
-			uint32_t relativeVertex  = input.ReadVInt();
-			uint32_t vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
-
-			triangle[ 2 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] ); 
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
-
-			verticesRead += 2;
-			++newVertices;
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-			break;
-		}
-		case IB_NEW_FREE_FREE:
-		{
-			uint32_t relativeVertex1  = input.ReadVInt();
-			uint32_t relativeVertex2  = input.ReadVInt();
-
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex1 );
-			vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
-
-			verticesRead += 3;
-			++newVertices;
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-
-			break;
-		}
-		case IB_CACHED_CACHED_CACHED:
-		{
-			uint32_t vertex0FifoIndex = input.Read( CACHED_VERTEX_BITS );
-			uint32_t vertex1FifoIndex = input.Read( CACHED_VERTEX_BITS );
-			uint32_t vertex2FifoIndex = input.Read( CACHED_VERTEX_BITS );
-
-			triangle[ 0 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex0FifoIndex ) & VERTEX_FIFO_MASK ] );
-			triangle[ 1 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex1FifoIndex ) & VERTEX_FIFO_MASK ] );
-			triangle[ 2 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex2FifoIndex ) & VERTEX_FIFO_MASK ] );
-
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
-
-			++edgesRead;
-			break;
-		}
-		case IB_CACHED_CACHED_FREE:
-		{
-			uint32_t vertex0FifoIndex = input.Read( CACHED_VERTEX_BITS );
-			uint32_t vertex1FifoIndex = input.Read( CACHED_VERTEX_BITS );
-			uint32_t relativeVertex2  = input.ReadVInt();
-
-			triangle[ 0 ]                                 = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex0FifoIndex ) & VERTEX_FIFO_MASK ] );
-			triangle[ 1 ]                                 = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex1FifoIndex ) & VERTEX_FIFO_MASK ] );
-
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                 = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
+    Edge      edgeFifo[ EDGE_FIFO_SIZE ];
+    uint32_t  vertexFifo[ VERTEX_FIFO_SIZE ];
+
+    uint32_t  edgesRead = 0;
+    uint32_t  verticesRead = 0;
+    uint32_t  newVertices = 0;
+    const Ty* triangleEnd = triangles + ( triangleCount * 3 );
+
+    // iterate through the triangles
+    for ( Ty* triangle = triangles; triangle < triangleEnd; triangle += 3 )
+    {
+        IndexBufferTriangleCodes code      = static_cast< IndexBufferTriangleCodes >( input.Read( IB_TRIANGLE_CODE_BITS ) );
+
+        switch ( code )
+        {
+        case IB_EDGE_NEW:
+        {
+            uint32_t    edgeFifoIndex = input.Read( CACHED_EDGE_BITS );
+
+            const Edge& edge          = edgeFifo[ ( ( edgesRead - 1 ) - edgeFifoIndex ) & EDGE_FIFO_MASK ];
+
+            triangle[ 0 ] = static_cast< Ty >( edge.second );
+            triangle[ 1 ] = static_cast< Ty >( edge.first );
+
+            vertexFifo[ verticesRead & EDGE_FIFO_MASK ] =
+            triangle[ 2 ]                               = static_cast< Ty >( newVertices );
+
+            ++newVertices;
+            ++verticesRead;
+
+            break;
+        }
+
+        case IB_EDGE_CACHED:
+        {
+            uint32_t    edgeFifoIndex   = input.Read( CACHED_EDGE_BITS );
+            uint32_t    vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
+
+            const Edge& edge            = edgeFifo[ ( ( edgesRead - 1 ) - edgeFifoIndex ) & EDGE_FIFO_MASK ];
+
+            triangle[ 0 ] = static_cast< Ty >( edge.second );
+            triangle[ 1 ] = static_cast< Ty >( edge.first );
+            triangle[ 2 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] );
+            
+            break;
+        }
+        case IB_EDGE_FREE:
+        {
+            uint32_t    edgeFifoIndex   = input.Read( CACHED_EDGE_BITS );
+            uint32_t    relativeVertex  = input.ReadVInt();
+
+            const Edge& edge            = edgeFifo[ ( ( edgesRead - 1 ) - edgeFifoIndex ) & EDGE_FIFO_MASK ];
+
+            triangle[ 0 ] = static_cast< Ty >( edge.second );
+            triangle[ 1 ] = static_cast< Ty >( edge.first );
+            
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                 = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
+            ++verticesRead;
+            
+            break;
+        }
+        case IB_NEW_NEW_NEW:
+        {
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 1 ]                                         = static_cast< Ty >( newVertices + 1 );
+            vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                         = static_cast< Ty >( newVertices + 2 );
+
+            newVertices  += 3;
+            verticesRead += 3;
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+            break;
+        }
+        case IB_NEW_NEW_CACHED:
+        {
+            uint32_t vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
+
+            triangle[ 2 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] );
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 1 ]                                         = static_cast< Ty >( newVertices + 1 );
+
+            verticesRead += 2;
+            newVertices  += 2;
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+            break;
+        }
+        case IB_NEW_NEW_FREE:
+        {
+            uint32_t relativeVertex = input.ReadVInt();
+
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 1 ]                                         = static_cast< Ty >( newVertices + 1 );
+            vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
+
+            newVertices  += 2;
+            verticesRead += 3;
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+            break;
+        }
+        case IB_NEW_CACHED_CACHED:
+        {
+            uint32_t vertex1FifoIndex = input.Read( CACHED_VERTEX_BITS );
+            uint32_t vertex2FifoIndex = input.Read( CACHED_VERTEX_BITS );
+
+            triangle[ 1 ]                                 = static_cast< Ty >(  vertexFifo[ ( ( verticesRead - 1 ) - vertex1FifoIndex ) & VERTEX_FIFO_MASK ] );
+            triangle[ 2 ]                                 = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex2FifoIndex ) & VERTEX_FIFO_MASK ] );
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
+            triangle[ 0 ]                                 = static_cast< Ty >( newVertices );
+
+            ++verticesRead;
+            ++newVertices;
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+            break;
+        }
+        case IB_NEW_CACHED_FREE:
+        {
+            uint32_t vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
+            uint32_t relativeVertex  = input.ReadVInt();
+
+            triangle[ 1 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] );
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
+
+            verticesRead += 2;
+            ++newVertices;
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+            break;
+        }
+        case IB_NEW_FREE_CACHED:
+        {
+            uint32_t relativeVertex  = input.ReadVInt();
+            uint32_t vertexFifoIndex = input.Read( CACHED_VERTEX_BITS );
+
+            triangle[ 2 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertexFifoIndex ) & VERTEX_FIFO_MASK ] ); 
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex );
+
+            verticesRead += 2;
+            ++newVertices;
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+            break;
+        }
+        case IB_NEW_FREE_FREE:
+        {
+            uint32_t relativeVertex1  = input.ReadVInt();
+            uint32_t relativeVertex2  = input.ReadVInt();
+
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 0 ]                                         = static_cast< Ty >( newVertices );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex1 );
+            vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
+
+            verticesRead += 3;
+            ++newVertices;
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+
+            break;
+        }
+        case IB_CACHED_CACHED_CACHED:
+        {
+            uint32_t vertex0FifoIndex = input.Read( CACHED_VERTEX_BITS );
+            uint32_t vertex1FifoIndex = input.Read( CACHED_VERTEX_BITS );
+            uint32_t vertex2FifoIndex = input.Read( CACHED_VERTEX_BITS );
+
+            triangle[ 0 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex0FifoIndex ) & VERTEX_FIFO_MASK ] );
+            triangle[ 1 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex1FifoIndex ) & VERTEX_FIFO_MASK ] );
+            triangle[ 2 ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex2FifoIndex ) & VERTEX_FIFO_MASK ] );
+
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+
+            ++edgesRead;
+            break;
+        }
+        case IB_CACHED_CACHED_FREE:
+        {
+            uint32_t vertex0FifoIndex = input.Read( CACHED_VERTEX_BITS );
+            uint32_t vertex1FifoIndex = input.Read( CACHED_VERTEX_BITS );
+            uint32_t relativeVertex2  = input.ReadVInt();
+
+            triangle[ 0 ]                                 = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex0FifoIndex ) & VERTEX_FIFO_MASK ] );
+            triangle[ 1 ]                                 = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex1FifoIndex ) & VERTEX_FIFO_MASK ] );
+
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                 = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
 
-			++verticesRead;
+            ++verticesRead;
 
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
 
-			++edgesRead;
+            ++edgesRead;
 
-			break;
-		}
-		case IB_CACHED_FREE_FREE:
-		{
-			uint32_t vertex0FifoIndex = input.Read( CACHED_VERTEX_BITS );
-			uint32_t relativeVertex1  = input.ReadVInt();
-			uint32_t relativeVertex2  = input.ReadVInt();
+            break;
+        }
+        case IB_CACHED_FREE_FREE:
+        {
+            uint32_t vertex0FifoIndex = input.Read( CACHED_VERTEX_BITS );
+            uint32_t relativeVertex1  = input.ReadVInt();
+            uint32_t relativeVertex2  = input.ReadVInt();
 
-			triangle[ 0 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex0FifoIndex ) & VERTEX_FIFO_MASK ] );
+            triangle[ 0 ]                                         = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - vertex0FifoIndex ) & VERTEX_FIFO_MASK ] );
 
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex1 );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex1 );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
 
-			verticesRead += 2;
+            verticesRead += 2;
 
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
 
-			++edgesRead;
+            ++edgesRead;
 
-			break;
-		}
-		case IB_FREE_FREE_FREE:
-		{
-			uint32_t relativeVertex0 = input.ReadVInt();
-			uint32_t relativeVertex1 = input.ReadVInt();
-			uint32_t relativeVertex2 = input.ReadVInt();
+            break;
+        }
+        case IB_FREE_FREE_FREE:
+        {
+            uint32_t relativeVertex0 = input.ReadVInt();
+            uint32_t relativeVertex1 = input.ReadVInt();
+            uint32_t relativeVertex2 = input.ReadVInt();
 
-			vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
-			triangle[ 0 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex0 );
-			vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex1 );
-			vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
-			triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
+            vertexFifo[ verticesRead & VERTEX_FIFO_MASK ]         =
+            triangle[ 0 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex0 );
+            vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 1 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex1 );
+            vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] =
+            triangle[ 2 ]                                         = static_cast< Ty >( ( newVertices - 1 ) - relativeVertex2 );
 
-			verticesRead += 3;
+            verticesRead += 3;
 
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
 
-			++edgesRead;
+            ++edgesRead;
 
-			break;
-		}
-		case IB_EDGE_0_NEW:
-		{
-			const Edge& edge = edgeFifo[ ( edgesRead - 1 ) & EDGE_FIFO_MASK ];
+            break;
+        }
+        case IB_EDGE_0_NEW:
+        {
+            const Edge& edge = edgeFifo[ ( edgesRead - 1 ) & EDGE_FIFO_MASK ];
 
-			triangle[ 0 ]                               = static_cast< Ty >( edge.second );
-			triangle[ 1 ]                               = static_cast< Ty >( edge.first );
+            triangle[ 0 ]                               = static_cast< Ty >( edge.second );
+            triangle[ 1 ]                               = static_cast< Ty >( edge.first );
 
-			vertexFifo[ verticesRead & EDGE_FIFO_MASK ] =
-			triangle[ 2 ]                               = static_cast< Ty >( newVertices );
+            vertexFifo[ verticesRead & EDGE_FIFO_MASK ] =
+            triangle[ 2 ]                               = static_cast< Ty >( newVertices );
 
-			++newVertices;
-			++verticesRead;
-			break;
-		}
-		case IB_EDGE_1_NEW:
-		{
-			const Edge& edge = edgeFifo[ ( ( edgesRead - 1 ) - 1 ) & EDGE_FIFO_MASK ];
+            ++newVertices;
+            ++verticesRead;
+            break;
+        }
+        case IB_EDGE_1_NEW:
+        {
+            const Edge& edge = edgeFifo[ ( ( edgesRead - 1 ) - 1 ) & EDGE_FIFO_MASK ];
 
-			triangle[ 0 ]                               = static_cast< Ty >( edge.second );
-			triangle[ 1 ]                               = static_cast< Ty >( edge.first );
+            triangle[ 0 ]                               = static_cast< Ty >( edge.second );
+            triangle[ 1 ]                               = static_cast< Ty >( edge.first );
 
-			vertexFifo[ verticesRead & EDGE_FIFO_MASK ] =
-			triangle[ 2 ]                               = static_cast< Ty >( newVertices );
+            vertexFifo[ verticesRead & EDGE_FIFO_MASK ] =
+            triangle[ 2 ]                               = static_cast< Ty >( newVertices );
 
-			++newVertices;
-			++verticesRead;
-			break;
-		}
-		}
+            ++newVertices;
+            ++verticesRead;
+            break;
+        }
+        }
 
-		edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] );
+        edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] );
 
-		++edgesRead;
+        ++edgesRead;
 
-		edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] );
+        edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] );
 
-		++edgesRead;
-	}
+        ++edgesRead;
+    }
 }
 
 template <typename Ty>
 void DecompressIndiceCodes1( Ty* triangles, uint32_t triangleCount, ReadBitstream& input )
 {
-	Edge      edgeFifo[ EDGE_FIFO_SIZE ];
-	uint32_t  vertexFifo[ VERTEX_FIFO_SIZE ];
+    Edge      edgeFifo[ EDGE_FIFO_SIZE ];
+    uint32_t  vertexFifo[ VERTEX_FIFO_SIZE ];
 
-	uint32_t  edgesRead    = 0;
-	uint32_t  verticesRead = 0;
-	uint32_t  newVertices  = 0;
-	const Ty* triangleEnd = triangles + ( triangleCount * 3 );
+    uint32_t  edgesRead    = 0;
+    uint32_t  verticesRead = 0;
+    uint32_t  newVertices  = 0;
+    const Ty* triangleEnd = triangles + ( triangleCount * 3 );
 
-	// iterate through the triangles
-	for ( Ty* triangle = triangles; triangle < triangleEnd; triangle += 3 )
-	{
-		int  readVertex = 0;
-		bool skipFirstEdge = false;
+    // iterate through the triangles
+    for ( Ty* triangle = triangles; triangle < triangleEnd; triangle += 3 )
+    {
+        int  readVertex = 0;
+        bool skipFirstEdge = false;
 
-		while ( readVertex < 3 )
-		{
-			IndexBufferCodes code = static_cast< IndexBufferCodes >( input.Read( IB_VERTEX_CODE_BITS ) );
+        while ( readVertex < 3 )
+        {
+            IndexBufferCodes code = static_cast< IndexBufferCodes >( input.Read( IB_VERTEX_CODE_BITS ) );
 
-			switch ( code )
-			{
-			case IB_NEW_VERTEX:
+            switch ( code )
+            {
+            case IB_NEW_VERTEX:
 
-				vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
-				triangle[ readVertex ]                        = static_cast< Ty >(  newVertices );
+                vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
+                triangle[ readVertex ]                        = static_cast< Ty >(  newVertices );
 
-				++readVertex;
-				++verticesRead;
-				++newVertices;
+                ++readVertex;
+                ++verticesRead;
+                ++newVertices;
 
-				break;
+                break;
 
-			case IB_CACHED_EDGE:
+            case IB_CACHED_EDGE:
 
-			{
-				assert( readVertex == 0 );
+            {
+                assert( readVertex == 0 );
 
-				uint32_t    fifoIndex = input.Read( CACHED_EDGE_BITS );
-				const Edge& edge      = edgeFifo[ ( ( edgesRead - 1 ) - fifoIndex ) & EDGE_FIFO_MASK ];
+                uint32_t    fifoIndex = input.Read( CACHED_EDGE_BITS );
+                const Edge& edge      = edgeFifo[ ( ( edgesRead - 1 ) - fifoIndex ) & EDGE_FIFO_MASK ];
 
-				triangle[ 0 ] = static_cast< Ty >( edge.second );
-				triangle[ 1 ] = static_cast< Ty >( edge.first );
+                triangle[ 0 ] = static_cast< Ty >( edge.second );
+                triangle[ 1 ] = static_cast< Ty >( edge.first );
 
-				readVertex    += 2;
-				skipFirstEdge  = true;
+                readVertex    += 2;
+                skipFirstEdge  = true;
 
-				break;
-			}
+                break;
+            }
 
-			case IB_CACHED_VERTEX:
+            case IB_CACHED_VERTEX:
 
-			{
-				uint32_t fifoIndex     = input.Read( CACHED_VERTEX_BITS );
-				
-				triangle[ readVertex ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - fifoIndex ) & VERTEX_FIFO_MASK ] );
+            {
+                uint32_t fifoIndex     = input.Read( CACHED_VERTEX_BITS );
+                
+                triangle[ readVertex ] = static_cast< Ty >( vertexFifo[ ( ( verticesRead - 1 ) - fifoIndex ) & VERTEX_FIFO_MASK ] );
 
-				++readVertex;
+                ++readVertex;
 
-				break;
-			}
+                break;
+            }
 
-			case IB_FREE_VERTEX:
+            case IB_FREE_VERTEX:
 
-			{
-				uint32_t relativeVertex = input.ReadVInt();
+            {
+                uint32_t relativeVertex = input.ReadVInt();
 
-				uint32_t vertex = ( newVertices - 1 ) - relativeVertex;
+                uint32_t vertex = ( newVertices - 1 ) - relativeVertex;
 
-				vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
-				triangle[ readVertex ]                        = static_cast< Ty >( vertex );
+                vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] =
+                triangle[ readVertex ]                        = static_cast< Ty >( vertex );
 
-				++verticesRead;
-				++readVertex;
-				break;
-			}
-			}
-		}
+                ++verticesRead;
+                ++readVertex;
+                break;
+            }
+            }
+        }
 
-		if ( !skipFirstEdge )
-		{
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
+        if ( !skipFirstEdge )
+        {
+            edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] );
 
-			++edgesRead;
-		}
-		else // first 2 verts were an edge case, so insert them into the vertex fifo. 
-		{
-			vertexFifo[ verticesRead & EDGE_FIFO_MASK ] = triangle[ 0 ];
+            ++edgesRead;
+        }
+        else // first 2 verts were an edge case, so insert them into the vertex fifo. 
+        {
+            vertexFifo[ verticesRead & EDGE_FIFO_MASK ] = triangle[ 0 ];
 
-			++verticesRead;
+            ++verticesRead;
 
-			vertexFifo[ verticesRead & EDGE_FIFO_MASK ] = triangle[ 1 ];
+            vertexFifo[ verticesRead & EDGE_FIFO_MASK ] = triangle[ 1 ];
 
-			++verticesRead;
-		}
+            ++verticesRead;
+        }
 
-		edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] );
+        edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] );
 
-		++edgesRead;
+        ++edgesRead;
 
-		edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] );
+        edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] );
 
-		++edgesRead;
-	}
+        ++edgesRead;
+    }
 }
 
 template < typename Ty >
 void DecompressIndexBuffer( Ty* triangles, uint32_t triangleCount, ReadBitstream& input )
 {
-	IndexBufferCompressionFormat format = static_cast< IndexBufferCompressionFormat >( input.ReadVInt() );
+    IndexBufferCompressionFormat format = static_cast< IndexBufferCompressionFormat >( input.ReadVInt() );
 
-	switch ( format )
-	{
-	case IBCF_PER_INDICE_1:
+    switch ( format )
+    {
+    case IBCF_PER_INDICE_1:
 
-		DecompressIndiceCodes1<Ty>( triangles, triangleCount, input );
-		break;
+        DecompressIndiceCodes1<Ty>( triangles, triangleCount, input );
+        break;
 
-	case IBCF_PER_TRIANGLE_1:
+    case IBCF_PER_TRIANGLE_1:
 
-		DecompressTriangleCodes1<Ty>( triangles, triangleCount, input );
-		break;
+        DecompressTriangleCodes1<Ty>( triangles, triangleCount, input );
+        break;
 
-	default: // ICBF_AUTO:
-		break;
-	}
+    default: // ICBF_AUTO:
+        break;
+    }
 }
 
 void DecompressIndexBuffer( uint32_t* triangles, uint32_t triangleCount, ReadBitstream& input )
 {
-	DecompressIndexBuffer<uint32_t>( triangles, triangleCount, input );
+    DecompressIndexBuffer<uint32_t>( triangles, triangleCount, input );
 }
 
 void DecompressIndexBuffer( uint16_t* triangles, uint32_t triangleCount, ReadBitstream& input )
 {
-	DecompressIndexBuffer<uint16_t>( triangles, triangleCount, input );
+    DecompressIndexBuffer<uint16_t>( triangles, triangleCount, input );
 }

3rdparty/ib-compress/indexcompressionconstants.h

@@ -43,52 +43,52 @@ const int IB_TRIANGLE_CODE_BITS = 4;
 // Edge in the edge fifo.
 struct Edge
 {
-	void set( uint32_t f, uint32_t s )
-	{
-		first  = f;
-		second = s;
-	}
+    void set( uint32_t f, uint32_t s )
+    {
+        first  = f;
+        second = s;
+    }
 
-	uint32_t first;
-	uint32_t second;
+    uint32_t first;
+    uint32_t second;
 };
 
 // These are the vertex/edge codes for CompressIndexBuffer
 enum IndexBufferCodes
 {
-	// Represents a yet un-seen vertex.
-	IB_NEW_VERTEX    = 0,
+    // Represents a yet un-seen vertex.
+    IB_NEW_VERTEX    = 0,
 
-	// Represents 2 vertices on an edge in the edge fifo, which will be used as the first 2 vertices of the
-	// triangle.
-	IB_CACHED_EDGE   = 1,
-	
-	// Represents a vertex that has been seen recently and is still in the vertex fifo.
-	IB_CACHED_VERTEX = 2,
+    // Represents 2 vertices on an edge in the edge fifo, which will be used as the first 2 vertices of the
+    // triangle.
+    IB_CACHED_EDGE   = 1,
+    
+    // Represents a vertex that has been seen recently and is still in the vertex fifo.
+    IB_CACHED_VERTEX = 2,
 
-	// Represents a vertex that has been seen 
-	IB_FREE_VERTEX   = 3
+    // Represents a vertex that has been seen 
+    IB_FREE_VERTEX   = 3
 };
 
 // These are the triangle codes for CompressIndexBuffer2
 enum IndexBufferTriangleCodes
 {
-	IB_EDGE_NEW = 0,
-	IB_EDGE_CACHED = 1,
-	IB_EDGE_FREE = 2,
-	IB_NEW_NEW_NEW = 3,
-	IB_NEW_NEW_CACHED = 4,
-	IB_NEW_NEW_FREE = 5,
-	IB_NEW_CACHED_CACHED = 6,
-	IB_NEW_CACHED_FREE= 7,
-	IB_NEW_FREE_CACHED = 8,
-	IB_NEW_FREE_FREE = 9,
-	IB_CACHED_CACHED_CACHED = 10,
-	IB_CACHED_CACHED_FREE = 11,
-	IB_CACHED_FREE_FREE = 12,
-	IB_FREE_FREE_FREE = 13,
-	IB_EDGE_0_NEW = 14,
-	IB_EDGE_1_NEW = 15
+    IB_EDGE_NEW = 0,
+    IB_EDGE_CACHED = 1,
+    IB_EDGE_FREE = 2,
+    IB_NEW_NEW_NEW = 3,
+    IB_NEW_NEW_CACHED = 4,
+    IB_NEW_NEW_FREE = 5,
+    IB_NEW_CACHED_CACHED = 6,
+    IB_NEW_CACHED_FREE= 7,
+    IB_NEW_FREE_CACHED = 8,
+    IB_NEW_FREE_FREE = 9,
+    IB_CACHED_CACHED_CACHED = 10,
+    IB_CACHED_CACHED_FREE = 11,
+    IB_CACHED_FREE_FREE = 12,
+    IB_FREE_FREE_FREE = 13,
+    IB_EDGE_0_NEW = 14,
+    IB_EDGE_1_NEW = 15
 };
 
 #endif 

3rdparty/ib-compress/readbitstream.h

@@ -44,103 +44,103 @@ class ReadBitstream
 {
 public:
 
-	// Construct the bitstream with a fixed byte buffer (which should be padded out to multiples of 8 bytes, as we read in 8 byte chunks).
-	ReadBitstream( const uint8_t* buffer, size_t bufferSize );
+    // Construct the bitstream with a fixed byte buffer (which should be padded out to multiples of 8 bytes, as we read in 8 byte chunks).
+    ReadBitstream( const uint8_t* buffer, size_t bufferSize );
 
-	~ReadBitstream() {}
+    ~ReadBitstream() {}
 
-	// Read a number of bits
-	uint32_t Read( uint32_t bitcount );
+    // Read a number of bits
+    uint32_t Read( uint32_t bitcount );
 
-	// Get the buffer size of this in bytes
-	size_t Size() const { return m_bufferSize; }
+    // Get the buffer size of this in bytes
+    size_t Size() const { return m_bufferSize; }
 
-	uint32_t ReadVInt();
+    uint32_t ReadVInt();
 
 private:
 
-	uint64_t m_bitBuffer;
+    uint64_t m_bitBuffer;
 
-	const uint8_t* m_buffer;
-	const uint8_t* m_cursor;
+    const uint8_t* m_buffer;
+    const uint8_t* m_cursor;
 
-	size_t m_bufferSize;
-	uint32_t m_bitsLeft;
+    size_t m_bufferSize;
+    uint32_t m_bitsLeft;
 
 };
 
 inline ReadBitstream::ReadBitstream( const uint8_t* buffer, size_t bufferSize )
 {
-	m_cursor     =
-	m_buffer     = buffer;
-	m_bufferSize = bufferSize;
-
-	if ( bufferSize >= 8 )
-	{
-		m_bitBuffer = m_cursor[ 0 ];
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 1 ] ) << 8;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 2 ] ) << 16;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 3 ] ) << 24;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 4 ] ) << 32;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 5 ] ) << 40;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 6 ] ) << 48;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 7 ] ) << 56;
-
-		m_cursor += 8;
-		m_bitsLeft = 64;
-	}
-	else
-	{
-		m_bitsLeft = 0;
-	}
+    m_cursor     =
+    m_buffer     = buffer;
+    m_bufferSize = bufferSize;
+
+    if ( bufferSize >= 8 )
+    {
+        m_bitBuffer = m_cursor[ 0 ];
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 1 ] ) << 8;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 2 ] ) << 16;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 3 ] ) << 24;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 4 ] ) << 32;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 5 ] ) << 40;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 6 ] ) << 48;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 7 ] ) << 56;
+
+        m_cursor += 8;
+        m_bitsLeft = 64;
+    }
+    else
+    {
+        m_bitsLeft = 0;
+    }
 }
 
 
 RBS_INLINE uint32_t ReadBitstream::Read( uint32_t bitCount )
 {
-	uint64_t mask   = ( uint64_t( 1 ) << bitCount ) - 1;
-	uint32_t result = static_cast< uint32_t >( ( m_bitBuffer >> ( 64 - m_bitsLeft ) & ( m_bitsLeft == 0 ? 0 : 0xFFFFFFFFFFFFFFFF ) ) & mask );
-
-	if ( m_bitsLeft < bitCount )
-	{
-		m_bitBuffer = m_cursor[ 0 ];
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 1 ] ) << 8;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 2 ] ) << 16;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 3 ] ) << 24;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 4 ] ) << 32;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 5 ] ) << 40;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 6 ] ) << 48;
-		m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 7 ] ) << 56;
-
-		m_cursor += 8;
-
-		result     |= static_cast< uint32_t >( m_bitBuffer << m_bitsLeft ) & mask;
-		m_bitsLeft  = 64 - ( bitCount - m_bitsLeft );
-	}
-	else
-	{
-		m_bitsLeft -= bitCount;
-	}
-
-	return result;
+    uint64_t mask   = ( uint64_t( 1 ) << bitCount ) - 1;
+    uint32_t result = static_cast< uint32_t >( ( m_bitBuffer >> ( 64 - m_bitsLeft ) & ( m_bitsLeft == 0 ? 0 : 0xFFFFFFFFFFFFFFFF ) ) & mask );
+
+    if ( m_bitsLeft < bitCount )
+    {
+        m_bitBuffer = m_cursor[ 0 ];
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 1 ] ) << 8;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 2 ] ) << 16;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 3 ] ) << 24;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 4 ] ) << 32;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 5 ] ) << 40;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 6 ] ) << 48;
+        m_bitBuffer |= static_cast< uint64_t >( m_cursor[ 7 ] ) << 56;
+
+        m_cursor += 8;
+
+        result     |= static_cast< uint32_t >( m_bitBuffer << m_bitsLeft ) & mask;
+        m_bitsLeft  = 64 - ( bitCount - m_bitsLeft );
+    }
+    else
+    {
+        m_bitsLeft -= bitCount;
+    }
+
+    return result;
 }
 
 RBS_INLINE uint32_t ReadBitstream::ReadVInt()
 {
-	uint32_t bitsToShift = 0;
-	uint32_t result      = 0;
-	uint32_t readByte;
+    uint32_t bitsToShift = 0;
+    uint32_t result      = 0;
+    uint32_t readByte;
 
-	do
-	{
-		readByte = Read( 8 );
+    do
+    {
+        readByte = Read( 8 );
 
-		result |= ( readByte & 0x7F ) << bitsToShift;
-		bitsToShift += 7;
+        result |= ( readByte & 0x7F ) << bitsToShift;
+        bitsToShift += 7;
 
-	} while ( readByte & 0x80 );
+    } while ( readByte & 0x80 );
 
-	return result;
+    return result;
 }
 
 #endif // -- READ_BIT_STREAM_H__

3rdparty/ib-compress/writebitstream.h

@@ -41,138 +41,138 @@ class WriteBitstream
 {
 public:
 
-	// Construct the bit stream with an initial buffer capacity - should be a multiple of 8 and > 0 
-	WriteBitstream( size_t initialBufferCapacity = 16 )
-	{
-		m_bufferCursor =
-		m_buffer       = new uint8_t[ initialBufferCapacity ];
-		m_bufferEnd    = m_buffer + initialBufferCapacity;
-		m_size         = 0;
-		m_bitsLeft     = 64;
-		m_bitBuffer    = 0;
-	}
+    // Construct the bit stream with an initial buffer capacity - should be a multiple of 8 and > 0 
+    WriteBitstream( size_t initialBufferCapacity = 16 )
+    {
+        m_bufferCursor =
+        m_buffer       = new uint8_t[ initialBufferCapacity ];
+        m_bufferEnd    = m_buffer + initialBufferCapacity;
+        m_size         = 0;
+        m_bitsLeft     = 64;
+        m_bitBuffer    = 0;
+    }
 
-	~WriteBitstream()
-	{
-		delete[] m_buffer;
-	}
+    ~WriteBitstream()
+    {
+        delete[] m_buffer;
+    }
 
-	// Size in bits.
-	size_t Size() const { return m_size; }
+    // Size in bits.
+    size_t Size() const { return m_size; }
 
-	// Write a number of bits to the stream.
-	void Write( uint32_t value, uint32_t bitCount );
+    // Write a number of bits to the stream.
+    void Write( uint32_t value, uint32_t bitCount );
 
-	// Write a V int to the stream.
-	void WriteVInt( uint32_t value );
+    // Write a V int to the stream.
+    void WriteVInt( uint32_t value );
 
-	// Get the size in bytes 
-	size_t ByteSize() const { return ( m_size + 7 ) >> 3; }
+    // Get the size in bytes 
+    size_t ByteSize() const { return ( m_size + 7 ) >> 3; }
 
-	// Finish writing by flushing the buffer.
-	void Finish();
+    // Finish writing by flushing the buffer.
+    void Finish();
 
-	// Get the raw data for this buffer.
-	const uint8_t* RawData() const { return m_buffer; }
+    // Get the raw data for this buffer.
+    const uint8_t* RawData() const { return m_buffer; }
 
 private:
 
-	// If we need to grow the buffer.
-	void GrowBuffer();
+    // If we need to grow the buffer.
+    void GrowBuffer();
 
-	// Not copyable 
-	WriteBitstream( const WriteBitstream& );
+    // Not copyable 
+    WriteBitstream( const WriteBitstream& );
 
-	// Not assignable
-	WriteBitstream& operator=( const WriteBitstream& );
+    // Not assignable
+    WriteBitstream& operator=( const WriteBitstream& );
 
-	uint64_t  m_bitBuffer;
-	size_t    m_size;
-	uint8_t*  m_buffer;
-	uint8_t*  m_bufferCursor;
-	uint8_t*  m_bufferEnd;
-	uint32_t  m_bitsLeft;
+    uint64_t  m_bitBuffer;
+    size_t    m_size;
+    uint8_t*  m_buffer;
+    uint8_t*  m_bufferCursor;
+    uint8_t*  m_bufferEnd;
+    uint32_t  m_bitsLeft;
 };
 
 WBS_INLINE void WriteBitstream::Write( uint32_t value, uint32_t bitCount )
 {
     m_bitBuffer |= ( static_cast<uint64_t>( value ) << ( 64 - m_bitsLeft ) ) & ( m_bitsLeft == 0 ? 0 : 0xFFFFFFFFFFFFFFFF );
 
-	if ( bitCount > m_bitsLeft )
-	{
-		if ( m_bufferCursor > m_bufferEnd - 7 )
-		{
-			GrowBuffer();
-		}
+    if ( bitCount > m_bitsLeft )
+    {
+        if ( m_bufferCursor > m_bufferEnd - 7 )
+        {
+            GrowBuffer();
+        }
 
-		m_bufferCursor[ 0 ] = m_bitBuffer & 0xFF;
-		m_bufferCursor[ 1 ] = ( m_bitBuffer >> 8 ) & 0xFF;
-		m_bufferCursor[ 2 ] = ( m_bitBuffer >> 16 ) & 0xFF;
-		m_bufferCursor[ 3 ] = ( m_bitBuffer >> 24 ) & 0xFF;
-		m_bufferCursor[ 4 ] = ( m_bitBuffer >> 32 ) & 0xFF;
-		m_bufferCursor[ 5 ] = ( m_bitBuffer >> 40 ) & 0xFF;
-		m_bufferCursor[ 6 ] = ( m_bitBuffer >> 48 ) & 0xFF;
-		m_bufferCursor[ 7 ] = ( m_bitBuffer >> 56 ) & 0xFF;
+        m_bufferCursor[ 0 ] = m_bitBuffer & 0xFF;
+        m_bufferCursor[ 1 ] = ( m_bitBuffer >> 8 ) & 0xFF;
+        m_bufferCursor[ 2 ] = ( m_bitBuffer >> 16 ) & 0xFF;
+        m_bufferCursor[ 3 ] = ( m_bitBuffer >> 24 ) & 0xFF;
+        m_bufferCursor[ 4 ] = ( m_bitBuffer >> 32 ) & 0xFF;
+        m_bufferCursor[ 5 ] = ( m_bitBuffer >> 40 ) & 0xFF;
+        m_bufferCursor[ 6 ] = ( m_bitBuffer >> 48 ) & 0xFF;
+        m_bufferCursor[ 7 ] = ( m_bitBuffer >> 56 ) & 0xFF;
 
-		m_bufferCursor += 8;
+        m_bufferCursor += 8;
 
         m_bitBuffer = value >> ( m_bitsLeft );
-		m_bitsLeft  = 64 - ( bitCount - m_bitsLeft );
-	}
-	else
-	{
-		m_bitsLeft -= bitCount;
-	}
-
-	m_size += bitCount;
+        m_bitsLeft  = 64 - ( bitCount - m_bitsLeft );
+    }
+    else
+    {
+        m_bitsLeft -= bitCount;
+    }
+
+    m_size += bitCount;
 }
 
 WBS_INLINE void WriteBitstream::WriteVInt( uint32_t value )
 {
-	do
-	{
-		uint32_t lower7 = value & 0x7F;
+    do
+    {
+        uint32_t lower7 = value & 0x7F;
 
-		value >>= 7;
+        value >>= 7;
 
-		Write( lower7 | ( value > 0 ? 0x80 : 0 ), 8 );
+        Write( lower7 | ( value > 0 ? 0x80 : 0 ), 8 );
 
-	} while ( value > 0 );
+    } while ( value > 0 );
 }
 
 inline void WriteBitstream::Finish()
 {
-	if ( m_bufferCursor > m_bufferEnd - 8 )
-	{
-		GrowBuffer();
-	}
-
-	m_bufferCursor[ 0 ] = m_bitBuffer & 0xFF;
-	m_bufferCursor[ 1 ] = ( m_bitBuffer >> 8 ) & 0xFF;
-	m_bufferCursor[ 2 ] = ( m_bitBuffer >> 16 ) & 0xFF;
-	m_bufferCursor[ 3 ] = ( m_bitBuffer >> 24 ) & 0xFF;
-	m_bufferCursor[ 4 ] = ( m_bitBuffer >> 32 ) & 0xFF;
-	m_bufferCursor[ 5 ] = ( m_bitBuffer >> 40 ) & 0xFF;
-	m_bufferCursor[ 6 ] = ( m_bitBuffer >> 48 ) & 0xFF;
-	m_bufferCursor[ 7 ] = ( m_bitBuffer >> 56 ) & 0xFF;
-
-	m_bufferCursor += 8;
+    if ( m_bufferCursor > m_bufferEnd - 8 )
+    {
+        GrowBuffer();
+    }
+
+    m_bufferCursor[ 0 ] = m_bitBuffer & 0xFF;
+    m_bufferCursor[ 1 ] = ( m_bitBuffer >> 8 ) & 0xFF;
+    m_bufferCursor[ 2 ] = ( m_bitBuffer >> 16 ) & 0xFF;
+    m_bufferCursor[ 3 ] = ( m_bitBuffer >> 24 ) & 0xFF;
+    m_bufferCursor[ 4 ] = ( m_bitBuffer >> 32 ) & 0xFF;
+    m_bufferCursor[ 5 ] = ( m_bitBuffer >> 40 ) & 0xFF;
+    m_bufferCursor[ 6 ] = ( m_bitBuffer >> 48 ) & 0xFF;
+    m_bufferCursor[ 7 ] = ( m_bitBuffer >> 56 ) & 0xFF;
+
+    m_bufferCursor += 8;
 }
 
 WBS_INLINE void WriteBitstream::GrowBuffer()
 {
-	size_t    bufferSize     = m_bufferEnd - m_buffer;
-	size_t    newBufferSize  = bufferSize * 2;
-	size_t    bufferPosition = m_bufferCursor - m_buffer;
-	uint8_t*  newBuffer      = new uint8_t[ newBufferSize ];
+    size_t    bufferSize     = m_bufferEnd - m_buffer;
+    size_t    newBufferSize  = bufferSize * 2;
+    size_t    bufferPosition = m_bufferCursor - m_buffer;
+    uint8_t*  newBuffer      = new uint8_t[ newBufferSize ];
 
-	::memcpy( reinterpret_cast<void*>( newBuffer ), reinterpret_cast<void*>( m_buffer ), bufferSize );
+    ::memcpy( reinterpret_cast<void*>( newBuffer ), reinterpret_cast<void*>( m_buffer ), bufferSize );
 
-	delete[] m_buffer;
+    delete[] m_buffer;
 
-	m_buffer       = newBuffer;
-	m_bufferCursor = m_buffer + bufferPosition;
-	m_bufferEnd    = m_buffer + newBufferSize;
+    m_buffer       = newBuffer;
+    m_bufferCursor = m_buffer + bufferPosition;
+    m_bufferEnd    = m_buffer + newBufferSize;
 }
 
 #endif // -- WRITE_BIT_STREAM_H__