Fixed ib-compress to build with vs2008. Added 16-bit indices support.

3rdparty/ib-compress/IndexBufferCompession.cpp

@@ -101,33 +101,33 @@ static IBC_INLINE void OutputVertex( uint32_t vertex,
 
 }
 
-
-void CompressIndexBuffer( const uint32_t* triangles, 
+template <typename Ty>
+void CompressIndexBuffer( const Ty* triangles, 
 						  uint32_t triangleCount, 
 						  uint32_t* vertexRemap, 
 						  uint32_t vertexCount, 
 						  WriteBitstream& output )
 {
-	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 uint32_t* triangleEnd    = triangles + ( triangleCount * 3 );
+	uint32_t  edgesRead      = 0;
+	uint32_t  verticesRead   = 0;
+	uint32_t  newVertices    = 0;
+	const Ty* triangleEnd    = triangles + ( triangleCount * 3 );
 
 	assert( vertexCount < 0xFFFFFFFF );
 
-	uint32_t*       vertexRemapEnd = vertexRemap + vertexCount;
+	uint32_t* vertexRemapEnd = vertexRemap + vertexCount;
 
 	// clear the vertex remapping to "not found" value of 0xFFFFFFFF - dirty, but low overhead.
-	for ( auto remappedVertex = vertexRemap; remappedVertex < vertexRemapEnd; ++remappedVertex )
+	for (uint32_t* remappedVertex = vertexRemap; remappedVertex < vertexRemapEnd; ++remappedVertex )
 	{
 		*remappedVertex = VERTEX_NOT_MAPPED;
 	}
 
 	// iterate through the triangles
-	for ( auto triangle = triangles; triangle < triangleEnd; triangle += 3 )
+	for (const Ty* triangle = triangles; triangle < triangleEnd; triangle += 3 )
 	{
 		int32_t lowestEdgeCursor = edgesRead >= EDGE_FIFO_SIZE ? edgesRead - EDGE_FIFO_SIZE : 0;
 		int32_t edgeCursor = edgesRead - 1;
@@ -189,33 +189,33 @@ void CompressIndexBuffer( const uint32_t* triangles,
 			{
 			case 0:
 
-				edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 2 ], triangle[ 0 ] };
+				edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 2 ], triangle[ 0 ]);
 
 				++edgesRead;
 
-				edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 0 ], triangle[ 1 ] };
+				edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 0 ], triangle[ 1 ]);
 
 				++edgesRead;
 				break;
 
 			case 1:
 
-				edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 0 ], triangle[ 1 ] };
+				edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 0 ], triangle[ 1 ]);
 
 				++edgesRead;
 
-				edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 1 ], triangle[ 2 ] };
+				edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 1 ], triangle[ 2 ]);
 
 				++edgesRead;
 				break;
 
 			case 2:
 
-				edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 1 ], triangle[ 2 ] };
+				edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 1 ], triangle[ 2 ]);
 
 				++edgesRead;
 
-				edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 2 ], triangle[ 0 ] };
+				edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 2 ], triangle[ 0 ]);
 
 				++edgesRead;
 				break;
@@ -229,17 +229,35 @@ void CompressIndexBuffer( const uint32_t* triangles,
 			OutputVertex( triangle[ 2 ], vertexRemap, newVertices, vertexFifo, verticesRead, output );
 
 			// populate the edge fifo with the 3 most recent edges
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 0 ], triangle[ 1 ] };
+			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 0 ], triangle[ 1 ]);
 
 			++edgesRead;
 
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 1 ], triangle[ 2 ] };
+			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 1 ], triangle[ 2 ]);
 
 			++edgesRead;
 
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 2 ], triangle[ 0 ] };
+			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 2 ], triangle[ 0 ]);
 
 			++edgesRead;
 		}
 	}
 }
+
+void CompressIndexBuffer ( const uint16_t* triangles,
+						 uint32_t triangleCount, 
+						 uint32_t* vertexRemap, 
+						 uint32_t vertexCount, 
+						 WriteBitstream& output )
+{
+	CompressIndexBuffer<uint16_t>(triangles, triangleCount, vertexRemap, vertexCount, output);
+}
+
+void CompressIndexBuffer ( const uint32_t* triangles,
+						  uint32_t triangleCount, 
+						  uint32_t* vertexRemap, 
+						  uint32_t vertexCount, 
+						  WriteBitstream& output )
+{
+	CompressIndexBuffer<uint32_t>(triangles, triangleCount, vertexRemap, vertexCount, output);
+}

3rdparty/ib-compress/IndexBufferCompression.h

@@ -26,9 +26,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INDEX_BUFFER_COMPRESSION_H__
 #pragma once
 
-class WriteBitstream;
-
-#include <cstdint>
+#include <stdint.h>
+#include "writebitstream.h"
 
 // Compress an index buffer, writing the results out to a bitstream and providing a vertex remapping (which will be in pre-transform cache optimised
 // order.
