summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/examples/common/bgfx_utils.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/examples/common/bgfx_utils.cpp')
-rw-r--r--3rdparty/bgfx/examples/common/bgfx_utils.cpp553
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) )
{