From 82bb7516c244f201a2540fff10913aa0e4e73ae8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Branimir=20Karad=C5=BEi=C4=87?= Date: Thu, 1 Jan 2015 12:09:57 -0800 Subject: [PATCH] Updated ib-compress. --- .../ib-compress/indexbuffercompression.cpp | 1212 ++++++++--------- .../indexbuffercompressionformat.h | 8 +- .../ib-compress/indexbufferdecompression.cpp | 736 +++++----- .../ib-compress/indexcompressionconstants.h | 66 +- 3rdparty/ib-compress/readbitstream.h | 128 +- 3rdparty/ib-compress/writebitstream.h | 176 +-- 6 files changed, 1163 insertions(+), 1163 deletions(-) diff --git a/3rdparty/ib-compress/indexbuffercompression.cpp b/3rdparty/ib-compress/indexbuffercompression.cpp index 5d4f56036..219466b52 100644 --- a/3rdparty/ib-compress/indexbuffercompression.cpp +++ b/3rdparty/ib-compress/indexbuffercompression.cpp @@ -36,126 +36,126 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Individual vertex type classifications. enum VertexClassification { - NEW_VERTEX = 0, - CACHED_VERTEX = 1, - FREE_VERTEX = 2 + NEW_VERTEX = 0, + CACHED_VERTEX = 1, + FREE_VERTEX = 2 }; // Individual case for handling a combination of vertice classifications. struct VertexCompressionCase { - IndexBufferTriangleCodes code; - uint32_t vertexOrder[ 3 ]; + IndexBufferTriangleCodes code; + uint32_t vertexOrder[ 3 ]; }; // This is a table for looking up the appropriate code and rotation for a set of vertex classifications. const VertexCompressionCase CompressionCase[3][3][3] = { - { // new - { // new new - { // new new new - IB_NEW_NEW_NEW, { 0, 1, 2 } - }, - { // new new cached - IB_NEW_NEW_CACHED, { 0, 1, 2 } - }, - { // new new free - IB_NEW_NEW_FREE, { 0, 1, 2 } - } - }, - { // new cached - { // new cached new - IB_NEW_NEW_CACHED, { 2, 0, 1 } - }, - { // new cached cached - IB_NEW_CACHED_CACHED, { 0, 1, 2 } - }, - { // new cached free - IB_NEW_CACHED_FREE, { 0, 1, 2 } - } - }, - { // new free - { // new free new - IB_NEW_NEW_FREE, { 2, 0, 1 } - }, - { // new free cached - IB_NEW_FREE_CACHED, { 0, 1, 2 } - }, - { // new free free - IB_NEW_FREE_FREE, { 0, 1, 2 } - } - } - }, - { // cached - { // cached new - { // cached new new - IB_NEW_NEW_CACHED, { 1, 2, 0 } - }, - { // cached new cached - IB_NEW_CACHED_CACHED, { 1, 2, 0 } - }, - { // cached new free - IB_NEW_FREE_CACHED, { 1, 2, 0 } - } - }, - { // cached cached - { // cached cached new - IB_NEW_CACHED_CACHED, { 2, 0, 1 } - }, - { // cached cached cached - IB_CACHED_CACHED_CACHED, { 0, 1, 2 } - }, - { // cached cached free - IB_CACHED_CACHED_FREE, { 0, 1, 2 } - } - }, - { // cached free - { // cached free new - IB_NEW_CACHED_FREE, { 2, 0, 1 } - }, - { // cached free cached - IB_CACHED_CACHED_FREE, { 2, 0, 1 } - }, - { // cached free free - IB_CACHED_FREE_FREE, { 0, 1, 2 } - } - } - }, - { // free - { // free new - { // free new new - IB_NEW_NEW_FREE, { 1, 2, 0 } - }, - { // free new cached - IB_NEW_CACHED_FREE, { 1, 2, 0 } - }, - { // free new free - IB_NEW_FREE_FREE, { 1, 2, 0 } - } - }, - { // free cached - { // free cached new - IB_NEW_FREE_CACHED, { 2, 0, 1 } - }, - { // free cached cached - IB_CACHED_CACHED_FREE, { 1, 2, 0 } - }, - { // free cached free - IB_CACHED_FREE_FREE, { 1, 2, 0 } - } - }, - { // free free - { // free free new - IB_NEW_FREE_FREE, { 2, 0, 1 } - }, - { // free free cached - IB_CACHED_FREE_FREE, { 2, 0, 1 } - }, - { // free free free - IB_FREE_FREE_FREE, { 0, 1, 2 } - } - } - } + { // new + { // new new + { // new new new + IB_NEW_NEW_NEW, { 0, 1, 2 } + }, + { // new new cached + IB_NEW_NEW_CACHED, { 0, 1, 2 } + }, + { // new new free + IB_NEW_NEW_FREE, { 0, 1, 2 } + } + }, + { // new cached + { // new cached new + IB_NEW_NEW_CACHED, { 2, 0, 1 } + }, + { // new cached cached + IB_NEW_CACHED_CACHED, { 0, 1, 2 } + }, + { // new cached free + IB_NEW_CACHED_FREE, { 0, 1, 2 } + } + }, + { // new free + { // new free new + IB_NEW_NEW_FREE, { 2, 0, 1 } + }, + { // new free cached + IB_NEW_FREE_CACHED, { 0, 1, 2 } + }, + { // new free free + IB_NEW_FREE_FREE, { 0, 1, 2 } + } + } + }, + { // cached + { // cached new + { // cached new new + IB_NEW_NEW_CACHED, { 1, 2, 0 } + }, + { // cached new cached + IB_NEW_CACHED_CACHED, { 1, 2, 0 } + }, + { // cached new free + IB_NEW_FREE_CACHED, { 1, 2, 0 } + } + }, + { // cached cached + { // cached cached new + IB_NEW_CACHED_CACHED, { 2, 0, 1 } + }, + { // cached cached cached + IB_CACHED_CACHED_CACHED, { 0, 1, 2 } + }, + { // cached cached free + IB_CACHED_CACHED_FREE, { 0, 1, 2 } + } + }, + { // cached free + { // cached free new + IB_NEW_CACHED_FREE, { 2, 0, 1 } + }, + { // cached free cached + IB_CACHED_CACHED_FREE, { 2, 0, 1 } + }, + { // cached free free + IB_CACHED_FREE_FREE, { 0, 1, 2 } + } + } + }, + { // free + { // free new + { // free new new + IB_NEW_NEW_FREE, { 1, 2, 0 } + }, + { // free new cached + IB_NEW_CACHED_FREE, { 1, 2, 0 } + }, + { // free new free + IB_NEW_FREE_FREE, { 1, 2, 0 } + } + }, + { // free cached + { // free cached new + IB_NEW_FREE_CACHED, { 2, 0, 1 } + }, + { // free cached cached + IB_CACHED_CACHED_FREE, { 1, 2, 0 } + }, + { // free cached free + IB_CACHED_FREE_FREE, { 1, 2, 0 } + } + }, + { // free free + { // free free new + IB_NEW_FREE_FREE, { 2, 0, 1 } + }, + { // free free cached + IB_CACHED_FREE_FREE, { 2, 0, 1 } + }, + { // free free free + IB_FREE_FREE_FREE, { 0, 1, 2 } + } + } + } }; const uint32_t VERTEX_NOT_MAPPED = 0xFFFFFFFF; @@ -163,588 +163,588 @@ const uint32_t VERTEX_NOT_MAPPED = 0xFFFFFFFF; // Classify a vertex as new, cached or free, outputting the relative position in the vertex indice cache FIFO. static IBC_INLINE VertexClassification ClassifyVertex( uint32_t vertex, const uint32_t* vertexRemap, const uint32_t* vertexFifo, uint32_t verticesRead, uint32_t& cachedVertexIndex ) { - if ( vertexRemap[ vertex ] == VERTEX_NOT_MAPPED ) - { - return NEW_VERTEX; - } - else - { - int32_t lowestVertexCursor = verticesRead >= VERTEX_FIFO_SIZE ? verticesRead - VERTEX_FIFO_SIZE : 0; + if ( vertexRemap[ vertex ] == VERTEX_NOT_MAPPED ) + { + return NEW_VERTEX; + } + else + { + int32_t lowestVertexCursor = verticesRead >= VERTEX_FIFO_SIZE ? verticesRead - VERTEX_FIFO_SIZE : 0; - // Probe backwards in the vertex FIFO for a cached vertex - for ( int32_t vertexCursor = verticesRead - 1; vertexCursor >= lowestVertexCursor; --vertexCursor ) - { - if ( vertexFifo[ vertexCursor & VERTEX_FIFO_MASK ] == vertex ) - { - cachedVertexIndex = ( verticesRead - 1 ) - vertexCursor; + // Probe backwards in the vertex FIFO for a cached vertex + for ( int32_t vertexCursor = verticesRead - 1; vertexCursor >= lowestVertexCursor; --vertexCursor ) + { + if ( vertexFifo[ vertexCursor & VERTEX_FIFO_MASK ] == vertex ) + { + cachedVertexIndex = ( verticesRead - 1 ) - vertexCursor; - return CACHED_VERTEX; - } - } + return CACHED_VERTEX; + } + } - return FREE_VERTEX; - } + return FREE_VERTEX; + } } template void CompressTriangleCodes1( const Ty* triangles, - uint32_t triangleCount, - uint32_t* vertexRemap, - uint32_t vertexCount, - WriteBitstream& output ) + uint32_t triangleCount, + uint32_t* vertexRemap, + uint32_t vertexCount, + WriteBitstream& output ) { - 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 ); - - assert( vertexCount < 0xFFFFFFFF ); - - uint32_t* vertexRemapEnd = vertexRemap + vertexCount; - - // clear the vertex remapping to "not found" value of 0xFFFFFFFF - dirty, but low overhead. - for ( uint32_t* remappedVertex = vertexRemap; remappedVertex < vertexRemapEnd; ++remappedVertex ) - { - *remappedVertex = VERTEX_NOT_MAPPED; - } - - // iterate through the triangles - 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; - bool foundEdge = false; - - int32_t spareVertex = 0; - - // check to make sure that there are no degenerate triangles. - assert( triangle[ 0 ] != triangle[ 1 ] && triangle[ 1 ] != triangle[ 2 ] && triangle[ 2 ] != triangle[ 0 ] ); - - // Probe back through the edge fifo to see if one of the triangle edges is in the FIFO - for ( ; edgeCursor >= lowestEdgeCursor; --edgeCursor ) - { - const Edge& edge = edgeFifo[ edgeCursor & EDGE_FIFO_MASK ]; - - // check all the edges in order and save the free vertex. - if ( edge.second == triangle[ 0 ] && edge.first == triangle[ 1 ] ) - { - foundEdge = true; - spareVertex = 2; - break; - } - else if ( edge.second == triangle[ 1 ] && edge.first == triangle[ 2 ] ) - { - foundEdge = true; - spareVertex = 0; - break; - } - else if ( edge.second == triangle[ 2 ] && edge.first == triangle[ 0 ] ) - { - foundEdge = true; - spareVertex = 1; - break; - } - } + 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 ); + + assert( vertexCount < 0xFFFFFFFF ); + + uint32_t* vertexRemapEnd = vertexRemap + vertexCount; + + // clear the vertex remapping to "not found" value of 0xFFFFFFFF - dirty, but low overhead. + for ( uint32_t* remappedVertex = vertexRemap; remappedVertex < vertexRemapEnd; ++remappedVertex ) + { + *remappedVertex = VERTEX_NOT_MAPPED; + } + + // iterate through the triangles + 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; + bool foundEdge = false; + + int32_t spareVertex = 0; + + // check to make sure that there are no degenerate triangles. + assert( triangle[ 0 ] != triangle[ 1 ] && triangle[ 1 ] != triangle[ 2 ] && triangle[ 2 ] != triangle[ 0 ] ); + + // Probe back through the edge fifo to see if one of the triangle edges is in the FIFO + for ( ; edgeCursor >= lowestEdgeCursor; --edgeCursor ) + { + const Edge& edge = edgeFifo[ edgeCursor & EDGE_FIFO_MASK ]; + + // check all the edges in order and save the free vertex. + if ( edge.second == triangle[ 0 ] && edge.first == triangle[ 1 ] ) + { + foundEdge = true; + spareVertex = 2; + break; + } + else if ( edge.second == triangle[ 1 ] && edge.first == triangle[ 2 ] ) + { + foundEdge = true; + spareVertex = 0; + break; + } + else if ( edge.second == triangle[ 2 ] && edge.first == triangle[ 0 ] ) + { + foundEdge = true; + spareVertex = 1; + break; + } + } - // we found an edge so write it out, so classify a vertex and then write out the correct code. - if ( foundEdge ) - { - uint32_t cachedVertex; - - uint32_t spareVertexIndice = triangle[ spareVertex ]; - VertexClassification freeVertexClass = ClassifyVertex( spareVertexIndice, vertexRemap, vertexFifo, verticesRead, cachedVertex ); - uint32_t relativeEdge = ( edgesRead - 1 ) - edgeCursor; + // we found an edge so write it out, so classify a vertex and then write out the correct code. + if ( foundEdge ) + { + uint32_t cachedVertex; + + uint32_t spareVertexIndice = triangle[ spareVertex ]; + VertexClassification freeVertexClass = ClassifyVertex( spareVertexIndice, vertexRemap, vertexFifo, verticesRead, cachedVertex ); + uint32_t relativeEdge = ( edgesRead - 1 ) - edgeCursor; - switch ( freeVertexClass ) - { - case NEW_VERTEX: - - switch ( relativeEdge ) - { - case 0: + switch ( freeVertexClass ) + { + case NEW_VERTEX: + + switch ( relativeEdge ) + { + case 0: - output.Write( IB_EDGE_0_NEW, IB_TRIANGLE_CODE_BITS ); - break; - - case 1: + output.Write( IB_EDGE_0_NEW, IB_TRIANGLE_CODE_BITS ); + break; + + case 1: - output.Write( IB_EDGE_1_NEW, IB_TRIANGLE_CODE_BITS ); - break; + output.Write( IB_EDGE_1_NEW, IB_TRIANGLE_CODE_BITS ); + break; - default: + default: - output.Write( IB_EDGE_NEW, IB_TRIANGLE_CODE_BITS ); - output.Write( relativeEdge, CACHED_EDGE_BITS ); - break; + output.Write( IB_EDGE_NEW, IB_TRIANGLE_CODE_BITS ); + output.Write( relativeEdge, CACHED_EDGE_BITS ); + break; - } - - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = spareVertexIndice; - vertexRemap[ spareVertexIndice ] = newVertices; - - ++verticesRead; - ++newVertices; - break; - - case CACHED_VERTEX: - - output.Write( IB_EDGE_CACHED, IB_TRIANGLE_CODE_BITS ); - output.Write( relativeEdge, CACHED_EDGE_BITS ); - output.Write( cachedVertex, CACHED_VERTEX_BITS ); - break; + } + + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = spareVertexIndice; + vertexRemap[ spareVertexIndice ] = newVertices; + + ++verticesRead; + ++newVertices; + break; + + case CACHED_VERTEX: + + output.Write( IB_EDGE_CACHED, IB_TRIANGLE_CODE_BITS ); + output.Write( relativeEdge, CACHED_EDGE_BITS ); + output.Write( cachedVertex, CACHED_VERTEX_BITS ); + break; - case FREE_VERTEX: - - output.Write( IB_EDGE_FREE, IB_TRIANGLE_CODE_BITS ); - output.Write( relativeEdge, CACHED_EDGE_BITS ); + case FREE_VERTEX: + + output.Write( IB_EDGE_FREE, IB_TRIANGLE_CODE_BITS ); + output.Write( relativeEdge, CACHED_EDGE_BITS ); - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = spareVertexIndice; + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = spareVertexIndice; - ++verticesRead; - - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ spareVertexIndice ] ); - break; - - } - - // Populate the edge fifo with the the remaining edges - // Note - the winding order is important as we'll need to re-produce this on decompression. - // The edges are put in as if the found edge is the first edge in the triangle (which it will be when we - // reconstruct). - switch ( spareVertex ) - { - case 0: + ++verticesRead; + + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ spareVertexIndice ] ); + break; + + } + + // Populate the edge fifo with the the remaining edges + // Note - the winding order is important as we'll need to re-produce this on decompression. + // The edges are put in as if the found edge is the first edge in the triangle (which it will be when we + // reconstruct). + switch ( spareVertex ) + { + case 0: - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] ); - ++edgesRead; - - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); - - ++edgesRead; - break; + ++edgesRead; + + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); + + ++edgesRead; + break; - case 1: - - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); + case 1: + + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); - ++edgesRead; + ++edgesRead; - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] ); - ++edgesRead; - break; + ++edgesRead; + break; - case 2: + case 2: - 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; - break; - } - } - else - { - VertexClassification classifications[ 3 ]; - uint32_t cachedVertexIndices[ 3 ]; + ++edgesRead; + break; + } + } + else + { + VertexClassification classifications[ 3 ]; + uint32_t cachedVertexIndices[ 3 ]; - // classify each vertex as new, cached or free, potentially extracting a cached indice. - classifications[ 0 ] = ClassifyVertex( triangle[ 0 ], vertexRemap, vertexFifo, verticesRead, cachedVertexIndices[ 0 ] ); - classifications[ 1 ] = ClassifyVertex( triangle[ 1 ], vertexRemap, vertexFifo, verticesRead, cachedVertexIndices[ 1 ] ); - classifications[ 2 ] = ClassifyVertex( triangle[ 2 ], vertexRemap, vertexFifo, verticesRead, cachedVertexIndices[ 2 ] ); + // classify each vertex as new, cached or free, potentially extracting a cached indice. + classifications[ 0 ] = ClassifyVertex( triangle[ 0 ], vertexRemap, vertexFifo, verticesRead, cachedVertexIndices[ 0 ] ); + classifications[ 1 ] = ClassifyVertex( triangle[ 1 ], vertexRemap, vertexFifo, verticesRead, cachedVertexIndices[ 1 ] ); + classifications[ 2 ] = ClassifyVertex( triangle[ 2 ], vertexRemap, vertexFifo, verticesRead, cachedVertexIndices[ 2 ] ); - // use the classifications to lookup the matching compression code and potentially rotate the order of the vertices. - const VertexCompressionCase& compressionCase = CompressionCase[ classifications[ 0 ] ][ classifications[ 1 ] ][ classifications[ 2 ] ]; - - // rotate the order of the vertices based on the compression classification. - uint32_t reorderedTriangle[ 3 ]; - - reorderedTriangle[ 0 ] = triangle[ compressionCase.vertexOrder[ 0 ] ]; - reorderedTriangle[ 1 ] = triangle[ compressionCase.vertexOrder[ 1 ] ]; - reorderedTriangle[ 2 ] = triangle[ compressionCase.vertexOrder[ 2 ] ]; + // use the classifications to lookup the matching compression code and potentially rotate the order of the vertices. + const VertexCompressionCase& compressionCase = CompressionCase[ classifications[ 0 ] ][ classifications[ 1 ] ][ classifications[ 2 ] ]; + + // rotate the order of the vertices based on the compression classification. + uint32_t reorderedTriangle[ 3 ]; + + reorderedTriangle[ 0 ] = triangle[ compressionCase.vertexOrder[ 0 ] ]; + reorderedTriangle[ 1 ] = triangle[ compressionCase.vertexOrder[ 1 ] ]; + reorderedTriangle[ 2 ] = triangle[ compressionCase.vertexOrder[ 2 ] ]; - output.Write( compressionCase.code, IB_TRIANGLE_CODE_BITS ); + output.Write( compressionCase.code, IB_TRIANGLE_CODE_BITS ); - switch ( compressionCase.code ) - { - case IB_NEW_NEW_NEW: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = triangle[ 0 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = triangle[ 1 ]; - vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = triangle[ 2 ]; + switch ( compressionCase.code ) + { + case IB_NEW_NEW_NEW: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = triangle[ 0 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = triangle[ 1 ]; + vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = triangle[ 2 ]; - vertexRemap[ triangle[ 0 ] ] = newVertices; - vertexRemap[ triangle[ 1 ] ] = newVertices + 1; - vertexRemap[ triangle[ 2 ] ] = newVertices + 2; + vertexRemap[ triangle[ 0 ] ] = newVertices; + vertexRemap[ triangle[ 1 ] ] = newVertices + 1; + vertexRemap[ triangle[ 2 ] ] = newVertices + 2; - verticesRead += 3; - newVertices += 3; + verticesRead += 3; + newVertices += 3; - break; - } - case IB_NEW_NEW_CACHED: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; + break; + } + case IB_NEW_NEW_CACHED: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); - vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; - vertexRemap[ reorderedTriangle[ 1 ] ] = newVertices + 1; + vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; + vertexRemap[ reorderedTriangle[ 1 ] ] = newVertices + 1; - verticesRead += 2; - newVertices += 2; + verticesRead += 2; + newVertices += 2; - break; - } - case IB_NEW_NEW_FREE: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; - vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; + break; + } + case IB_NEW_NEW_FREE: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; + vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); - vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; - vertexRemap[ reorderedTriangle[ 1 ] ] = newVertices + 1; + vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; + vertexRemap[ reorderedTriangle[ 1 ] ] = newVertices + 1; - verticesRead += 3; - newVertices += 2; + verticesRead += 3; + newVertices += 2; - break; - } - case IB_NEW_CACHED_CACHED: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; - - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); - - vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; - verticesRead += 1; - newVertices += 1; - - break; - } - case IB_NEW_CACHED_FREE: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; - - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); - - vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; - - verticesRead += 2; - newVertices += 1; - - break; - } - case IB_NEW_FREE_CACHED: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; - - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); - - vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; - - verticesRead += 2; - newVertices += 1; - - break; - } - case IB_NEW_FREE_FREE: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; - vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; - - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); - - vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; - - verticesRead += 3; - newVertices += 1; - - break; - } - case IB_CACHED_CACHED_CACHED: - { - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 0 ] ], CACHED_VERTEX_BITS ); - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); - break; - } - case IB_CACHED_CACHED_FREE: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; - - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 0 ] ], CACHED_VERTEX_BITS ); - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); - - verticesRead += 1; - - break; - } - case IB_CACHED_FREE_FREE: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; - - output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 0 ] ], CACHED_VERTEX_BITS ); - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); - - verticesRead += 2; - - break; - } - case IB_FREE_FREE_FREE: - { - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; - vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; - vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; - - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 0 ] ] ); - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); - output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); - - verticesRead += 3; - break; - } + break; + } + case IB_NEW_CACHED_CACHED: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; + + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); + + vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; + verticesRead += 1; + newVertices += 1; + + break; + } + case IB_NEW_CACHED_FREE: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; + + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); + + vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; + + verticesRead += 2; + newVertices += 1; + + break; + } + case IB_NEW_FREE_CACHED: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; + + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); + + vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; + + verticesRead += 2; + newVertices += 1; + + break; + } + case IB_NEW_FREE_FREE: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; + vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; + + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); + + vertexRemap[ reorderedTriangle[ 0 ] ] = newVertices; + + verticesRead += 3; + newVertices += 1; + + break; + } + case IB_CACHED_CACHED_CACHED: + { + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 0 ] ], CACHED_VERTEX_BITS ); + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 2 ] ], CACHED_VERTEX_BITS ); + break; + } + case IB_CACHED_CACHED_FREE: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; + + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 0 ] ], CACHED_VERTEX_BITS ); + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 1 ] ], CACHED_VERTEX_BITS ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); + + verticesRead += 1; + + break; + } + case IB_CACHED_FREE_FREE: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; + + output.Write( cachedVertexIndices[ compressionCase.vertexOrder[ 0 ] ], CACHED_VERTEX_BITS ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); + + verticesRead += 2; + + break; + } + case IB_FREE_FREE_FREE: + { + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = reorderedTriangle[ 0 ]; + vertexFifo[ ( verticesRead + 1 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 1 ]; + vertexFifo[ ( verticesRead + 2 ) & VERTEX_FIFO_MASK ] = reorderedTriangle[ 2 ]; + + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 0 ] ] ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 1 ] ] ); + output.WriteVInt( ( newVertices - 1 ) - vertexRemap[ reorderedTriangle[ 2 ] ] ); + + verticesRead += 3; + break; + } default: // IB_EDGE_NEW, IB_EDGE_CACHED, IB_EDGE_0_NEW, IB_EDGE_1_NEW break; - } + } - // populate the edge fifo with the 3 most recent edges - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( reorderedTriangle[ 0 ], reorderedTriangle[ 1 ] ); + // populate the edge fifo with the 3 most recent edges + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( reorderedTriangle[ 0 ], reorderedTriangle[ 1 ] ); - ++edgesRead; + ++edgesRead; - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( reorderedTriangle[ 1 ], reorderedTriangle[ 2 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( reorderedTriangle[ 1 ], reorderedTriangle[ 2 ] ); - ++edgesRead; + ++edgesRead; - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( reorderedTriangle[ 2 ], reorderedTriangle[ 0 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( reorderedTriangle[ 2 ], reorderedTriangle[ 0 ] ); - ++edgesRead; - } - } + ++edgesRead; + } + } } // Output the compression information for a single vertex, remapping any new vertices and updating the vertex fifo where needed. static IBC_INLINE void OutputVertex( uint32_t vertex, - uint32_t* vertexRemap, - uint32_t& newVertexCount, - uint32_t* vertexFifo, - uint32_t& verticesRead, - WriteBitstream& output ) + uint32_t* vertexRemap, + uint32_t& newVertexCount, + uint32_t* vertexFifo, + uint32_t& verticesRead, + WriteBitstream& output ) { - // Check if a vertex hasn't been remapped, - if ( vertexRemap[ vertex ] == VERTEX_NOT_MAPPED ) - { - // no remap, so remap to the current high watermark and output a new vertex code. - vertexRemap[ vertex ] = newVertexCount; + // Check if a vertex hasn't been remapped, + if ( vertexRemap[ vertex ] == VERTEX_NOT_MAPPED ) + { + // no remap, so remap to the current high watermark and output a new vertex code. + vertexRemap[ vertex ] = newVertexCount; - output.Write( IB_NEW_VERTEX, IB_VERTEX_CODE_BITS ); + output.Write( IB_NEW_VERTEX, IB_VERTEX_CODE_BITS ); - ++newVertexCount; + ++newVertexCount; - // new vertices go into the vertex FIFO - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = vertex; + // new vertices go into the vertex FIFO + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = vertex; - ++verticesRead; - } - else - { - int32_t lowestVertexCursor = verticesRead >= VERTEX_FIFO_SIZE ? verticesRead - VERTEX_FIFO_SIZE : 0; + ++verticesRead; + } + else + { + int32_t lowestVertexCursor = verticesRead >= VERTEX_FIFO_SIZE ? verticesRead - VERTEX_FIFO_SIZE : 0; - // Probe backwards in the vertex FIFO for a cached vertex - for ( int32_t vertexCursor = verticesRead - 1; vertexCursor >= lowestVertexCursor; --vertexCursor ) - { - if ( vertexFifo[ vertexCursor & VERTEX_FIFO_MASK ] == vertex ) - { - // found a cached vertex, so write out the code for a cached vertex, as the relative index into the fifo. - output.Write( IB_CACHED_VERTEX, IB_VERTEX_CODE_BITS ); - output.Write( ( verticesRead - 1 ) - vertexCursor, CACHED_VERTEX_BITS ); + // Probe backwards in the vertex FIFO for a cached vertex + for ( int32_t vertexCursor = verticesRead - 1; vertexCursor >= lowestVertexCursor; --vertexCursor ) + { + if ( vertexFifo[ vertexCursor & VERTEX_FIFO_MASK ] == vertex ) + { + // found a cached vertex, so write out the code for a cached vertex, as the relative index into the fifo. + output.Write( IB_CACHED_VERTEX, IB_VERTEX_CODE_BITS ); + output.Write( ( verticesRead - 1 ) - vertexCursor, CACHED_VERTEX_BITS ); - return; - } - } + return; + } + } - // no cached vertex found, so write out a free vertex - output.Write( IB_FREE_VERTEX, IB_VERTEX_CODE_BITS ); + // no cached vertex found, so write out a free vertex + output.Write( IB_FREE_VERTEX, IB_VERTEX_CODE_BITS ); - // free vertices are relative to the latest new vertex. - uint32_t vertexOutput = ( newVertexCount - 1 ) - vertexRemap[ vertex ]; + // free vertices are relative to the latest new vertex. + uint32_t vertexOutput = ( newVertexCount - 1 ) - vertexRemap[ vertex ]; - // v-int encode the free vertex index. - output.WriteVInt( vertexOutput ); + // v-int encode the free vertex index. + output.WriteVInt( vertexOutput ); - // free vertices go back into the vertex cache. - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = vertex; - - ++verticesRead; - } + // free vertices go back into the vertex cache. + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = vertex; + + ++verticesRead; + } } template void CompressIndiceCodes1( const Ty* triangles, - uint32_t triangleCount, - uint32_t* vertexRemap, - uint32_t vertexCount, - WriteBitstream& output ) + 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 Ty* 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 ); + 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 ( uint32_t* remappedVertex = vertexRemap; remappedVertex < vertexRemapEnd; ++remappedVertex ) - { - *remappedVertex = VERTEX_NOT_MAPPED; - } + // clear the vertex remapping to "not found" value of 0xFFFFFFFF - dirty, but low overhead. + for ( uint32_t* remappedVertex = vertexRemap; remappedVertex < vertexRemapEnd; ++remappedVertex ) + { + *remappedVertex = VERTEX_NOT_MAPPED; + } - // iterate through the triangles - 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; - bool foundEdge = false; + // iterate through the triangles + 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; + bool foundEdge = false; - int32_t freeVertex = -1; // should not be negative 1 if found, this is not used as a signal, but for debugging. + int32_t freeVertex = -1; // should not be negative 1 if found, this is not used as a signal, but for debugging. - // Probe back through the edge fifo to see if one of the triangle edges is in the FIFO - for ( ; edgeCursor >= lowestEdgeCursor; --edgeCursor ) - { - const Edge& edge = edgeFifo[ edgeCursor & VERTEX_FIFO_MASK ]; + // Probe back through the edge fifo to see if one of the triangle edges is in the FIFO + for ( ; edgeCursor >= lowestEdgeCursor; --edgeCursor ) + { + const Edge& edge = edgeFifo[ edgeCursor & VERTEX_FIFO_MASK ]; - // check all the edges in order and save the free vertex. - if ( edge.second == triangle[ 0 ] && edge.first == triangle[ 1 ] ) - { - foundEdge = true; - freeVertex = 2; - break; - } - else if ( edge.second == triangle[ 1 ] && edge.first == triangle[ 2 ] ) - { - foundEdge = true; - freeVertex = 0; - break; - } - else if ( edge.second == triangle[ 2 ] && edge.first == triangle[ 0 ] ) - { - foundEdge = true; - freeVertex = 1; - break; - } - } + // check all the edges in order and save the free vertex. + if ( edge.second == triangle[ 0 ] && edge.first == triangle[ 1 ] ) + { + foundEdge = true; + freeVertex = 2; + break; + } + else if ( edge.second == triangle[ 1 ] && edge.first == triangle[ 2 ] ) + { + foundEdge = true; + freeVertex = 0; + break; + } + else if ( edge.second == triangle[ 2 ] && edge.first == triangle[ 0 ] ) + { + foundEdge = true; + freeVertex = 1; + break; + } + } - // we found an edge so write it out, then output the vertex - if ( foundEdge ) - { - output.Write( IB_CACHED_EDGE, IB_VERTEX_CODE_BITS ); - output.Write( ( edgesRead - 1 ) - edgeCursor, CACHED_EDGE_BITS ); + // we found an edge so write it out, then output the vertex + if ( foundEdge ) + { + output.Write( IB_CACHED_EDGE, IB_VERTEX_CODE_BITS ); + output.Write( ( edgesRead - 1 ) - edgeCursor, CACHED_EDGE_BITS ); - const Edge& edge = edgeFifo[ edgeCursor & EDGE_FIFO_MASK ]; + const Edge& edge = edgeFifo[ edgeCursor & EDGE_FIFO_MASK ]; - OutputVertex( triangle[ freeVertex ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); + OutputVertex( triangle[ freeVertex ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); - // edge is in reverse order to last triangle it occured on (and it will only be a match if this is the case). - // so put the vertices into the fifo in that order. - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = edge.second; + // edge is in reverse order to last triangle it occured on (and it will only be a match if this is the case). + // so put the vertices into the fifo in that order. + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = edge.second; - ++verticesRead; + ++verticesRead; - vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = edge.first; + vertexFifo[ verticesRead & VERTEX_FIFO_MASK ] = edge.first; - ++verticesRead; + ++verticesRead; - // Populate the edge fifo with the the remaining edges - // Note - the winding order is important as we'll need to re-produce this on decompression. - // The edges are put in as if the found edge is the first edge in the triangle (which it will be when we - // reconstruct). - switch ( freeVertex ) - { - case 0: + // Populate the edge fifo with the the remaining edges + // Note - the winding order is important as we'll need to re-produce this on decompression. + // The edges are put in as if the found edge is the first edge in the triangle (which it will be when we + // reconstruct). + switch ( freeVertex ) + { + case 0: - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 2 ], triangle[ 0 ] ); - ++edgesRead; + ++edgesRead; - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); - ++edgesRead; - break; + ++edgesRead; + break; - case 1: + case 1: - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); - ++edgesRead; + ++edgesRead; - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] ); + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 1 ], triangle[ 2 ] ); - ++edgesRead; - break; + ++edgesRead; + break; - case 2: + case 2: - 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; - break; - } - } - else - { - // no edge, so we need to output all the vertices. - OutputVertex( triangle[ 0 ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); - OutputVertex( triangle[ 1 ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); - OutputVertex( triangle[ 2 ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); + ++edgesRead; + break; + } + } + else + { + // no edge, so we need to output all the vertices. + OutputVertex( triangle[ 0 ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); + OutputVertex( triangle[ 1 ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); + OutputVertex( triangle[ 2 ], vertexRemap, newVertices, vertexFifo, verticesRead, output ); - // populate the edge fifo with the 3 most recent edges - edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); + // populate the edge fifo with the 3 most recent edges + edgeFifo[ edgesRead & EDGE_FIFO_MASK ].set( triangle[ 0 ], triangle[ 1 ] ); - ++edgesRead; + ++edgesRead; - 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; + } + } } // Detects if there are any degenerate triangles in a set of triangles, where there is 1 or more duplicate vertices. @@ -768,25 +768,25 @@ bool ContainsDegenerates( const Ty* triangles, uint32_t triangleCount ) template void CompressIndexBuffer( const Ty* triangles, - uint32_t triangleCount, - uint32_t* vertexRemap, - uint32_t vertexCount, - IndexBufferCompressionFormat format, - WriteBitstream& output ) + uint32_t triangleCount, + uint32_t* vertexRemap, + uint32_t vertexCount, + IndexBufferCompressionFormat format, + WriteBitstream& output ) { - switch ( format ) - { - case IBCF_PER_INDICE_1: + switch ( format ) + { + case IBCF_PER_INDICE_1: output.WriteVInt( IBCF_PER_INDICE_1 ); - CompressIndiceCodes1( triangles, triangleCount, vertexRemap, vertexCount, output ); - break; + CompressIndiceCodes1( triangles, triangleCount, vertexRemap, vertexCount, output ); + break; - case IBCF_PER_TRIANGLE_1: + case IBCF_PER_TRIANGLE_1: output.WriteVInt( IBCF_PER_TRIANGLE_1 ); - CompressTriangleCodes1( triangles, triangleCount, vertexRemap, vertexCount, output ); - break; + CompressTriangleCodes1( triangles, triangleCount, vertexRemap, vertexCount, output ); + break; case ICBF_AUTO: @@ -802,27 +802,27 @@ void CompressIndexBuffer( const Ty* triangles, } break; - } + } } void CompressIndexBuffer( const uint16_t* triangles, - uint32_t triangleCount, - uint32_t* vertexRemap, - uint32_t vertexCount, - IndexBufferCompressionFormat format, - WriteBitstream& output ) + uint32_t triangleCount, + uint32_t* vertexRemap, + uint32_t vertexCount, + IndexBufferCompressionFormat format, + WriteBitstream& output ) { - CompressIndexBuffer( triangles, triangleCount, vertexRemap, vertexCount, format, output ); + CompressIndexBuffer( triangles, triangleCount, vertexRemap, vertexCount, format, output ); } void CompressIndexBuffer( const uint32_t* triangles, - uint32_t triangleCount, - uint32_t* vertexRemap, - uint32_t vertexCount, - IndexBufferCompressionFormat format, - WriteBitstream& output ) + uint32_t triangleCount, + uint32_t* vertexRemap, + uint32_t vertexCount, + IndexBufferCompressionFormat format, + WriteBitstream& output ) { - CompressIndexBuffer( triangles, triangleCount, vertexRemap, vertexCount, format, output ); + CompressIndexBuffer( triangles, triangleCount, vertexRemap, vertexCount, format, output ); } diff --git a/3rdparty/ib-compress/indexbuffercompressionformat.h b/3rdparty/ib-compress/indexbuffercompressionformat.h index 16903a151..b6fb5f4f7 100644 --- a/3rdparty/ib-compress/indexbuffercompressionformat.h +++ b/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). diff --git a/3rdparty/ib-compress/indexbufferdecompression.cpp b/3rdparty/ib-compress/indexbufferdecompression.cpp index 10c8881d3..95fdc4bc2 100644 --- a/3rdparty/ib-compress/indexbufferdecompression.cpp +++ b/3rdparty/ib-compress/indexbufferdecompression.cpp @@ -31,451 +31,451 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. template 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 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( triangles, triangleCount, input ); - break; + DecompressIndiceCodes1( triangles, triangleCount, input ); + break; - case IBCF_PER_TRIANGLE_1: + case IBCF_PER_TRIANGLE_1: - DecompressTriangleCodes1( triangles, triangleCount, input ); - break; + DecompressTriangleCodes1( triangles, triangleCount, input ); + break; - default: // ICBF_AUTO: - break; - } + default: // ICBF_AUTO: + break; + } } void DecompressIndexBuffer( uint32_t* triangles, uint32_t triangleCount, ReadBitstream& input ) { - DecompressIndexBuffer( triangles, triangleCount, input ); + DecompressIndexBuffer( triangles, triangleCount, input ); } void DecompressIndexBuffer( uint16_t* triangles, uint32_t triangleCount, ReadBitstream& input ) { - DecompressIndexBuffer( triangles, triangleCount, input ); + DecompressIndexBuffer( triangles, triangleCount, input ); } diff --git a/3rdparty/ib-compress/indexcompressionconstants.h b/3rdparty/ib-compress/indexcompressionconstants.h index 24cf346f5..20d5a6af5 100644 --- a/3rdparty/ib-compress/indexcompressionconstants.h +++ b/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 \ No newline at end of file diff --git a/3rdparty/ib-compress/readbitstream.h b/3rdparty/ib-compress/readbitstream.h index 5eff24765..be1378c54 100644 --- a/3rdparty/ib-compress/readbitstream.h +++ b/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; + 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; + 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 += 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 ); + 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; + 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; + m_cursor += 8; - result |= static_cast< uint32_t >( m_bitBuffer << m_bitsLeft ) & mask; - m_bitsLeft = 64 - ( bitCount - m_bitsLeft ); - } - else - { - m_bitsLeft -= bitCount; - } + result |= static_cast< uint32_t >( m_bitBuffer << m_bitsLeft ) & mask; + m_bitsLeft = 64 - ( bitCount - m_bitsLeft ); + } + else + { + m_bitsLeft -= bitCount; + } - return result; + 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__ diff --git a/3rdparty/ib-compress/writebitstream.h b/3rdparty/ib-compress/writebitstream.h index 7dfc81e75..ed777e9d9 100644 --- a/3rdparty/ib-compress/writebitstream.h +++ b/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( 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_bitsLeft = 64 - ( bitCount - m_bitsLeft ); + } + else + { + m_bitsLeft -= bitCount; + } - m_size += 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(); - } + 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[ 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; } 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( newBuffer ), reinterpret_cast( m_buffer ), bufferSize ); + ::memcpy( reinterpret_cast( newBuffer ), reinterpret_cast( 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__ \ No newline at end of file