From 7db31fc7fa407f67cdde3ce69174a646fb683b73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Branimir=20Karad=C5=BEi=C4=87?= Date: Wed, 7 Jan 2015 22:36:36 -0800 Subject: [PATCH] Cleanup. --- .../shadowmaps_simple.cpp | 480 ++++-------------- examples/common/bgfx_utils.cpp | 67 ++- examples/common/bgfx_utils.h | 25 +- examples/common/entry/entry.cpp | 10 +- examples/common/entry/entry.h | 3 +- 5 files changed, 195 insertions(+), 390 deletions(-) diff --git a/examples/15-shadowmaps-simple/shadowmaps_simple.cpp b/examples/15-shadowmaps-simple/shadowmaps_simple.cpp index 51782513..8982b18d 100644 --- a/examples/15-shadowmaps-simple/shadowmaps_simple.cpp +++ b/examples/15-shadowmaps-simple/shadowmaps_simple.cpp @@ -14,6 +14,7 @@ #include #include #include "entry/entry.h" +#include "bgfx_utils.h" #define RENDER_SHADOW_PASS_ID 0 #define RENDER_SCENE_PASS_ID 1 @@ -65,323 +66,6 @@ static const uint16_t s_planeIndices[] = 1, 3, 2, }; -static const char* s_shaderPath = NULL; -static bool s_flipV = false; -static float s_texelHalf = 0.0f; -bgfx::FrameBufferHandle s_shadowMapFB; -static bgfx::UniformHandle u_shadowMap; - -inline void mtxProj(float* _result, float _fovy, float _aspect, float _near, float _far) -{ - bx::mtxProj(_result, _fovy, _aspect, _near, _far, s_flipV); -} - -static void shaderFilePath(char* _out, const char* _name) -{ - strcpy(_out, s_shaderPath); - strcat(_out, _name); - strcat(_out, ".bin"); -} - -long int fsize(FILE* _file) -{ - long int pos = ftell(_file); - fseek(_file, 0L, SEEK_END); - long int size = ftell(_file); - fseek(_file, pos, SEEK_SET); - return size; -} - -static const bgfx::Memory* load(const char* _filePath) -{ - FILE* file = fopen(_filePath, "rb"); - if (NULL != file) - { - uint32_t size = (uint32_t)fsize(file); - const bgfx::Memory* mem = bgfx::alloc(size+1); - size_t ignore = fread(mem->data, 1, size, file); - BX_UNUSED(ignore); - fclose(file); - mem->data[mem->size-1] = '\0'; - return mem; - } - - return NULL; -} - -static const bgfx::Memory* loadShader(const char* _name) -{ - char filePath[512]; - shaderFilePath(filePath, _name); - return load(filePath); -} - -static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) -{ - const bgfx::Memory* mem; - - // Load vertex shader. - mem = loadShader(_vsName); - bgfx::ShaderHandle vsh = bgfx::createShader(mem); - - // Load fragment shader. - mem = loadShader(_fsName); - bgfx::ShaderHandle fsh = bgfx::createShader(mem); - - // Create program from shaders. - return bgfx::createProgram(vsh, fsh, true /* destroy shaders when program is destroyed */); -} - -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 Group -{ - Group() - { - reset(); - } - - void reset() - { - m_vbh.idx = bgfx::invalidHandle; - m_ibh.idx = bgfx::invalidHandle; - m_prims.clear(); - } - - bgfx::VertexBufferHandle m_vbh; - bgfx::IndexBufferHandle m_ibh; - Sphere m_sphere; - Aabb m_aabb; - Obb m_obb; - PrimitiveArray m_prims; -}; - -namespace bgfx -{ - int32_t read(bx::ReaderI* _reader, bgfx::VertexDecl& _decl); -} - -struct Mesh -{ - void load(const void* _vertices, uint32_t _numVertices, const bgfx::VertexDecl _decl, const uint16_t* _indices, uint32_t _numIndices) - { - Group group; - const bgfx::Memory* mem; - uint32_t size; - - size = _numVertices*_decl.getStride(); - mem = bgfx::makeRef(_vertices, size); - group.m_vbh = bgfx::createVertexBuffer(mem, _decl); - - size = _numIndices*2; - mem = bgfx::makeRef(_indices, size); - group.m_ibh = bgfx::createIndexBuffer(mem); - - //TODO: - // group.m_sphere = ... - // group.m_aabb = ... - // group.m_obb = ... - // group.m_prims = ... - - 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::CrtFileReader reader; - reader.open(_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_decl); - uint16_t stride = m_decl.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_decl); - } - 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(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, reader.seek() ); - break; - } - } - - reader.close(); - } - - void unload() - { - for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) - { - const Group& group = *it; - bgfx::destroyVertexBuffer(group.m_vbh); - - if (bgfx::isValid(group.m_ibh) ) - { - bgfx::destroyIndexBuffer(group.m_ibh); - } - } - m_groups.clear(); - } - - void submit(uint8_t _view, float* _mtx, bgfx::ProgramHandle _program) - { - for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) - { - const Group& group = *it; - - // Set model matrix for rendering. - bgfx::setTransform(_mtx); - bgfx::setProgram(_program); - bgfx::setIndexBuffer(group.m_ibh); - bgfx::setVertexBuffer(group.m_vbh); - - // Set shadow map. - bgfx::setTexture(4, u_shadowMap, s_shadowMapFB); - - // Set render states. - bgfx::setState(0 - | BGFX_STATE_RGB_WRITE - | BGFX_STATE_ALPHA_WRITE - | BGFX_STATE_DEPTH_WRITE - | BGFX_STATE_DEPTH_TEST_LESS - | BGFX_STATE_CULL_CCW - | BGFX_STATE_MSAA - ); - - // Submit primitive for rendering. - bgfx::submit(_view); - } - } - - void submitShadow(uint8_t _view, float* _mtx, bgfx::ProgramHandle _program) - { - for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) - { - const Group& group = *it; - - // Set model matrix for rendering. - bgfx::setTransform(_mtx); - bgfx::setProgram(_program); - bgfx::setIndexBuffer(group.m_ibh); - bgfx::setVertexBuffer(group.m_vbh); - - // Set render states. - bgfx::setState(0 - | BGFX_STATE_RGB_WRITE - | BGFX_STATE_ALPHA_WRITE - | BGFX_STATE_DEPTH_WRITE - | BGFX_STATE_DEPTH_TEST_LESS - | BGFX_STATE_CULL_CCW - | BGFX_STATE_MSAA - ); - - // Submit primitive for rendering. - bgfx::submit(_view); - } - } - - bgfx::VertexDecl m_decl; - typedef std::vector GroupArray; - GroupArray m_groups; -}; - int _main_(int /*_argc*/, char** /*_argv*/) { uint32_t width = 1280; @@ -392,39 +76,19 @@ int _main_(int /*_argc*/, char** /*_argv*/) bgfx::init(); bgfx::reset(width, height, reset); + bgfx::RendererType::Enum renderer = bgfx::getRendererType(); + bool flipV = false + || renderer == bgfx::RendererType::OpenGL + || renderer == bgfx::RendererType::OpenGLES + ; + // Enable debug text. bgfx::setDebug(debug); - // Setup root path for binary shaders. Shader binaries are different - // for each renderer. - switch (bgfx::getRendererType() ) - { - default: - case bgfx::RendererType::Direct3D9: - s_shaderPath = "shaders/dx9/"; - s_texelHalf = 0.5f; - break; - - case bgfx::RendererType::Direct3D11: - s_shaderPath = "shaders/dx11/"; - break; - - case bgfx::RendererType::OpenGL: - s_shaderPath = "shaders/glsl/"; - s_flipV = true; - break; - - case bgfx::RendererType::OpenGLES: - s_shaderPath = "shaders/gles/"; - s_flipV = true; - break; - } - // Uniforms. - u_shadowMap = bgfx::createUniform("u_shadowMap", bgfx::UniformType::Uniform1iv); - - bgfx::UniformHandle u_lightPos = bgfx::createUniform("u_lightPos", bgfx::UniformType::Uniform4fv); - bgfx::UniformHandle u_lightMtx = bgfx::createUniform("u_lightMtx", bgfx::UniformType::Uniform4x4fv); + bgfx::UniformHandle u_shadowMap = bgfx::createUniform("u_shadowMap", bgfx::UniformType::Uniform1iv); + bgfx::UniformHandle u_lightPos = bgfx::createUniform("u_lightPos", bgfx::UniformType::Uniform4fv); + bgfx::UniformHandle u_lightMtx = bgfx::createUniform("u_lightMtx", bgfx::UniformType::Uniform4x4fv); // Vertex declarations. bgfx::VertexDecl PosNormalDecl; @@ -434,14 +98,18 @@ int _main_(int /*_argc*/, char** /*_argv*/) .end(); // Meshes. - Mesh bunnyMesh; - Mesh cubeMesh; - Mesh hollowcubeMesh; - Mesh hplaneMesh; - bunnyMesh.load("meshes/bunny.bin"); - cubeMesh.load("meshes/cube.bin"); - hollowcubeMesh.load("meshes/hollowcube.bin"); - hplaneMesh.load(s_hplaneVertices, BX_COUNTOF(s_hplaneVertices), PosNormalDecl, s_planeIndices, BX_COUNTOF(s_planeIndices) ); + Mesh* bunny = meshLoad("meshes/bunny.bin"); + Mesh* cube = meshLoad("meshes/cube.bin"); + Mesh* hollowcube = meshLoad("meshes/hollowcube.bin"); + + bgfx::VertexBufferHandle vbh = bgfx::createVertexBuffer( + bgfx::makeRef(s_hplaneVertices, sizeof(s_hplaneVertices) ) + , PosNormalDecl + ); + + bgfx::IndexBufferHandle ibh = bgfx::createIndexBuffer( + bgfx::makeRef(s_planeIndices, sizeof(s_planeIndices) ) + ); // Render targets. uint16_t shadowMapSize = 512; @@ -454,6 +122,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) bgfx::ProgramHandle progShadow; bgfx::ProgramHandle progMesh; + bgfx::TextureHandle shadowMapTexture; + bgfx::FrameBufferHandle shadowMapFB; if (shadowSamplerSupported) { @@ -461,11 +131,9 @@ int _main_(int /*_argc*/, char** /*_argv*/) progShadow = loadProgram("vs_sms_shadow", "fs_sms_shadow"); progMesh = loadProgram("vs_sms_mesh", "fs_sms_mesh"); - bgfx::TextureHandle fbtextures[] = - { - bgfx::createTexture2D(shadowMapSize, shadowMapSize, 1, bgfx::TextureFormat::D16, BGFX_TEXTURE_COMPARE_LEQUAL), - }; - s_shadowMapFB = bgfx::createFrameBuffer(BX_COUNTOF(fbtextures), fbtextures, true); + shadowMapTexture = bgfx::createTexture2D(shadowMapSize, shadowMapSize, 1, bgfx::TextureFormat::D16, BGFX_TEXTURE_COMPARE_LEQUAL); + bgfx::TextureHandle fbtextures[] = { shadowMapTexture }; + shadowMapFB = bgfx::createFrameBuffer(BX_COUNTOF(fbtextures), fbtextures, true); } else { @@ -474,14 +142,46 @@ int _main_(int /*_argc*/, char** /*_argv*/) progShadow = loadProgram("vs_sms_shadow_pd", "fs_sms_shadow_pd"); progMesh = loadProgram("vs_sms_mesh", "fs_sms_mesh_pd"); + shadowMapTexture = bgfx::createTexture2D(shadowMapSize, shadowMapSize, 1, bgfx::TextureFormat::BGRA8, BGFX_TEXTURE_RT); bgfx::TextureHandle fbtextures[] = { - bgfx::createTexture2D(shadowMapSize, shadowMapSize, 1, bgfx::TextureFormat::BGRA8, BGFX_TEXTURE_RT), + shadowMapTexture, bgfx::createTexture2D(shadowMapSize, shadowMapSize, 1, bgfx::TextureFormat::D16, BGFX_TEXTURE_RT_BUFFER_ONLY), }; - s_shadowMapFB = bgfx::createFrameBuffer(BX_COUNTOF(fbtextures), fbtextures, true); + shadowMapFB = bgfx::createFrameBuffer(BX_COUNTOF(fbtextures), fbtextures, true); } + MeshState* state[2]; + state[0] = meshStateCreate(); + state[0]->m_state = 0 + | BGFX_STATE_RGB_WRITE + | BGFX_STATE_ALPHA_WRITE + | BGFX_STATE_DEPTH_WRITE + | BGFX_STATE_DEPTH_TEST_LESS + | BGFX_STATE_CULL_CCW + | BGFX_STATE_MSAA + ; + state[0]->m_program = progShadow; + state[0]->m_viewId = RENDER_SHADOW_PASS_ID; + state[0]->m_numTextures = 0; + + state[1] = meshStateCreate(); + state[1]->m_state = 0 + | BGFX_STATE_RGB_WRITE + | BGFX_STATE_ALPHA_WRITE + | BGFX_STATE_DEPTH_WRITE + | BGFX_STATE_DEPTH_TEST_LESS + | BGFX_STATE_CULL_CCW + | BGFX_STATE_MSAA + ; + state[1]->m_program = progMesh; + state[1]->m_viewId = RENDER_SCENE_PASS_ID; + state[1]->m_numTextures = 1; + state[1]->m_textures[0].m_flags = UINT32_MAX; + state[1]->m_textures[0].m_stage = 4; + state[1]->m_textures[0].m_sampler = u_shadowMap; + state[1]->m_textures[0].m_texture = shadowMapTexture; + // Set view and projection matrices. float view[16]; float proj[16]; @@ -491,7 +191,7 @@ int _main_(int /*_argc*/, char** /*_argv*/) bx::mtxLookAt(view, eye, at); const float aspect = float(int32_t(width) ) / float(int32_t(height) ); - mtxProj(proj, 60.0f, aspect, 0.1f, 1000.0f); + bx::mtxProj(proj, 60.0f, aspect, 0.1f, 1000.0f, flipV); // Time acumulators. float timeAccumulatorLight = 0.0f; @@ -574,7 +274,7 @@ int _main_(int /*_argc*/, char** /*_argv*/) bx::mtxOrtho(lightProj, -area, area, -area, area, -100.0f, 100.0f); bgfx::setViewRect(RENDER_SHADOW_PASS_ID, 0, 0, shadowMapSize, shadowMapSize); - bgfx::setViewFrameBuffer(RENDER_SHADOW_PASS_ID, s_shadowMapFB); + bgfx::setViewFrameBuffer(RENDER_SHADOW_PASS_ID, shadowMapFB); bgfx::setViewTransform(RENDER_SHADOW_PASS_ID, lightView, lightProj); bgfx::setViewRect(RENDER_SCENE_PASS_ID, 0, 0, width, height); @@ -595,7 +295,7 @@ int _main_(int /*_argc*/, char** /*_argv*/) float mtxShadow[16]; float lightMtx[16]; - const float sy = s_flipV ? 0.5f : -0.5f; + const float sy = flipV ? 0.5f : -0.5f; const float mtxCrop[16] = { 0.5f, 0.0f, 0.0f, 0.0f, @@ -605,47 +305,71 @@ int _main_(int /*_argc*/, char** /*_argv*/) }; float mtxTmp[16]; - bx::mtxMul(mtxTmp, lightProj, mtxCrop); + bx::mtxMul(mtxTmp, lightProj, mtxCrop); bx::mtxMul(mtxShadow, lightView, mtxTmp); // Floor. bx::mtxMul(lightMtx, mtxFloor, mtxShadow); bgfx::setUniform(u_lightMtx, lightMtx); - hplaneMesh.submit(RENDER_SCENE_PASS_ID, mtxFloor, progMesh); - hplaneMesh.submitShadow(RENDER_SHADOW_PASS_ID, mtxFloor, progShadow); + uint32_t cached = bgfx::setTransform(mtxFloor); + for (uint32_t pass = 0; pass < 2; ++pass) + { + const MeshState& st = *state[pass]; + bgfx::setTransform(cached); + for (uint8_t tex = 0; tex < st.m_numTextures; ++tex) + { + const MeshState::Texture& texture = st.m_textures[tex]; + bgfx::setTexture(texture.m_stage + , texture.m_sampler + , texture.m_texture + , texture.m_flags + ); + } + bgfx::setUniform(u_lightMtx, lightMtx); + bgfx::setProgram(st.m_program); + bgfx::setIndexBuffer(ibh); + bgfx::setVertexBuffer(vbh); + bgfx::setState(st.m_state); + bgfx::submit(st.m_viewId); + } // Bunny. bx::mtxMul(lightMtx, mtxBunny, mtxShadow); bgfx::setUniform(u_lightMtx, lightMtx); - bunnyMesh.submit(RENDER_SCENE_PASS_ID, mtxBunny, progMesh); - bunnyMesh.submitShadow(RENDER_SHADOW_PASS_ID, mtxBunny, progShadow); + meshSubmit(bunny, &state[0], 1, mtxBunny); + meshSubmit(bunny, &state[1], 1, mtxBunny); // Hollow cube. bx::mtxMul(lightMtx, mtxHollowcube, mtxShadow); bgfx::setUniform(u_lightMtx, lightMtx); - hollowcubeMesh.submit(RENDER_SCENE_PASS_ID, mtxHollowcube, progMesh); - hollowcubeMesh.submitShadow(RENDER_SHADOW_PASS_ID, mtxHollowcube, progShadow); + meshSubmit(hollowcube, &state[0], 1, mtxHollowcube); + meshSubmit(hollowcube, &state[1], 1, mtxHollowcube); // Cube. bx::mtxMul(lightMtx, mtxCube, mtxShadow); bgfx::setUniform(u_lightMtx, lightMtx); - cubeMesh.submit(RENDER_SCENE_PASS_ID, mtxCube, progMesh); - cubeMesh.submitShadow(RENDER_SHADOW_PASS_ID, mtxCube, progShadow); + meshSubmit(cube, &state[0], 1, mtxCube); + meshSubmit(cube, &state[1], 1, mtxCube); // Advance to next frame. Rendering thread will be kicked to // process submitted rendering primitives. bgfx::frame(); } - bunnyMesh.unload(); - cubeMesh.unload(); - hollowcubeMesh.unload(); - hplaneMesh.unload(); + meshUnload(bunny); + meshUnload(cube); + meshUnload(hollowcube); + + meshStateDestroy(state[0]); + meshStateDestroy(state[1]); + + bgfx::destroyVertexBuffer(vbh); + bgfx::destroyIndexBuffer(ibh); bgfx::destroyProgram(progShadow); bgfx::destroyProgram(progMesh); - bgfx::destroyFrameBuffer(s_shadowMapFB); + bgfx::destroyFrameBuffer(shadowMapFB); bgfx::destroyUniform(u_shadowMap); bgfx::destroyUniform(u_lightPos); diff --git a/examples/common/bgfx_utils.cpp b/examples/common/bgfx_utils.cpp index df293298..637ed6ca 100644 --- a/examples/common/bgfx_utils.cpp +++ b/examples/common/bgfx_utils.cpp @@ -16,6 +16,8 @@ namespace stl = tinystl; #include "entry/entry.h" #include +#include "bgfx_utils.h" + void* load(bx::FileReaderI* _reader, const char* _filePath) { if (0 == bx::open(_reader, _filePath) ) @@ -214,7 +216,7 @@ void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexDecl _decl } delete [] tangents; -} +} struct Aabb { @@ -288,6 +290,8 @@ struct Mesh Group group; + bx::ReallocatorI* allocator = entry::getAllocator(); + uint32_t chunk; while (4 == bx::read(_reader, chunk) ) { @@ -332,15 +336,14 @@ struct Mesh uint32_t compressedSize; bx::read(_reader, compressedSize); - bx::CrtAllocator allocator; - void* compressedIndices = BX_ALLOC(&allocator, compressedSize); + void* compressedIndices = BX_ALLOC(allocator, compressedSize); bx::read(_reader, compressedIndices, compressedSize); ReadBitstream rbs( (const uint8_t*)compressedIndices, compressedSize); DecompressIndexBuffer( (uint16_t*)mem->data, numIndices / 3, rbs); - BX_FREE(&allocator, compressedIndices); + BX_FREE(allocator, compressedIndices); group.m_ibh = bgfx::createIndexBuffer(mem); } @@ -405,7 +408,7 @@ struct Mesh m_groups.clear(); } - void submit(uint8_t _id, bgfx::ProgramHandle _program, float* _mtx, uint64_t _state) + void submit(uint8_t _id, bgfx::ProgramHandle _program, const float* _mtx, uint64_t _state) const { if (BGFX_STATE_MASK == _state) { @@ -419,12 +422,13 @@ struct Mesh ; } + uint32_t cached = bgfx::setTransform(_mtx); + for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) { const Group& group = *it; - // Set model matrix for rendering. - bgfx::setTransform(_mtx); + bgfx::setTransform(cached); bgfx::setProgram(_program); bgfx::setIndexBuffer(group.m_ibh); bgfx::setVertexBuffer(group.m_vbh); @@ -433,6 +437,37 @@ struct Mesh } } + 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) + { + const MeshState& state = *_state[pass]; + + for (GroupArray::const_iterator it = m_groups.begin(), itEnd = m_groups.end(); it != itEnd; ++it) + { + const Group& group = *it; + + bgfx::setTransform(cached, _numMatrices); + 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::setProgram(state.m_program); + bgfx::setIndexBuffer(group.m_ibh); + bgfx::setVertexBuffer(group.m_vbh); + bgfx::setState(state.m_state); + bgfx::submit(state.m_viewId); + } + } + } + bgfx::VertexDecl m_decl; typedef stl::vector GroupArray; GroupArray m_groups; @@ -460,7 +495,23 @@ void meshUnload(Mesh* _mesh) delete _mesh; } -void meshSubmit(Mesh* _mesh, uint8_t _id, bgfx::ProgramHandle _program, float* _mtx, uint64_t _state) +MeshState* meshStateCreate() +{ + MeshState* state = (MeshState*)BX_ALLOC(entry::getAllocator(), sizeof(MeshState) ); + return state; +} + +void meshStateDestroy(MeshState* _meshState) +{ + BX_FREE(entry::getAllocator(), _meshState); +} + +void meshSubmit(const Mesh* _mesh, uint8_t _id, bgfx::ProgramHandle _program, const float* _mtx, uint64_t _state) { _mesh->submit(_id, _program, _mtx, _state); } + +void meshSubmit(const Mesh* _mesh, const MeshState*const* _state, uint8_t _numPasses, const float* _mtx, uint16_t _numMatrices) +{ + _mesh->submit(_state, _numPasses, _mtx, _numMatrices); +} diff --git a/examples/common/bgfx_utils.h b/examples/common/bgfx_utils.h index a9352656..73fc5838 100644 --- a/examples/common/bgfx_utils.h +++ b/examples/common/bgfx_utils.h @@ -14,9 +14,32 @@ bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName); bgfx::TextureHandle loadTexture(const char* _name, uint32_t _flags = BGFX_TEXTURE_NONE, uint8_t _skip = 0, bgfx::TextureInfo* _info = NULL); void calcTangents(void* _vertices, uint16_t _numVertices, bgfx::VertexDecl _decl, const uint16_t* _indices, uint32_t _numIndices); +struct MeshState +{ + struct Texture + { + uint32_t m_flags; + bgfx::UniformHandle m_sampler; + bgfx::TextureHandle m_texture; + uint8_t m_stage; + }; + + Texture m_textures[4]; + uint64_t m_state; + bgfx::ProgramHandle m_program; + uint8_t m_numTextures; + uint8_t m_viewId; +}; + struct Mesh; + Mesh* meshLoad(const char* _filePath); void meshUnload(Mesh* _mesh); -void meshSubmit(Mesh* _mesh, uint8_t _id, bgfx::ProgramHandle _program, float* _mtx, uint64_t _state = BGFX_STATE_MASK); + +MeshState* meshStateCreate(); +void meshStateDestroy(MeshState* _meshState); + +void meshSubmit(const Mesh* _mesh, uint8_t _id, bgfx::ProgramHandle _program, const float* _mtx, uint64_t _state = BGFX_STATE_MASK); +void meshSubmit(const Mesh* _mesh, const MeshState*const* _state, uint8_t _numPasses, const float* _mtx, uint16_t _numMatrices = 1); #endif // BGFX_UTILS_H_HEADER_GUARD diff --git a/examples/common/entry/entry.cpp b/examples/common/entry/entry.cpp index 341cb07e..eeab9e10 100644 --- a/examples/common/entry/entry.cpp +++ b/examples/common/entry/entry.cpp @@ -22,6 +22,7 @@ namespace entry static bool s_exit = false; static bx::FileReaderI* s_fileReader = NULL; static bx::FileWriterI* s_fileWriter = NULL; + static bx::CrtAllocator s_allocator; bool setOrToggle(uint32_t& _flags, const char* _name, uint32_t _bit, int _first, int _argc, char const* const* _argv) { @@ -109,7 +110,7 @@ namespace entry return 0; } - static const InputBinding s_bindings[] = + static const InputBinding s_bindings[] = { { entry::Key::KeyQ, entry::Modifier::LeftCtrl, 1, cmd, "exit" }, { entry::Key::F1, entry::Modifier::None, 1, cmd, "graphics stats" }, @@ -295,7 +296,7 @@ namespace entry : m_ev(poll(_handle) ) { } - + ~SE() { if (NULL != m_ev) @@ -444,6 +445,11 @@ namespace entry return s_fileWriter; } + bx::ReallocatorI* getAllocator() + { + return &s_allocator; + } + } // namespace entry extern "C" bool entry_process_events(uint32_t* _width, uint32_t* _height, uint32_t* _debug, uint32_t* _reset) diff --git a/examples/common/entry/entry.h b/examples/common/entry/entry.h index 79c8eda0..7f6524b8 100644 --- a/examples/common/entry/entry.h +++ b/examples/common/entry/entry.h @@ -10,7 +10,7 @@ #include // memset #include -namespace bx { struct FileReaderI; struct FileWriterI; } +namespace bx { struct FileReaderI; struct FileWriterI; struct ReallocatorI; } extern "C" int _main_(int _argc, char** _argv); @@ -203,6 +203,7 @@ namespace entry bx::FileReaderI* getFileReader(); bx::FileWriterI* getFileWriter(); + bx::ReallocatorI* getAllocator(); WindowHandle createWindow(int32_t _x, int32_t _y, uint32_t _width, uint32_t _height, uint32_t _flags = ENTRY_WINDOW_FLAG_NONE, const char* _title = ""); void destroyWindow(WindowHandle _handle);