Mirrors/bgfx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bgfx.git synced 2026-02-17 20:52:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup.

Browse Source
This commit is contained in:
Бранимир Караџић
2020-07-05 21:30:52 -07:00
parent c5458a5d62
commit 301629ed16
2 changed files with 95 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

163
examples/common/bgfx_utils.cpp
View File

@@ -356,8 +356,6 @@ void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexLayout _la
delete [] tangents;
}
Group::Group()
{
reset();
@@ -381,88 +379,91 @@ namespace bgfx
void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
{
#define BGFX_CHUNK_MAGIC_VB BX_MAKEFOURCC('V', 'B', ' ', 0x1)
#define BGFX_CHUNK_MAGIC_VBC BX_MAKEFOURCC('V', 'B', 'C', 0x0)
#define BGFX_CHUNK_MAGIC_IB BX_MAKEFOURCC('I', 'B', ' ', 0x0)
#define BGFX_CHUNK_MAGIC_IBC BX_MAKEFOURCC('I', 'B', 'C', 0x1)
#define BGFX_CHUNK_MAGIC_PRI BX_MAKEFOURCC('P', 'R', 'I', 0x0)
constexpr uint32_t kChunkVertexBuffer = BX_MAKEFOURCC('V', 'B', ' ', 0x1);
constexpr uint32_t kChunkVertexBufferCompressed = BX_MAKEFOURCC('V', 'B', 'C', 0x0);
constexpr uint32_t kChunkIndexBuffer = BX_MAKEFOURCC('I', 'B', ' ', 0x0);
constexpr uint32_t kChunkIndexBufferCompressed = BX_MAKEFOURCC('I', 'B', 'C', 0x1);
constexpr uint32_t kChunkPrimitive = BX_MAKEFOURCC('P', 'R', 'I', 0x0);
using namespace bx;
using namespace bgfx;
Group group;
bx::AllocatorI* allocator = entry::getAllocator();
uint32_t chunk;
bx::Error err;
while (4 == bx::read(_reader, chunk, &err)
&& err.isOk() )
&& err.isOk() )
{
switch (chunk)
{
case BGFX_CHUNK_MAGIC_VB:
case kChunkVertexBuffer:
{
read(_reader, group.m_sphere);
read(_reader, group.m_aabb);
read(_reader, group.m_obb);
read(_reader, m_layout);
uint16_t stride = m_layout.getStride();
read(_reader, group.m_numVertices);
const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride);
read(_reader, mem->data, mem->size);
if ( _ramcopy )
if (_ramcopy)
{
group.m_vertices = (uint8_t*)BX_ALLOC(allocator, group.m_numVertices*stride);
bx::memCopy(group.m_vertices, mem->data, mem->size);
}
group.m_vbh = bgfx::createVertexBuffer(mem, m_layout);
}
break;
case BGFX_CHUNK_MAGIC_VBC:
case kChunkVertexBufferCompressed:
{
read(_reader, group.m_sphere);
read(_reader, group.m_aabb);
read(_reader, group.m_obb);
read(_reader, m_layout);
uint16_t stride = m_layout.getStride();
read(_reader, group.m_numVertices);
const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride);
uint32_t compressedSize;
bx::read(_reader, compressedSize);
void* compressedVertices = BX_ALLOC(allocator, compressedSize);
bx::read(_reader, compressedVertices, compressedSize);
meshopt_decodeVertexBuffer(mem->data, group.m_numVertices, stride, (uint8_t*)compressedVertices, compressedSize);
BX_FREE(allocator, compressedVertices);
if ( _ramcopy )
if (_ramcopy)
{
group.m_vertices = (uint8_t*)BX_ALLOC(allocator, group.m_numVertices*stride);
bx::memCopy(group.m_vertices, mem->data, mem->size);
}
group.m_vbh = bgfx::createVertexBuffer(mem, m_layout);
}
break;
case BGFX_CHUNK_MAGIC_IB:
case kChunkIndexBuffer:
{
read(_reader, group.m_numIndices);
const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2);
read(_reader, mem->data, mem->size);
if ( _ramcopy )
if (_ramcopy)
{
group.m_indices = (uint16_t*)BX_ALLOC(allocator, group.m_numIndices*2);
bx::memCopy(group.m_indices, mem->data, mem->size);
@@ -471,54 +472,54 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
group.m_ibh = bgfx::createIndexBuffer(mem);
}
break;
case BGFX_CHUNK_MAGIC_IBC:
case kChunkIndexBufferCompressed:
{
bx::read(_reader, group.m_numIndices);
const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2);
uint32_t compressedSize;
bx::read(_reader, compressedSize);
void* compressedIndices = BX_ALLOC(allocator, compressedSize);
bx::read(_reader, compressedIndices, compressedSize);
meshopt_decodeIndexBuffer(mem->data, group.m_numIndices, 2, (uint8_t*)compressedIndices, compressedSize);
BX_FREE(allocator, compressedIndices);
if ( _ramcopy )
if (_ramcopy)
{
group.m_indices = (uint16_t*)BX_ALLOC(allocator, group.m_numIndices*2);
bx::memCopy(group.m_indices, mem->data, mem->size);
}
group.m_ibh = bgfx::createIndexBuffer(mem);
}
break;
case BGFX_CHUNK_MAGIC_PRI:
case kChunkPrimitive:
{
uint16_t len;
read(_reader, len);
stl::string material;
material.resize(len);
read(_reader, const_cast<char*>(material.c_str() ), len);
uint16_t num;
read(_reader, num);
for (uint32_t ii = 0; ii < num; ++ii)
{
read(_reader, len);
stl::string name;
name.resize(len);
read(_reader, const_cast<char*>(name.c_str() ), len);
Primitive prim;
read(_reader, prim.m_startIndex);
read(_reader, prim.m_numIndices);
@@ -527,15 +528,15 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
read(_reader, prim.m_sphere);
read(_reader, prim.m_aabb);
read(_reader, prim.m_obb);
group.m_prims.push_back(prim);
}
m_groups.push_back(group);
group.reset();
}
break;
default:
DBG("%08x at %d", chunk, bx::skip(_reader, 0) );
break;
@@ -546,23 +547,23 @@ void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy)
void Mesh::unload()
{
bx::AllocatorI* allocator = entry::getAllocator();
for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
{
const Group& group = *it;
bgfx::destroy(group.m_vbh);
if (bgfx::isValid(group.m_ibh) )
{
bgfx::destroy(group.m_ibh);
}
if ( NULL != group.m_vertices )
if (NULL != group.m_vertices)
{
BX_FREE(allocator, group.m_vertices);
}
if ( NULL != group.m_indices )
if (NULL != group.m_indices)
{
BX_FREE(allocator, group.m_indices);
}
@@ -575,22 +576,22 @@ void Mesh::submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _
if (BGFX_STATE_MASK == _state)
{
_state = 0
| BGFX_STATE_WRITE_RGB
| BGFX_STATE_WRITE_A
| BGFX_STATE_WRITE_Z
| BGFX_STATE_DEPTH_TEST_LESS
| BGFX_STATE_CULL_CCW
| BGFX_STATE_MSAA
;
| BGFX_STATE_WRITE_RGB
| BGFX_STATE_WRITE_A
| BGFX_STATE_WRITE_Z
| BGFX_STATE_DEPTH_TEST_LESS
| BGFX_STATE_CULL_CCW
| BGFX_STATE_MSAA
;
}
bgfx::setTransform(_mtx);
bgfx::setState(_state);
for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
{
const Group& group = *it;
bgfx::setIndexBuffer(group.m_ibh);
bgfx::setVertexBuffer(0, group.m_vbh);
bgfx::submit(_id, _program, 0, (it == itEnd-1) ? (BGFX_DISCARD_INDEX_BUFFER | BGFX_DISCARD_VERTEX_STREAMS | BGFX_DISCARD_STATE) : BGFX_DISCARD_NONE);
@@ -600,31 +601,37 @@ void Mesh::submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _
void Mesh::submit(const MeshState*const* _state, uint8_t _numPasses, const float* _mtx, uint16_t _numMatrices) const
{
uint32_t cached = bgfx::setTransform(_mtx, _numMatrices);
for (uint32_t pass = 0; pass < _numPasses; ++pass)
{
bgfx::setTransform(cached, _numMatrices);
const MeshState& state = *_state[pass];
bgfx::setState(state.m_state);
for (uint8_t tex = 0; tex < state.m_numTextures; ++tex)
{
const MeshState::Texture& texture = state.m_textures[tex];
bgfx::setTexture(texture.m_stage
, texture.m_sampler
, texture.m_texture
, texture.m_flags
);
bgfx::setTexture(
texture.m_stage
, texture.m_sampler
, texture.m_texture
, texture.m_flags
);
}
for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it)
{
const Group& group = *it;
bgfx::setIndexBuffer(group.m_ibh);
bgfx::setVertexBuffer(0, group.m_vbh);
bgfx::submit(state.m_viewId, state.m_program, 0, (it == itEnd - 1) ? (BGFX_DISCARD_INDEX_BUFFER | BGFX_DISCARD_VERTEX_STREAMS | BGFX_DISCARD_STATE) : BGFX_DISCARD_NONE);
bgfx::submit(
state.m_viewId
, state.m_program
, 0
, (it == itEnd - 1) ? (BGFX_DISCARD_INDEX_BUFFER | BGFX_DISCARD_VERTEX_STREAMS | BGFX_DISCARD_STATE) : BGFX_DISCARD_NONE
);
}
}
}

20
tools/geometryc/geometryc.cpp
View File

@@ -152,11 +152,11 @@ struct Mesh
static uint32_t s_obbSteps = 17;
#define BGFX_CHUNK_MAGIC_VB BX_MAKEFOURCC('V', 'B', ' ', 0x1)
#define BGFX_CHUNK_MAGIC_VBC BX_MAKEFOURCC('V', 'B', 'C', 0x0)
#define BGFX_CHUNK_MAGIC_IB BX_MAKEFOURCC('I', 'B', ' ', 0x0)
#define BGFX_CHUNK_MAGIC_IBC BX_MAKEFOURCC('I', 'B', 'C', 0x1)
#define BGFX_CHUNK_MAGIC_PRI BX_MAKEFOURCC('P', 'R', 'I', 0x0)
constexpr uint32_t kChunkVertexBuffer = BX_MAKEFOURCC('V', 'B', ' ', 0x1);
constexpr uint32_t kChunkVertexBufferCompressed = BX_MAKEFOURCC('V', 'B', 'C', 0x0);
constexpr uint32_t kChunkIndexBuffer = BX_MAKEFOURCC('I', 'B', ' ', 0x0);
constexpr uint32_t kChunkIndexBufferCompressed = BX_MAKEFOURCC('I', 'B', 'C', 0x1);
constexpr uint32_t kChunkPrimitive = BX_MAKEFOURCC('P', 'R', 'I', 0x0);
void optimizeVertexCache(uint16_t* _indices, uint32_t _numIndices, uint32_t _numVertices)
{
@@ -349,7 +349,7 @@ void write(bx::WriterI* _writer
if (_compress)
{
write(_writer, BGFX_CHUNK_MAGIC_VBC);
write(_writer, kChunkVertexBufferCompressed);
write(_writer, _vertices, _numVertices, stride);
write(_writer, _layout);
@@ -359,7 +359,7 @@ void write(bx::WriterI* _writer
}
else
{
write(_writer, BGFX_CHUNK_MAGIC_VB);
write(_writer, kChunkVertexBuffer);
write(_writer, _vertices, _numVertices, stride);
write(_writer, _layout);
@@ -370,18 +370,18 @@ void write(bx::WriterI* _writer
if (_compress)
{
write(_writer, BGFX_CHUNK_MAGIC_IBC);
write(_writer, kChunkIndexBufferCompressed);
write(_writer, _numIndices);
writeCompressedIndices(_writer, _indices, _numIndices, _numVertices);
}
else
{
write(_writer, BGFX_CHUNK_MAGIC_IB);
write(_writer, kChunkIndexBuffer);
write(_writer, _numIndices);
write(_writer, _indices, _numIndices*2);
}
write(_writer, BGFX_CHUNK_MAGIC_PRI);
write(_writer, kChunkPrimitive);
uint16_t nameLen = uint16_t(_material.size() );
write(_writer, nameLen);
write(_writer, _material.c_str(), nameLen);