diff --git a/examples/14-shadowvolumes/shadowvolumes.cpp b/examples/14-shadowvolumes/shadowvolumes.cpp index efb60c3aa..f4578d039 100644 --- a/examples/14-shadowvolumes/shadowvolumes.cpp +++ b/examples/14-shadowvolumes/shadowvolumes.cpp @@ -556,37 +556,6 @@ void touch(bgfx::ViewId _id) ::submit(_id, handle); } -struct Aabb -{ - float m_min[3]; - float m_max[3]; -}; - -struct Obb -{ - float m_mtx[16]; -}; - -struct Sphere -{ - float m_center[3]; - float m_radius; -}; - -struct Primitive -{ - uint32_t m_startIndex; - uint32_t m_numIndices; - uint32_t m_startVertex; - uint32_t m_numVertices; - - Sphere m_sphere; - Aabb m_aabb; - Obb m_obb; -}; - -typedef std::vector PrimitiveArray; - struct Face { uint16_t m_i[3]; @@ -995,96 +964,37 @@ struct Mesh void load(const char* _filePath) { -#define BGFX_CHUNK_MAGIC_VB BX_MAKEFOURCC('V', 'B', ' ', 0x1) -#define BGFX_CHUNK_MAGIC_IB BX_MAKEFOURCC('I', 'B', ' ', 0x0) -#define BGFX_CHUNK_MAGIC_PRI BX_MAKEFOURCC('P', 'R', 'I', 0x0) + ::Mesh* mesh = ::meshLoad(_filePath, true); + m_decl = mesh->m_decl; + uint16_t stride = m_decl.getStride(); - bx::FileReaderI* reader = entry::getFileReader(); - bx::open(reader, _filePath); - - Group group; - - uint32_t chunk; - while (4 == bx::read(reader, chunk) ) + for (::GroupArray::iterator it = mesh->m_groups.begin(), itEnd = mesh->m_groups.end(); it != itEnd; ++it) { - switch (chunk) - { - case BGFX_CHUNK_MAGIC_VB: - { - bx::read(reader, group.m_sphere); - bx::read(reader, group.m_aabb); - bx::read(reader, group.m_obb); + Group group; + group.m_numVertices = it->m_numVertices; + const uint32_t vertexSize = group.m_numVertices*stride; + group.m_vertices = (uint8_t*)malloc(vertexSize); + bx::memCopy(group.m_vertices, it->m_vertices, vertexSize); - bgfx::read(reader, m_decl); - uint16_t stride = m_decl.getStride(); + const bgfx::Memory* mem = bgfx::makeRef(group.m_vertices, vertexSize); + group.m_vbh = bgfx::createVertexBuffer(mem, m_decl); + + group.m_numIndices = it->m_numIndices; + const uint32_t indexSize = 2 * group.m_numIndices; + group.m_indices = (uint16_t*)malloc(indexSize); + bx::memCopy(group.m_indices, it->m_indices, indexSize); + + mem = bgfx::makeRef(group.m_indices, indexSize); + group.m_ibh = bgfx::createIndexBuffer(mem); - bx::read(reader, group.m_numVertices); - const uint32_t size = group.m_numVertices*stride; - group.m_vertices = (uint8_t*)malloc(size); - bx::read(reader, group.m_vertices, size); - - const bgfx::Memory* mem = bgfx::makeRef(group.m_vertices, size); - group.m_vbh = bgfx::createVertexBuffer(mem, m_decl); - } - break; - - case BGFX_CHUNK_MAGIC_IB: - { - bx::read(reader, group.m_numIndices); - const uint32_t size = group.m_numIndices*2; - group.m_indices = (uint16_t*)malloc(size); - bx::read(reader, group.m_indices, size); - - const bgfx::Memory* mem = bgfx::makeRef(group.m_indices, size); - group.m_ibh = bgfx::createIndexBuffer(mem); - } - break; - - case BGFX_CHUNK_MAGIC_PRI: - { - uint16_t len; - bx::read(reader, len); - - std::string material; - material.resize(len); - bx::read(reader, const_cast(material.c_str() ), len); - - uint16_t num; - bx::read(reader, num); - - for (uint32_t ii = 0; ii < num; ++ii) - { - bx::read(reader, len); - - std::string name; - name.resize(len); - bx::read(reader, const_cast(name.c_str() ), len); - - Primitive prim; - bx::read(reader, prim.m_startIndex); - bx::read(reader, prim.m_numIndices); - bx::read(reader, prim.m_startVertex); - bx::read(reader, prim.m_numVertices); - bx::read(reader, prim.m_sphere); - bx::read(reader, prim.m_aabb); - bx::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::seek(reader) ); - abort(); - break; - } + group.m_sphere = it->m_sphere; + group.m_aabb = it->m_aabb; + group.m_obb = it->m_obb; + group.m_prims = it->m_prims; + + m_groups.push_back(group); } - - bx::close(reader); + ::meshUnload(mesh); for (GroupArray::iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) { @@ -1774,17 +1684,17 @@ bool clipTest(const float* _planes, uint8_t _planeNum, const Mesh& _mesh, const const Group& group = *it; Sphere sphere = group.m_sphere; - sphere.m_center[0] = sphere.m_center[0] * scale + _translate[0]; - sphere.m_center[1] = sphere.m_center[1] * scale + _translate[1]; - sphere.m_center[2] = sphere.m_center[2] * scale + _translate[2]; - sphere.m_radius *= (scale+0.4f); + sphere.center.x = sphere.center.x * scale + _translate[0]; + sphere.center.y = sphere.center.y * scale + _translate[1]; + sphere.center.z = sphere.center.z * scale + _translate[2]; + sphere.radius *= (scale+0.4f); bool isInside = true; for (uint8_t ii = 0; ii < _planeNum; ++ii) { const float* plane = volumePlanes[ii]; - float positiveSide = bx::dot(bx::load(plane), bx::load(sphere.m_center) ) + plane[3] + sphere.m_radius; + float positiveSide = bx::dot(bx::load(plane), sphere.center ) + plane[3] + sphere.radius; if (positiveSide < 0.0f) { diff --git a/examples/common/bgfx_utils.cpp b/examples/common/bgfx_utils.cpp index 20e1e23c2..0b31d4722 100644 --- a/examples/common/bgfx_utils.cpp +++ b/examples/common/bgfx_utils.cpp @@ -355,304 +355,292 @@ void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexDecl _decl delete [] tangents; } -struct Aabb + + +Group::Group() { - float m_min[3]; - float m_max[3]; -}; + reset(); +} -struct Obb +void Group::reset() { - float m_mtx[16]; -}; - -struct Sphere -{ - float m_center[3]; - float m_radius; -}; - -struct Primitive -{ - uint32_t m_startIndex; - uint32_t m_numIndices; - uint32_t m_startVertex; - uint32_t m_numVertices; - - Sphere m_sphere; - Aabb m_aabb; - Obb m_obb; -}; - -typedef stl::vector PrimitiveArray; - -struct Group -{ - Group() - { - reset(); - } - - void reset() - { - m_vbh.idx = bgfx::kInvalidHandle; - m_ibh.idx = bgfx::kInvalidHandle; - m_prims.clear(); - } - - bgfx::VertexBufferHandle m_vbh; - bgfx::IndexBufferHandle m_ibh; - Sphere m_sphere; - Aabb m_aabb; - Obb m_obb; - PrimitiveArray m_prims; -}; + m_vbh.idx = bgfx::kInvalidHandle; + m_ibh.idx = bgfx::kInvalidHandle; + m_numVertices = 0; + m_vertices = NULL; + m_numIndices = 0; + m_indices = NULL; + m_prims.clear(); +} namespace bgfx { int32_t read(bx::ReaderI* _reader, bgfx::VertexDecl& _decl, bx::Error* _err = NULL); } -struct Mesh +void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy) { - void load(bx::ReaderSeekerI* _reader) - { #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) - 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() ) + 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() ) + { + switch (chunk) { - switch (chunk) - { case BGFX_CHUNK_MAGIC_VB: + { + read(_reader, group.m_sphere); + read(_reader, group.m_aabb); + read(_reader, group.m_obb); + + read(_reader, m_decl); + + uint16_t stride = m_decl.getStride(); + + read(_reader, group.m_numVertices); + const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride); + read(_reader, mem->data, mem->size); + if ( _ramcopy ) { - read(_reader, group.m_sphere); - read(_reader, group.m_aabb); - read(_reader, group.m_obb); - - read(_reader, m_decl); - - uint16_t stride = m_decl.getStride(); - - uint16_t numVertices; - read(_reader, numVertices); - const bgfx::Memory* mem = bgfx::alloc(numVertices*stride); - read(_reader, mem->data, mem->size); - - group.m_vbh = bgfx::createVertexBuffer(mem, m_decl); + 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_decl); + } break; - + case BGFX_CHUNK_MAGIC_VBC: + { + read(_reader, group.m_sphere); + read(_reader, group.m_aabb); + read(_reader, group.m_obb); + + read(_reader, m_decl); + + uint16_t stride = m_decl.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 ) { - read(_reader, group.m_sphere); - read(_reader, group.m_aabb); - read(_reader, group.m_obb); - - read(_reader, m_decl); - - uint16_t stride = m_decl.getStride(); - - uint16_t numVertices; - read(_reader, numVertices); - - const bgfx::Memory* mem = bgfx::alloc(numVertices*stride); - - uint32_t compressedSize; - bx::read(_reader, compressedSize); - - void* compressedVertices = BX_ALLOC(allocator, compressedSize); - bx::read(_reader, compressedVertices, compressedSize); - - meshopt_decodeVertexBuffer(mem->data, numVertices, stride, (uint8_t*)compressedVertices, compressedSize); - - BX_FREE(allocator, compressedVertices); - - group.m_vbh = bgfx::createVertexBuffer(mem, m_decl); + 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_decl); + } break; - + case BGFX_CHUNK_MAGIC_IB: + { + read(_reader, group.m_numIndices); + const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2); + read(_reader, mem->data, mem->size); + if ( _ramcopy ) { - uint32_t numIndices; - read(_reader, numIndices); - const bgfx::Memory* mem = bgfx::alloc(numIndices*2); - read(_reader, mem->data, mem->size); - group.m_ibh = bgfx::createIndexBuffer(mem); + group.m_indices = (uint16_t*)BX_ALLOC(allocator, group.m_numIndices*2); + bx::memCopy(group.m_indices, mem->data, mem->size); } - break; + group.m_ibh = bgfx::createIndexBuffer(mem); + } + break; + case BGFX_CHUNK_MAGIC_IBC: + { + 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 ) { - uint32_t numIndices; - bx::read(_reader, numIndices); - - const bgfx::Memory* mem = bgfx::alloc(numIndices*2); - - uint32_t compressedSize; - bx::read(_reader, compressedSize); - - void* compressedIndices = BX_ALLOC(allocator, compressedSize); - - bx::read(_reader, compressedIndices, compressedSize); - - meshopt_decodeIndexBuffer(mem->data, numIndices, 2, (uint8_t*)compressedIndices, compressedSize); - - BX_FREE(allocator, compressedIndices); - - group.m_ibh = bgfx::createIndexBuffer(mem); + 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: + { + uint16_t len; + read(_reader, len); + + stl::string material; + material.resize(len); + read(_reader, const_cast(material.c_str() ), len); + + uint16_t num; + read(_reader, num); + + for (uint32_t ii = 0; ii < num; ++ii) { - uint16_t len; read(_reader, len); - - stl::string material; - material.resize(len); - read(_reader, const_cast(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(name.c_str() ), len); - - Primitive prim; - read(_reader, prim.m_startIndex); - read(_reader, prim.m_numIndices); - read(_reader, prim.m_startVertex); - read(_reader, prim.m_numVertices); - 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(); + + stl::string name; + name.resize(len); + read(_reader, const_cast(name.c_str() ), len); + + Primitive prim; + read(_reader, prim.m_startIndex); + read(_reader, prim.m_numIndices); + read(_reader, prim.m_startVertex); + read(_reader, prim.m_numVertices); + 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; - } } } +} - void unload() +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 ) + { + BX_FREE(allocator, group.m_vertices); + } + + if ( NULL != group.m_indices ) + { + BX_FREE(allocator, group.m_indices); + } + } + m_groups.clear(); +} + +void Mesh::submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _mtx, uint64_t _state) const +{ + 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::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); + } +} + +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 + ); + } + 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); - } - } - m_groups.clear(); - } - - void submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _mtx, uint64_t _state) const - { - 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::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::submit(state.m_viewId, state.m_program, 0, it != itEnd-1); } } +} - void 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 - ); - } - - 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::VertexDecl m_decl; - typedef stl::vector GroupArray; - GroupArray m_groups; -}; - -Mesh* meshLoad(bx::ReaderSeekerI* _reader) +Mesh* meshLoad(bx::ReaderSeekerI* _reader, bool _ramcopy) { Mesh* mesh = new Mesh; - mesh->load(_reader); + mesh->load(_reader, _ramcopy); return mesh; } -Mesh* meshLoad(const char* _filePath) +Mesh* meshLoad(const char* _filePath, bool _ramcopy) { bx::FileReaderI* reader = entry::getFileReader(); if (bx::open(reader, _filePath) ) { - Mesh* mesh = meshLoad(reader); + Mesh* mesh = meshLoad(reader, _ramcopy); bx::close(reader); return mesh; } diff --git a/examples/common/bgfx_utils.h b/examples/common/bgfx_utils.h index eb74b7905..f12cc6f1b 100644 --- a/examples/common/bgfx_utils.h +++ b/examples/common/bgfx_utils.h @@ -9,6 +9,12 @@ #include #include #include +#include "bounds.h" + +#include +#include +namespace stl = tinystl; + /// void* load(const char* _filePath, uint32_t* _size = NULL); @@ -78,10 +84,51 @@ struct MeshState bgfx::ViewId m_viewId; }; -struct Mesh; +struct Primitive +{ + uint32_t m_startIndex; + uint32_t m_numIndices; + uint32_t m_startVertex; + uint32_t m_numVertices; + + Sphere m_sphere; + Aabb m_aabb; + Obb m_obb; +}; + +typedef stl::vector PrimitiveArray; + +struct Group +{ + Group(); + void reset(); + + bgfx::VertexBufferHandle m_vbh; + bgfx::IndexBufferHandle m_ibh; + uint16_t m_numVertices; + uint8_t* m_vertices; + uint32_t m_numIndices; + uint16_t* m_indices; + Sphere m_sphere; + Aabb m_aabb; + Obb m_obb; + PrimitiveArray m_prims; +}; +typedef stl::vector GroupArray; + +struct Mesh +{ + void load(bx::ReaderSeekerI* _reader, bool _ramcopy); + void unload(); + void submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _mtx, uint64_t _state) const; + void submit(const MeshState*const* _state, uint8_t _numPasses, const float* _mtx, uint16_t _numMatrices) const; + + bgfx::VertexDecl m_decl; + GroupArray m_groups; +}; /// -Mesh* meshLoad(const char* _filePath); +Mesh* meshLoad(const char* _filePath, bool _ramcopy = false); /// void meshUnload(Mesh* _mesh); diff --git a/examples/common/debugdraw/debugdraw.cpp b/examples/common/debugdraw/debugdraw.cpp index b34e0e0e7..4f24dd9e0 100644 --- a/examples/common/debugdraw/debugdraw.cpp +++ b/examples/common/debugdraw/debugdraw.cpp @@ -528,7 +528,7 @@ struct Program }; }; -struct Mesh +struct DebugMesh { enum Enum { @@ -640,8 +640,8 @@ struct DebugDrawShared s_texColor = bgfx::createUniform("s_texColor", bgfx::UniformType::Sampler); m_texture = bgfx::createTexture2D(SPRITE_TEXTURE_SIZE, SPRITE_TEXTURE_SIZE, false, 1, bgfx::TextureFormat::BGRA8); - void* vertices[Mesh::Count] = {}; - uint16_t* indices[Mesh::Count] = {}; + void* vertices[DebugMesh::Count] = {}; + uint16_t* indices[DebugMesh::Count] = {}; uint16_t stride = DebugShapeVertex::ms_decl.getStride(); uint32_t startVertex = 0; @@ -649,7 +649,7 @@ struct DebugDrawShared for (uint32_t mesh = 0; mesh < 4; ++mesh) { - Mesh::Enum id = Mesh::Enum(Mesh::Sphere0+mesh); + DebugMesh::Enum id = DebugMesh::Enum(DebugMesh::Sphere0+mesh); const uint8_t tess = uint8_t(3-mesh); const uint32_t numVertices = genSphere(tess); @@ -701,7 +701,7 @@ struct DebugDrawShared for (uint32_t mesh = 0; mesh < 4; ++mesh) { - Mesh::Enum id = Mesh::Enum(Mesh::Cone0+mesh); + DebugMesh::Enum id = DebugMesh::Enum(DebugMesh::Cone0+mesh); const uint32_t num = getCircleLod(uint8_t(mesh) ); const float step = bx::kPi * 2.0f / num; @@ -762,7 +762,7 @@ struct DebugDrawShared for (uint32_t mesh = 0; mesh < 4; ++mesh) { - Mesh::Enum id = Mesh::Enum(Mesh::Cylinder0+mesh); + DebugMesh::Enum id = DebugMesh::Enum(DebugMesh::Cylinder0+mesh); const uint32_t num = getCircleLod(uint8_t(mesh) ); const float step = bx::kPi * 2.0f / num; @@ -832,7 +832,7 @@ struct DebugDrawShared for (uint32_t mesh = 0; mesh < 4; ++mesh) { - Mesh::Enum id = Mesh::Enum(Mesh::Capsule0+mesh); + DebugMesh::Enum id = DebugMesh::Enum(DebugMesh::Capsule0+mesh); const uint32_t num = getCircleLod(uint8_t(mesh) ); const float step = bx::kPi * 2.0f / num; @@ -900,30 +900,30 @@ struct DebugDrawShared startIndex += numIndices + numLineListIndices; } - m_mesh[Mesh::Quad].m_startVertex = startVertex; - m_mesh[Mesh::Quad].m_numVertices = BX_COUNTOF(s_quadVertices); - m_mesh[Mesh::Quad].m_startIndex[0] = startIndex; - m_mesh[Mesh::Quad].m_numIndices[0] = BX_COUNTOF(s_quadIndices); - m_mesh[Mesh::Quad].m_startIndex[1] = 0; - m_mesh[Mesh::Quad].m_numIndices[1] = 0; + m_mesh[DebugMesh::Quad].m_startVertex = startVertex; + m_mesh[DebugMesh::Quad].m_numVertices = BX_COUNTOF(s_quadVertices); + m_mesh[DebugMesh::Quad].m_startIndex[0] = startIndex; + m_mesh[DebugMesh::Quad].m_numIndices[0] = BX_COUNTOF(s_quadIndices); + m_mesh[DebugMesh::Quad].m_startIndex[1] = 0; + m_mesh[DebugMesh::Quad].m_numIndices[1] = 0; startVertex += BX_COUNTOF(s_quadVertices); startIndex += BX_COUNTOF(s_quadIndices); - m_mesh[Mesh::Cube].m_startVertex = startVertex; - m_mesh[Mesh::Cube].m_numVertices = BX_COUNTOF(s_cubeVertices); - m_mesh[Mesh::Cube].m_startIndex[0] = startIndex; - m_mesh[Mesh::Cube].m_numIndices[0] = BX_COUNTOF(s_cubeIndices); - m_mesh[Mesh::Cube].m_startIndex[1] = 0; - m_mesh[Mesh::Cube].m_numIndices[1] = 0; - startVertex += m_mesh[Mesh::Cube].m_numVertices; - startIndex += m_mesh[Mesh::Cube].m_numIndices[0]; + m_mesh[DebugMesh::Cube].m_startVertex = startVertex; + m_mesh[DebugMesh::Cube].m_numVertices = BX_COUNTOF(s_cubeVertices); + m_mesh[DebugMesh::Cube].m_startIndex[0] = startIndex; + m_mesh[DebugMesh::Cube].m_numIndices[0] = BX_COUNTOF(s_cubeIndices); + m_mesh[DebugMesh::Cube].m_startIndex[1] = 0; + m_mesh[DebugMesh::Cube].m_numIndices[1] = 0; + startVertex += m_mesh[DebugMesh::Cube].m_numVertices; + startIndex += m_mesh[DebugMesh::Cube].m_numIndices[0]; const bgfx::Memory* vb = bgfx::alloc(startVertex*stride); const bgfx::Memory* ib = bgfx::alloc(startIndex*sizeof(uint16_t) ); - for (uint32_t mesh = Mesh::Sphere0; mesh < Mesh::Quad; ++mesh) + for (uint32_t mesh = DebugMesh::Sphere0; mesh < DebugMesh::Quad; ++mesh) { - Mesh::Enum id = Mesh::Enum(mesh); + DebugMesh::Enum id = DebugMesh::Enum(mesh); bx::memCopy(&vb->data[m_mesh[id].m_startVertex * stride] , vertices[id] , m_mesh[id].m_numVertices*stride @@ -938,22 +938,22 @@ struct DebugDrawShared BX_FREE(m_allocator, indices[id]); } - bx::memCopy(&vb->data[m_mesh[Mesh::Quad].m_startVertex * stride] + bx::memCopy(&vb->data[m_mesh[DebugMesh::Quad].m_startVertex * stride] , s_quadVertices , sizeof(s_quadVertices) ); - bx::memCopy(&ib->data[m_mesh[Mesh::Quad].m_startIndex[0] * sizeof(uint16_t)] + bx::memCopy(&ib->data[m_mesh[DebugMesh::Quad].m_startIndex[0] * sizeof(uint16_t)] , s_quadIndices , sizeof(s_quadIndices) ); - bx::memCopy(&vb->data[m_mesh[Mesh::Cube].m_startVertex * stride] + bx::memCopy(&vb->data[m_mesh[DebugMesh::Cube].m_startVertex * stride] , s_cubeVertices , sizeof(s_cubeVertices) ); - bx::memCopy(&ib->data[m_mesh[Mesh::Cube].m_startIndex[0] * sizeof(uint16_t)] + bx::memCopy(&ib->data[m_mesh[DebugMesh::Cube].m_startIndex[0] * sizeof(uint16_t)] , s_cubeIndices , sizeof(s_cubeIndices) ); @@ -1017,7 +1017,7 @@ struct DebugDrawShared Sprite m_sprite; Geometry m_geometry; - Mesh m_mesh[Mesh::Count]; + DebugMesh m_mesh[DebugMesh::Count]; bgfx::UniformHandle s_texColor; bgfx::TextureHandle m_texture; @@ -1432,7 +1432,7 @@ struct DebugDrawEncoderImpl { Obb obb; toObb(obb, _aabb); - draw(Mesh::Cube, obb.mtx, 1, false); + draw(DebugMesh::Cube, obb.mtx, 1, false); } } @@ -1481,7 +1481,7 @@ struct DebugDrawEncoderImpl } else { - draw(Mesh::Cube, _obb.mtx, 1, false); + draw(DebugMesh::Cube, _obb.mtx, 1, false); } } @@ -1500,11 +1500,11 @@ struct DebugDrawEncoderImpl , _sphere.center.y , _sphere.center.z ); - uint8_t lod = attrib.m_lod > Mesh::SphereMaxLod - ? uint8_t(Mesh::SphereMaxLod) + uint8_t lod = attrib.m_lod > DebugMesh::SphereMaxLod + ? uint8_t(DebugMesh::SphereMaxLod) : attrib.m_lod ; - draw(Mesh::Enum(Mesh::Sphere0 + lod), mtx, 1, attrib.m_wireframe); + draw(DebugMesh::Enum(DebugMesh::Sphere0 + lod), mtx, 1, attrib.m_wireframe); } void draw(const Triangle& _triangle) @@ -1855,7 +1855,7 @@ struct DebugDrawEncoderImpl { float mtx[16]; bx::mtxFromNormal(mtx, _normal, _size*0.5f, _center, attrib.m_spin); - draw(Mesh::Quad, mtx, 1, false); + draw(DebugMesh::Quad, mtx, 1, false); } } @@ -1941,11 +1941,11 @@ struct DebugDrawEncoderImpl mtx[1][13] = _to.y; mtx[1][14] = _to.z; - uint8_t lod = attrib.m_lod > Mesh::ConeMaxLod - ? uint8_t(Mesh::ConeMaxLod) + uint8_t lod = attrib.m_lod > DebugMesh::ConeMaxLod + ? uint8_t(DebugMesh::ConeMaxLod) : attrib.m_lod ; - draw(Mesh::Enum(Mesh::Cone0 + lod), mtx[0], 2, attrib.m_wireframe); + draw(DebugMesh::Enum(DebugMesh::Cone0 + lod), mtx[0], 2, attrib.m_wireframe); } void drawCylinder(const bx::Vec3& _from, const bx::Vec3& _to, float _radius, bool _capsule) @@ -1963,11 +1963,11 @@ struct DebugDrawEncoderImpl if (_capsule) { - uint8_t lod = attrib.m_lod > Mesh::CapsuleMaxLod - ? uint8_t(Mesh::CapsuleMaxLod) + uint8_t lod = attrib.m_lod > DebugMesh::CapsuleMaxLod + ? uint8_t(DebugMesh::CapsuleMaxLod) : attrib.m_lod ; - draw(Mesh::Enum(Mesh::Capsule0 + lod), mtx[0], 2, attrib.m_wireframe); + draw(DebugMesh::Enum(DebugMesh::Capsule0 + lod), mtx[0], 2, attrib.m_wireframe); Sphere sphere; sphere.center = _from; @@ -1979,11 +1979,11 @@ struct DebugDrawEncoderImpl } else { - uint8_t lod = attrib.m_lod > Mesh::CylinderMaxLod - ? uint8_t(Mesh::CylinderMaxLod) + uint8_t lod = attrib.m_lod > DebugMesh::CylinderMaxLod + ? uint8_t(DebugMesh::CylinderMaxLod) : attrib.m_lod ; - draw(Mesh::Enum(Mesh::Cylinder0 + lod), mtx[0], 2, attrib.m_wireframe); + draw(DebugMesh::Enum(DebugMesh::Cylinder0 + lod), mtx[0], 2, attrib.m_wireframe); } } @@ -2125,11 +2125,11 @@ struct DebugDrawEncoderImpl pop(); } - void draw(Mesh::Enum _mesh, const float* _mtx, uint16_t _num, bool _wireframe) + void draw(DebugMesh::Enum _mesh, const float* _mtx, uint16_t _num, bool _wireframe) { pushTransform(_mtx, _num, false /* flush */); - const Mesh& mesh = s_dds.m_mesh[_mesh]; + const DebugMesh& mesh = s_dds.m_mesh[_mesh]; if (0 != mesh.m_numIndices[_wireframe]) {