diff options
Diffstat (limited to '3rdparty/bgfx/examples/common/bgfx_utils.cpp')
-rw-r--r-- | 3rdparty/bgfx/examples/common/bgfx_utils.cpp | 553 |
1 files changed, 319 insertions, 234 deletions
diff --git a/3rdparty/bgfx/examples/common/bgfx_utils.cpp b/3rdparty/bgfx/examples/common/bgfx_utils.cpp index fd3b87251c5..209e3ea7fe1 100644 --- a/3rdparty/bgfx/examples/common/bgfx_utils.cpp +++ b/3rdparty/bgfx/examples/common/bgfx_utils.cpp @@ -1,6 +1,6 @@ /* - * Copyright 2011-2018 Branimir Karadzic. All rights reserved. - * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause + * Copyright 2011-2022 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE */ #include "common.h" @@ -17,7 +17,7 @@ namespace stl = tinystl; #include <bx/readerwriter.h> #include <bx/string.h> #include "entry/entry.h" -#include <ib-compress/indexbufferdecompression.h> +#include <meshoptimizer/src/meshoptimizer.h> #include "bgfx_utils.h" @@ -29,7 +29,7 @@ void* load(bx::FileReaderI* _reader, bx::AllocatorI* _allocator, const char* _fi { uint32_t size = (uint32_t)bx::getSize(_reader); void* data = BX_ALLOC(_allocator, size); - bx::read(_reader, data, size); + bx::read(_reader, data, size, bx::ErrorAssert{}); bx::close(_reader); if (NULL != _size) { @@ -66,7 +66,7 @@ static const bgfx::Memory* loadMem(bx::FileReaderI* _reader, const char* _filePa { uint32_t size = (uint32_t)bx::getSize(_reader); const bgfx::Memory* mem = bgfx::alloc(size+1); - bx::read(_reader, mem->data, size); + bx::read(_reader, mem->data, size, bx::ErrorAssert{}); bx::close(_reader); mem->data[mem->size-1] = '\0'; return mem; @@ -82,7 +82,7 @@ static void* loadMem(bx::FileReaderI* _reader, bx::AllocatorI* _allocator, const { uint32_t size = (uint32_t)bx::getSize(_reader); void* data = BX_ALLOC(_allocator, size); - bx::read(_reader, data, size); + bx::read(_reader, data, size, bx::ErrorAssert{}); bx::close(_reader); if (NULL != _size) @@ -108,14 +108,17 @@ static bgfx::ShaderHandle loadShader(bx::FileReaderI* _reader, const char* _name case bgfx::RendererType::Direct3D9: shaderPath = "shaders/dx9/"; break; case bgfx::RendererType::Direct3D11: case bgfx::RendererType::Direct3D12: shaderPath = "shaders/dx11/"; break; + case bgfx::RendererType::Agc: case bgfx::RendererType::Gnm: shaderPath = "shaders/pssl/"; break; case bgfx::RendererType::Metal: shaderPath = "shaders/metal/"; break; + case bgfx::RendererType::Nvn: shaderPath = "shaders/nvn/"; break; case bgfx::RendererType::OpenGL: shaderPath = "shaders/glsl/"; break; case bgfx::RendererType::OpenGLES: shaderPath = "shaders/essl/"; break; case bgfx::RendererType::Vulkan: shaderPath = "shaders/spirv/"; break; + case bgfx::RendererType::WebGPU: shaderPath = "shaders/spirv/"; break; case bgfx::RendererType::Count: - BX_CHECK(false, "You should not be here!"); + BX_ASSERT(false, "You should not be here!"); break; } @@ -124,7 +127,7 @@ static bgfx::ShaderHandle loadShader(bx::FileReaderI* _reader, const char* _name bx::strCat(filePath, BX_COUNTOF(filePath), ".bin"); bgfx::ShaderHandle handle = bgfx::createShader(loadMem(_reader, filePath) ); - bgfx::setName(handle, filePath); + bgfx::setName(handle, _name); return handle; } @@ -158,7 +161,7 @@ static void imageReleaseCb(void* _ptr, void* _userData) bimg::imageFree(imageContainer); } -bgfx::TextureHandle loadTexture(bx::FileReaderI* _reader, const char* _filePath, uint32_t _flags, uint8_t _skip, bgfx::TextureInfo* _info, bimg::Orientation::Enum* _orientation) +bgfx::TextureHandle loadTexture(bx::FileReaderI* _reader, const char* _filePath, uint64_t _flags, uint8_t _skip, bgfx::TextureInfo* _info, bimg::Orientation::Enum* _orientation) { BX_UNUSED(_skip); bgfx::TextureHandle handle = BGFX_INVALID_HANDLE; @@ -244,7 +247,7 @@ bgfx::TextureHandle loadTexture(bx::FileReaderI* _reader, const char* _filePath, return handle; } -bgfx::TextureHandle loadTexture(const char* _name, uint32_t _flags, uint8_t _skip, bgfx::TextureInfo* _info, bimg::Orientation::Enum* _orientation) +bgfx::TextureHandle loadTexture(const char* _name, uint64_t _flags, uint8_t _skip, bgfx::TextureInfo* _info, bimg::Orientation::Enum* _orientation) { return loadTexture(entry::getFileReader(), _name, _flags, _skip, _info, _orientation); } @@ -257,7 +260,7 @@ bimg::ImageContainer* imageLoad(const char* _filePath, bgfx::TextureFormat::Enum return bimg::imageParse(entry::getAllocator(), data, size, bimg::TextureFormat::Enum(_dstFormat) ); } -void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexDecl _decl, const uint16_t* _indices, uint32_t _numIndices) +void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexLayout _layout, const uint16_t* _indices, uint32_t _numIndices) { struct PosTexcoord { @@ -285,14 +288,14 @@ void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexDecl _decl uint32_t i1 = indices[1]; uint32_t i2 = indices[2]; - bgfx::vertexUnpack(&v0.m_x, bgfx::Attrib::Position, _decl, _vertices, i0); - bgfx::vertexUnpack(&v0.m_u, bgfx::Attrib::TexCoord0, _decl, _vertices, i0); + bgfx::vertexUnpack(&v0.m_x, bgfx::Attrib::Position, _layout, _vertices, i0); + bgfx::vertexUnpack(&v0.m_u, bgfx::Attrib::TexCoord0, _layout, _vertices, i0); - bgfx::vertexUnpack(&v1.m_x, bgfx::Attrib::Position, _decl, _vertices, i1); - bgfx::vertexUnpack(&v1.m_u, bgfx::Attrib::TexCoord0, _decl, _vertices, i1); + bgfx::vertexUnpack(&v1.m_x, bgfx::Attrib::Position, _layout, _vertices, i1); + bgfx::vertexUnpack(&v1.m_u, bgfx::Attrib::TexCoord0, _layout, _vertices, i1); - bgfx::vertexUnpack(&v2.m_x, bgfx::Attrib::Position, _decl, _vertices, i2); - bgfx::vertexUnpack(&v2.m_u, bgfx::Attrib::TexCoord0, _decl, _vertices, i2); + bgfx::vertexUnpack(&v2.m_x, bgfx::Attrib::Position, _layout, _vertices, i2); + bgfx::vertexUnpack(&v2.m_u, bgfx::Attrib::TexCoord0, _layout, _vertices, i2); const float bax = v1.m_x - v0.m_x; const float bay = v1.m_y - v0.m_y; @@ -333,300 +336,338 @@ void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexDecl _decl for (uint32_t ii = 0; ii < _numVertices; ++ii) { - const float* tanu = &tangents[ii*6]; - const float* tanv = &tangents[ii*6 + 3]; + const bx::Vec3 tanu = bx::load<bx::Vec3>(&tangents[ii*6]); + const bx::Vec3 tanv = bx::load<bx::Vec3>(&tangents[ii*6 + 3]); - float normal[4]; - bgfx::vertexUnpack(normal, bgfx::Attrib::Normal, _decl, _vertices, ii); - float ndt = bx::vec3Dot(normal, tanu); + float nxyzw[4]; + bgfx::vertexUnpack(nxyzw, bgfx::Attrib::Normal, _layout, _vertices, ii); - float nxt[3]; - bx::vec3Cross(nxt, normal, tanu); - - float tmp[3]; - tmp[0] = tanu[0] - normal[0] * ndt; - tmp[1] = tanu[1] - normal[1] * ndt; - tmp[2] = tanu[2] - normal[2] * ndt; + const bx::Vec3 normal = bx::load<bx::Vec3>(nxyzw); + const float ndt = bx::dot(normal, tanu); + const bx::Vec3 nxt = bx::cross(normal, tanu); + const bx::Vec3 tmp = bx::sub(tanu, bx::mul(normal, ndt) ); float tangent[4]; - bx::vec3Norm(tangent, tmp); + bx::store(tangent, bx::normalize(tmp) ); + tangent[3] = bx::dot(nxt, tanv) < 0.0f ? -1.0f : 1.0f; - tangent[3] = bx::vec3Dot(nxt, tanv) < 0.0f ? -1.0f : 1.0f; - bgfx::vertexPack(tangent, true, bgfx::Attrib::Tangent, _decl, _vertices, ii); + bgfx::vertexPack(tangent, true, bgfx::Attrib::Tangent, _layout, _vertices, ii); } delete [] tangents; } -struct Aabb +Group::Group() { - float m_min[3]; - float m_max[3]; -}; + reset(); +} -struct Obb +void Group::reset() { - float m_mtx[16]; -}; + 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(); +} -struct Sphere +namespace bgfx { - float m_center[3]; - float m_radius; -}; + int32_t read(bx::ReaderI* _reader, bgfx::VertexLayout& _layout, bx::Error* _err); +} -struct Primitive +void Mesh::load(bx::ReaderSeekerI* _reader, bool _ramcopy) { - uint32_t m_startIndex; - uint32_t m_numIndices; - uint32_t m_startVertex; - uint32_t m_numVertices; + 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); - Sphere m_sphere; - Aabb m_aabb; - Obb m_obb; -}; + using namespace bx; + using namespace bgfx; -typedef stl::vector<Primitive> PrimitiveArray; + Group group; -struct Group -{ - Group() - { - reset(); - } + bx::AllocatorI* allocator = entry::getAllocator(); - void reset() + uint32_t chunk; + bx::Error err; + while (4 == bx::read(_reader, chunk, &err) + && err.isOk() ) { - m_vbh.idx = bgfx::kInvalidHandle; - m_ibh.idx = bgfx::kInvalidHandle; - m_prims.clear(); - } + switch (chunk) + { + case kChunkVertexBuffer: + { + read(_reader, group.m_sphere, &err); + read(_reader, group.m_aabb, &err); + read(_reader, group.m_obb, &err); - bgfx::VertexBufferHandle m_vbh; - bgfx::IndexBufferHandle m_ibh; - Sphere m_sphere; - Aabb m_aabb; - Obb m_obb; - PrimitiveArray m_prims; -}; + read(_reader, m_layout, &err); -namespace bgfx -{ - int32_t read(bx::ReaderI* _reader, bgfx::VertexDecl& _decl, bx::Error* _err = NULL); -} - -struct Mesh -{ - void load(bx::ReaderSeekerI* _reader) - { -#define BGFX_CHUNK_MAGIC_VB BX_MAKEFOURCC('V', 'B', ' ', 0x1) -#define BGFX_CHUNK_MAGIC_IB BX_MAKEFOURCC('I', 'B', ' ', 0x0) -#define BGFX_CHUNK_MAGIC_IBC BX_MAKEFOURCC('I', 'B', 'C', 0x0) -#define BGFX_CHUNK_MAGIC_PRI BX_MAKEFOURCC('P', 'R', 'I', 0x0) + uint16_t stride = m_layout.getStride(); - using namespace bx; - using namespace bgfx; + read(_reader, group.m_numVertices, &err); + const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride); + read(_reader, mem->data, mem->size, &err); - Group group; + if (_ramcopy) + { + group.m_vertices = (uint8_t*)BX_ALLOC(allocator, group.m_numVertices*stride); + bx::memCopy(group.m_vertices, mem->data, mem->size); + } - bx::AllocatorI* allocator = entry::getAllocator(); + group.m_vbh = bgfx::createVertexBuffer(mem, m_layout); + } + break; - uint32_t chunk; - bx::Error err; - while (4 == bx::read(_reader, chunk, &err) - && err.isOk() ) - { - switch (chunk) + case kChunkVertexBufferCompressed: { - case BGFX_CHUNK_MAGIC_VB: - { - read(_reader, group.m_sphere); - read(_reader, group.m_aabb); - read(_reader, group.m_obb); + read(_reader, group.m_sphere, &err); + read(_reader, group.m_aabb, &err); + read(_reader, group.m_obb, &err); + + read(_reader, m_layout, &err); + + uint16_t stride = m_layout.getStride(); + + read(_reader, group.m_numVertices, &err); + + const bgfx::Memory* mem = bgfx::alloc(group.m_numVertices*stride); + + uint32_t compressedSize; + bx::read(_reader, compressedSize, &err); - read(_reader, m_decl); + void* compressedVertices = BX_ALLOC(allocator, compressedSize); + bx::read(_reader, compressedVertices, compressedSize, &err); - uint16_t stride = m_decl.getStride(); + meshopt_decodeVertexBuffer(mem->data, group.m_numVertices, stride, (uint8_t*)compressedVertices, compressedSize); - uint16_t numVertices; - read(_reader, numVertices); - const bgfx::Memory* mem = bgfx::alloc(numVertices*stride); - read(_reader, mem->data, mem->size); + BX_FREE(allocator, compressedVertices); - group.m_vbh = bgfx::createVertexBuffer(mem, m_decl); + 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, &err); + + const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2); + read(_reader, mem->data, mem->size, &err); + + 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); } + + group.m_ibh = bgfx::createIndexBuffer(mem); + } break; - case BGFX_CHUNK_MAGIC_IBC: - { - uint32_t numIndices; - bx::read(_reader, numIndices); + case kChunkIndexBufferCompressed: + { + bx::read(_reader, group.m_numIndices, &err); - const bgfx::Memory* mem = bgfx::alloc(numIndices*2); + const bgfx::Memory* mem = bgfx::alloc(group.m_numIndices*2); - uint32_t compressedSize; - bx::read(_reader, compressedSize); + uint32_t compressedSize; + bx::read(_reader, compressedSize, &err); - void* compressedIndices = BX_ALLOC(allocator, compressedSize); + void* compressedIndices = BX_ALLOC(allocator, compressedSize); - bx::read(_reader, compressedIndices, compressedSize); + bx::read(_reader, compressedIndices, compressedSize, &err); - ReadBitstream rbs( (const uint8_t*)compressedIndices, compressedSize); - DecompressIndexBuffer( (uint16_t*)mem->data, numIndices / 3, rbs); + meshopt_decodeIndexBuffer(mem->data, group.m_numIndices, 2, (uint8_t*)compressedIndices, compressedSize); - BX_FREE(allocator, compressedIndices); + BX_FREE(allocator, compressedIndices); - group.m_ibh = bgfx::createIndexBuffer(mem); + 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, &err); + + stl::string material; + material.resize(len); + read(_reader, const_cast<char*>(material.c_str() ), len, &err); + + uint16_t num; + read(_reader, num, &err); + + for (uint32_t ii = 0; ii < num; ++ii) { - 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); - 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(); + read(_reader, len, &err); + + stl::string name; + name.resize(len); + read(_reader, const_cast<char*>(name.c_str() ), len, &err); + + Primitive prim; + read(_reader, prim.m_startIndex, &err); + read(_reader, prim.m_numIndices, &err); + read(_reader, prim.m_startVertex, &err); + read(_reader, prim.m_numVertices, &err); + read(_reader, prim.m_sphere, &err); + read(_reader, prim.m_aabb, &err); + read(_reader, prim.m_obb, &err); + + 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) { - for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) - { - const Group& group = *it; - bgfx::destroy(group.m_vbh); + const Group& group = *it; + bgfx::destroy(group.m_vbh); - if (bgfx::isValid(group.m_ibh) ) - { - bgfx::destroy(group.m_ibh); - } + 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) + if (NULL != group.m_vertices) { - _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 - ; + BX_FREE(allocator, group.m_vertices); } - bgfx::setTransform(_mtx); - bgfx::setState(_state); - - for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) + if (NULL != group.m_indices) { - const Group& group = *it; - - bgfx::setIndexBuffer(group.m_ibh); - bgfx::setVertexBuffer(0, group.m_vbh); - bgfx::submit(_id, _program, 0, it != itEnd-1); + BX_FREE(allocator, group.m_indices); } } + m_groups.clear(); +} - void submit(const MeshState*const* _state, uint8_t _numPasses, const float* _mtx, uint16_t _numMatrices) const +void Mesh::submit(bgfx::ViewId _id, bgfx::ProgramHandle _program, const float* _mtx, uint64_t _state) const +{ + if (BGFX_STATE_MASK == _state) { - uint32_t cached = bgfx::setTransform(_mtx, _numMatrices); + _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 + ; + } - for (uint32_t pass = 0; pass < _numPasses; ++pass) - { - bgfx::setTransform(cached, _numMatrices); + bgfx::setTransform(_mtx); + bgfx::setState(_state); - const MeshState& state = *_state[pass]; - bgfx::setState(state.m_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 + , BGFX_DISCARD_INDEX_BUFFER + | BGFX_DISCARD_VERTEX_STREAMS + ); + } - 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::discard(); +} - for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) - { - const Group& group = *it; +void Mesh::submit(const MeshState*const* _state, uint8_t _numPasses, const float* _mtx, uint16_t _numMatrices) const +{ + uint32_t cached = bgfx::setTransform(_mtx, _numMatrices); - bgfx::setIndexBuffer(group.m_ibh); - bgfx::setVertexBuffer(0, group.m_vbh); - bgfx::submit(state.m_viewId, state.m_program, 0, it != itEnd-1); - } + 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 + , BGFX_DISCARD_INDEX_BUFFER + | BGFX_DISCARD_VERTEX_STREAMS + ); } + + bgfx::discard(0 + | BGFX_DISCARD_BINDINGS + | BGFX_DISCARD_STATE + | BGFX_DISCARD_TRANSFORM + ); } - bgfx::VertexDecl m_decl; - typedef stl::vector<Group> GroupArray; - GroupArray m_groups; -}; + bgfx::discard(); +} -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; } @@ -661,6 +702,53 @@ void meshSubmit(const Mesh* _mesh, const MeshState*const* _state, uint8_t _numPa _mesh->submit(_state, _numPasses, _mtx, _numMatrices); } +struct RendererTypeRemap +{ + bx::StringView name; + bgfx::RendererType::Enum type; +}; + +static RendererTypeRemap s_rendererTypeRemap[] = +{ + { "d3d11", bgfx::RendererType::Direct3D11 }, + { "d3d12", bgfx::RendererType::Direct3D12 }, + { "d3d9", bgfx::RendererType::Direct3D9 }, + { "gl", bgfx::RendererType::OpenGL }, + { "mtl", bgfx::RendererType::Metal }, + { "noop", bgfx::RendererType::Noop }, + { "vk", bgfx::RendererType::Vulkan }, +}; + +bx::StringView getName(bgfx::RendererType::Enum _type) +{ + for (uint32_t ii = 0; ii < BX_COUNTOF(s_rendererTypeRemap); ++ii) + { + const RendererTypeRemap& remap = s_rendererTypeRemap[ii]; + + if (_type == remap.type) + { + return remap.name; + } + } + + return ""; +} + +bgfx::RendererType::Enum getType(const bx::StringView& _name) +{ + for (uint32_t ii = 0; ii < BX_COUNTOF(s_rendererTypeRemap); ++ii) + { + const RendererTypeRemap& remap = s_rendererTypeRemap[ii]; + + if (0 == bx::strCmpI(_name, remap.name) ) + { + return remap.type; + } + } + + return bgfx::RendererType::Count; +} + Args::Args(int _argc, const char* const* _argv) : m_type(bgfx::RendererType::Count) , m_pciId(BGFX_PCI_ID_NONE) @@ -679,20 +767,17 @@ Args::Args(int _argc, const char* const* _argv) { m_type = bgfx::RendererType::Noop; } - else if (BX_ENABLED(BX_PLATFORM_WINDOWS|BX_PLATFORM_WINRT|BX_PLATFORM_XBOXONE) ) + if (cmdLine.hasArg("d3d9") ) { - if (cmdLine.hasArg("d3d9") ) - { - m_type = bgfx::RendererType::Direct3D9; - } - else if (cmdLine.hasArg("d3d11") ) - { - m_type = bgfx::RendererType::Direct3D11; - } - else if (cmdLine.hasArg("d3d12") ) - { - m_type = bgfx::RendererType::Direct3D12; - } + m_type = bgfx::RendererType::Direct3D9; + } + else if (cmdLine.hasArg("d3d11") ) + { + m_type = bgfx::RendererType::Direct3D11; + } + else if (cmdLine.hasArg("d3d12") ) + { + m_type = bgfx::RendererType::Direct3D12; } else if (BX_ENABLED(BX_PLATFORM_OSX) ) { |