scratchfoundation/bgfx
1
0
Fork 0
mirror of https://github.com/scratchfoundation/bgfx.git synced 2025-03-14 00:49:53 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Branimir Karadžić 2014-09-29 21:58:29 -07:00
parent b7265b7221
commit b85b85c480
7 changed files with 77 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
3rdparty/ib-compress/IndexBufferCompession.cpp vendored
View file

@ -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);
}

8
3rdparty/ib-compress/IndexBufferCompression.h vendored
View file

@ -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__

35
3rdparty/ib-compress/IndexBufferDecompression.cpp vendored
View file

@ -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 );
}

8
3rdparty/ib-compress/IndexBufferDecompression.h vendored
View file

@ -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__

6
3rdparty/ib-compress/IndexCompressionConstants.h vendored
View file

@ -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;
};

2
3rdparty/ib-compress/ReadBitstream.h vendored
View file

@ -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

2
3rdparty/ib-compress/WriteBitstream.h vendored
View file

@ -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