@@ -42,6 +41,7 @@ class WriteBitstream;
 //     [in] vertexCount     - The number of vertices in the mesh. This should be less than 0xFFFFFFFF/2^32 - 1.
 //     [in] output          - The stream that the compressed data will be written to. Note that we will not flush/finish the stream
 //                            in case something else is going to be written after, so WriteBitstream::Finish will need to be called after this.
-void CompressIndexBuffer( const uint32_t* triangles, uint32_t triangleCount, uint32_t* vertexRemap, uint32_t vertexCount, WriteBitstream& output );
+template <typename Ty>
+void CompressIndexBuffer( const Ty* triangles, uint32_t triangleCount, uint32_t* vertexRemap, uint32_t vertexCount, WriteBitstream& output );
 
 #endif // -- INDEX_BUFFER_COMPRESSION_H__

3rdparty/ib-compress/IndexBufferDecompression.cpp

@@ -27,18 +27,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "IndexCompressionConstants.h"
 #include <assert.h>
 
-void DecompressIndexBuffer( uint32_t* triangles, uint32_t triangleCount, ReadBitstream& input )
+template <typename Ty>
+void DecompressIndexBuffer( 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 uint32_t* 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 ( uint32_t* triangle = triangles; triangle < triangleEnd; triangle += 3 )
+	for ( Ty* triangle = triangles; triangle < triangleEnd; triangle += 3 )
 	{
 		int  readVertex = 0;
 		bool skipFirstEdge = false;
@@ -120,7 +121,7 @@ void DecompressIndexBuffer( uint32_t* triangles, uint32_t triangleCount, ReadBit
 
 		if ( !skipFirstEdge )
 		{
-			edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 0 ], triangle[ 1 ] };
+			edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 0 ], triangle[ 1 ]);
 
 			++edgesRead;
 		}
@@ -135,12 +136,22 @@ void DecompressIndexBuffer( uint32_t* triangles, uint32_t triangleCount, ReadBit
 			++verticesRead;
 		}
 
-		edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 1 ], triangle[ 2 ] };
+		edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 1 ], triangle[ 2 ]);
 
 		++edgesRead;
 
-		edgeFifo[ edgesRead & EDGE_FIFO_MASK ] = { triangle[ 2 ], triangle[ 0 ] };
+		edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set(triangle[ 2 ], triangle[ 0 ]);
 
 		++edgesRead;
 	}
-}
+}
+
+void DecompressIndexBuffer( uint16_t* triangles, uint32_t triangleCount, ReadBitstream& input )
+{
+	DecompressIndexBuffer<uint16_t>( triangles, triangleCount, input );
+}
+
+void DecompressIndexBuffer( uint32_t* triangles, uint32_t triangleCount, ReadBitstream& input )
+{
+	DecompressIndexBuffer<uint32_t>( triangles, triangleCount, input );
+}

3rdparty/ib-compress/IndexBufferDecompression.h

@@ -26,9 +26,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INDEX_BUFFER_DECOMPRESSION_H__
 #pragma once
 
-#include <cstdint>
-
-class ReadBitstream;
+#include <stdint.h>
+#include "readbitstream.h"
 
 // Compress an index buffer, writing the results out to a bitstream and providing a vertex remapping (which will be in pre-transform cache optimised
 // order.
@@ -36,6 +35,7 @@ class ReadBitstream;
 //     [out] triangles      - Triangle list index buffer (3 indices to vertices per triangle), output from the decompression.
 //     [in]  triangle count - The number of triangles to decompress.
 //     [in]  input          - The bit stream that the compressed data will be read from.
-void DecompressIndexBuffer( uint32_t* triangles, uint32_t triangleCount, ReadBitstream& input );
+template <typename Ty>
+void DecompressIndexBuffer( Ty* triangles, uint32_t triangleCount, ReadBitstream& input );
 
 #endif // -- INDEX_BUFFER_DECOMPRESSION_H__

3rdparty/ib-compress/IndexCompressionConstants.h

@@ -38,6 +38,12 @@ const int IB_CODE_BITS       = 2;
 // Edge in the edge fifo.
 struct Edge
 {
+	void set(uint32_t f, uint32_t s)
+	{
+		first  = f;
+		second = s;
+	}
+
 	uint32_t first;
 	uint32_t second;
 };

3rdparty/ib-compress/ReadBitstream.h

@@ -26,7 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define READ_BIT_STREAM_H__
 #pragma once
 
-#include <cstdint>
+#include <stdint.h>
 
 #ifdef _MSC_VER
 

3rdparty/ib-compress/WriteBitstream.h

@@ -26,7 +26,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define WRITE_BIT_STREAM_H__
 #pragma once
 
-#include <cstdint>
+#include <stdint.h>
 #include <memory.h>
 
 #ifdef _MSC_VER