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

Remove duplicate outdated loading code

Browse Source
This commit is contained in:
Hugo Amnov
2020-02-01 19:46:21 +01:00
committed by Бранимир Караџић
parent a38e873f8a
commit fa9abba09f
1 changed files with 13 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
examples/16-shadowmaps/shadowmaps.cpp
View File

@@ -16,6 +16,7 @@
#include <bx/file.h>
#include "entry/entry.h"
#include "camera.h"
#include "bgfx_utils.h"
#include "imgui/imgui.h"
namespace bgfx
@@ -759,183 +760,35 @@ struct ClearValues
uint8_t m_clearStencil;
};
struct Aabb
struct Mesh : public ::Mesh
{
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<Primitive> PrimitiveArray;
struct Group
{
Group()
void load(const char* _filePath, bool _ramcopy = false)
{
reset();
bx::FileReaderI* reader = entry::getFileReader();
if (bx::open(reader, _filePath))
{
::Mesh::load(reader, _ramcopy);
bx::close(reader);
}
}
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;
};
struct Mesh
{
void load(const void* _vertices, uint32_t _numVertices, const bgfx::VertexLayout _layout, const uint16_t* _indices, uint32_t _numIndices)
{
Group group;
const bgfx::Memory* mem;
uint32_t size;
size = _numVertices*_layout.getStride();
size = _numVertices * _layout.getStride();
mem = bgfx::makeRef(_vertices, size);
group.m_vbh = bgfx::createVertexBuffer(mem, _layout);
size = _numIndices*2;
size = _numIndices * 2;
mem = bgfx::makeRef(_indices, size);
group.m_ibh = bgfx::createIndexBuffer(mem);
m_groups.push_back(group);
}
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)
bx::FileReaderI* reader = entry::getFileReader();
bx::open(reader, _filePath);
Group group;
uint32_t chunk;
while (4 == bx::read(reader, chunk) )
{
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);
bgfx::read(reader, m_layout);
uint16_t stride = m_layout.getStride();
uint16_t numVertices;
bx::read(reader, numVertices);
const bgfx::Memory* mem = bgfx::alloc(numVertices*stride);
bx::read(reader, mem->data, mem->size);
group.m_vbh = bgfx::createVertexBuffer(mem, m_layout);
}
break;
case BGFX_CHUNK_MAGIC_IB:
{
uint32_t numIndices;
bx::read(reader, numIndices);
const bgfx::Memory* mem = bgfx::alloc(numIndices*2);
bx::read(reader, mem->data, mem->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<char*>(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<char*>(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) );
break;
}
}
bx::close(reader);
}
void unload()
{
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::kInvalidHandle != group.m_ibh.idx)
{
bgfx::destroy(group.m_ibh);
}
}
m_groups.clear();
}
void submit(uint8_t _viewId, float* _mtx, bgfx::ProgramHandle _program, const RenderState& _renderState, bool _submitShadowMaps = false)
{
bgfx::TextureHandle texture = BGFX_INVALID_HANDLE;
@@ -966,7 +819,7 @@ struct Mesh
{
for (uint8_t ii = 0; ii < ShadowMapRenderTargets::Count; ++ii)
{
bgfx::setTexture(4 + ii, s_shadowMap[ii], bgfx::getTexture(s_rtShadowMap[ii]) );
bgfx::setTexture(4 + ii, s_shadowMap[ii], bgfx::getTexture(s_rtShadowMap[ii]));
}
}
@@ -978,12 +831,9 @@ struct Mesh
bgfx::submit(_viewId, _program);
}
}
bgfx::VertexLayout m_layout;
typedef std::vector<Group> GroupArray;
GroupArray m_groups;
};
struct PosColorTexCoord0Vertex
{
float m_x;