From f436f79c10a5873293cf69efe90d3808b40d769c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Branimir=20Karad=C5=BEi=C4=87?= Date: Sat, 29 Mar 2014 19:42:57 -0700 Subject: [PATCH] Simplified API, removed difference between vertex and fragment shaders. --- examples/01-cubes/cubes.cpp | 8 +- examples/02-metaballs/metaballs.cpp | 8 +- examples/03-raymarch/raymarch.cpp | 8 +- examples/04-mesh/mesh.cpp | 8 +- examples/05-instancing/instancing.cpp | 8 +- examples/06-bump/bump.cpp | 8 +- examples/07-callback/callback.cpp | 8 +- examples/08-update/update.cpp | 8 +- examples/09-hdr/hdr.cpp | 8 +- examples/12-lod/lod.cpp | 8 +- examples/13-stencil/stencil.cpp | 8 +- examples/14-shadowvolumes/shadowvolumes.cpp | 8 +- .../shadowmaps_simple.cpp | 8 +- examples/16-shadowmaps/shadowmaps.cpp | 8 +- examples/17-drawstress/drawstress.cpp | 8 +- examples/18-ibl/ibl.cpp | 8 +- examples/19-oit/oit.cpp | 4 +- examples/common/font/text_buffer_manager.cpp | 28 +-- examples/common/imgui/imgui.cpp | 20 +- include/bgfx.h | 24 +-- src/bgfx.cpp | 94 +++------- src/bgfx_p.h | 171 +++++------------- src/config.h | 8 +- src/renderer_d3d11.cpp | 53 +++--- src/renderer_d3d11.h | 2 +- src/renderer_d3d9.cpp | 53 +++--- src/renderer_d3d9.h | 2 +- src/renderer_gl.cpp | 51 +++--- src/renderer_gl.h | 2 +- src/renderer_null.cpp | 14 +- 30 files changed, 254 insertions(+), 400 deletions(-) diff --git a/examples/01-cubes/cubes.cpp b/examples/01-cubes/cubes.cpp index 11569150c..f69cbf3b1 100644 --- a/examples/01-cubes/cubes.cpp +++ b/examples/01-cubes/cubes.cpp @@ -155,11 +155,11 @@ int _main_(int /*_argc*/, char** /*_argv*/) // Load vertex shader. mem = loadShader("vs_cubes"); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader("fs_cubes"); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -168,8 +168,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); float at[3] = { 0.0f, 0.0f, 0.0f }; float eye[3] = { 0.0f, 0.0f, -35.0f }; diff --git a/examples/02-metaballs/metaballs.cpp b/examples/02-metaballs/metaballs.cpp index d759ee7e8..6a9cccc8d 100644 --- a/examples/02-metaballs/metaballs.cpp +++ b/examples/02-metaballs/metaballs.cpp @@ -504,8 +504,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) break; } - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(vs_metaballs); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(fs_metaballs); + bgfx::ShaderHandle vsh = bgfx::createShader(vs_metaballs); + bgfx::ShaderHandle fsh = bgfx::createShader(fs_metaballs); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -514,8 +514,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); #define DIMS 32 diff --git a/examples/03-raymarch/raymarch.cpp b/examples/03-raymarch/raymarch.cpp index ffa3b9ccf..5d672adfe 100644 --- a/examples/03-raymarch/raymarch.cpp +++ b/examples/03-raymarch/raymarch.cpp @@ -74,11 +74,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // Load vertex shader. mem = loadShader(_vsName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -87,8 +87,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/04-mesh/mesh.cpp b/examples/04-mesh/mesh.cpp index 2895baccb..72a7a3976 100644 --- a/examples/04-mesh/mesh.cpp +++ b/examples/04-mesh/mesh.cpp @@ -66,11 +66,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // Load vertex shader. mem = loadShader(_vsName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -79,8 +79,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/05-instancing/instancing.cpp b/examples/05-instancing/instancing.cpp index 1dec44921..52de86386 100644 --- a/examples/05-instancing/instancing.cpp +++ b/examples/05-instancing/instancing.cpp @@ -157,11 +157,11 @@ int _main_(int /*_argc*/, char** /*_argv*/) // Load vertex shader. mem = loadShader("vs_instancing"); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader("fs_instancing"); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -170,8 +170,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); int64_t timeOffset = bx::getHPCounter(); diff --git a/examples/06-bump/bump.cpp b/examples/06-bump/bump.cpp index 04b017644..41bec3314 100644 --- a/examples/06-bump/bump.cpp +++ b/examples/06-bump/bump.cpp @@ -326,11 +326,11 @@ int _main_(int /*_argc*/, char** /*_argv*/) // Load vertex shader. mem = loadShader(instancingSupported ? "vs_bump_instanced" : "vs_bump"); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader("fs_bump"); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -339,8 +339,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); // Load diffuse texture. mem = loadTexture("fieldstone-rgba.dds"); diff --git a/examples/07-callback/callback.cpp b/examples/07-callback/callback.cpp index 46dbd9968..4d20cb3e5 100644 --- a/examples/07-callback/callback.cpp +++ b/examples/07-callback/callback.cpp @@ -437,11 +437,11 @@ int _main_(int /*_argc*/, char** /*_argv*/) // Load vertex shader. mem = loadShader("vs_callback"); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader("fs_callback"); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -450,8 +450,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); float time = 0.0f; diff --git a/examples/08-update/update.cpp b/examples/08-update/update.cpp index 7917f5cda..587078db5 100644 --- a/examples/08-update/update.cpp +++ b/examples/08-update/update.cpp @@ -128,10 +128,10 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam const bgfx::Memory* mem; mem = loadShader(_vshName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); mem = loadShader(_fshName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -140,8 +140,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/09-hdr/hdr.cpp b/examples/09-hdr/hdr.cpp index 5f779112f..7b98d7f8d 100644 --- a/examples/09-hdr/hdr.cpp +++ b/examples/09-hdr/hdr.cpp @@ -63,12 +63,12 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam const bgfx::Memory* mem; mem = loadShader(_vshName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); mem = loadShader(_fshName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/12-lod/lod.cpp b/examples/12-lod/lod.cpp index 73f28f72b..9903b6db9 100644 --- a/examples/12-lod/lod.cpp +++ b/examples/12-lod/lod.cpp @@ -88,11 +88,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // Load vertex shader. mem = loadShader(_vsName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -101,8 +101,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/13-stencil/stencil.cpp b/examples/13-stencil/stencil.cpp index 6e240325a..228daed25 100644 --- a/examples/13-stencil/stencil.cpp +++ b/examples/13-stencil/stencil.cpp @@ -196,11 +196,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // Load vertex shader. mem = loadShader(_vsName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -209,8 +209,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/14-shadowvolumes/shadowvolumes.cpp b/examples/14-shadowvolumes/shadowvolumes.cpp index e938d35b9..2e594ab64 100644 --- a/examples/14-shadowvolumes/shadowvolumes.cpp +++ b/examples/14-shadowvolumes/shadowvolumes.cpp @@ -166,11 +166,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // Load vertex shader. mem = loadShader(_vsName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -179,8 +179,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/15-shadowmaps-simple/shadowmaps_simple.cpp b/examples/15-shadowmaps-simple/shadowmaps_simple.cpp index 24f25e76b..d03c3f0dd 100644 --- a/examples/15-shadowmaps-simple/shadowmaps_simple.cpp +++ b/examples/15-shadowmaps-simple/shadowmaps_simple.cpp @@ -123,11 +123,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // Load vertex shader. mem = loadShader(_vsName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -136,8 +136,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/16-shadowmaps/shadowmaps.cpp b/examples/16-shadowmaps/shadowmaps.cpp index 71253d2e4..b6aa2bf05 100644 --- a/examples/16-shadowmaps/shadowmaps.cpp +++ b/examples/16-shadowmaps/shadowmaps.cpp @@ -313,11 +313,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // Load vertex shader. mem = loadShader(_vsName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); // Load fragment shader. mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); // Create program from shaders. bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh); @@ -326,8 +326,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); return program; } diff --git a/examples/17-drawstress/drawstress.cpp b/examples/17-drawstress/drawstress.cpp index 047f63b06..5c74a6bd2 100644 --- a/examples/17-drawstress/drawstress.cpp +++ b/examples/17-drawstress/drawstress.cpp @@ -290,8 +290,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) break; } - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(vs_drawstress); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(fs_drawstress); + bgfx::ShaderHandle vsh = bgfx::createShader(vs_drawstress); + bgfx::ShaderHandle fsh = bgfx::createShader(fs_drawstress); // Create program from shaders. program = bgfx::createProgram(vsh, fsh); @@ -310,8 +310,8 @@ int _main_(int /*_argc*/, char** /*_argv*/) // their reference is kept inside bgfx after calling createProgram. // Vertex and fragment shader will be destroyed once program is // destroyed. - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); imguiCreate(s_droidSansTtf, sizeof(s_droidSansTtf) ); diff --git a/examples/18-ibl/ibl.cpp b/examples/18-ibl/ibl.cpp index 0075adc26..ddc059469 100644 --- a/examples/18-ibl/ibl.cpp +++ b/examples/18-ibl/ibl.cpp @@ -67,12 +67,12 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName) const bgfx::Memory* mem; mem = loadShader(_vsName); - bgfx::VertexShaderHandle vs = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vs = bgfx::createShader(mem); mem = loadShader(_fsName); - bgfx::FragmentShaderHandle fs = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fs = bgfx::createShader(mem); bgfx::ProgramHandle program = bgfx::createProgram(vs, fs); - bgfx::destroyVertexShader(vs); - bgfx::destroyFragmentShader(fs); + bgfx::destroyShader(vs); + bgfx::destroyShader(fs); return program; } diff --git a/examples/19-oit/oit.cpp b/examples/19-oit/oit.cpp index 922e3bd48..4be297fac 100644 --- a/examples/19-oit/oit.cpp +++ b/examples/19-oit/oit.cpp @@ -131,10 +131,10 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam const bgfx::Memory* mem; mem = loadShader(_vshName); - bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem); + bgfx::ShaderHandle vsh = bgfx::createShader(mem); mem = loadShader(_fshName); - bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem); + bgfx::ShaderHandle fsh = bgfx::createShader(mem); return bgfx::createProgram(vsh, fsh, true); } diff --git a/examples/common/font/text_buffer_manager.cpp b/examples/common/font/text_buffer_manager.cpp index 7367b4772..81fac5981 100644 --- a/examples/common/font/text_buffer_manager.cpp +++ b/examples/common/font/text_buffer_manager.cpp @@ -587,26 +587,26 @@ TextBufferManager::TextBufferManager(FontManager* _fontManager) break; } - bgfx::VertexShaderHandle vsh; - bgfx::FragmentShaderHandle fsh; + bgfx::ShaderHandle vsh; + bgfx::ShaderHandle fsh; - vsh = bgfx::createVertexShader(vs_font_basic); - fsh = bgfx::createFragmentShader(fs_font_basic); + vsh = bgfx::createShader(vs_font_basic); + fsh = bgfx::createShader(fs_font_basic); m_basicProgram = bgfx::createProgram(vsh, fsh); - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); - vsh = bgfx::createVertexShader(vs_font_distance_field); - fsh = bgfx::createFragmentShader(fs_font_distance_field); + vsh = bgfx::createShader(vs_font_distance_field); + fsh = bgfx::createShader(fs_font_distance_field); m_distanceProgram = bgfx::createProgram(vsh, fsh); - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); - vsh = bgfx::createVertexShader(vs_font_distance_field_subpixel); - fsh = bgfx::createFragmentShader(fs_font_distance_field_subpixel); + vsh = bgfx::createShader(vs_font_distance_field_subpixel); + fsh = bgfx::createShader(fs_font_distance_field_subpixel); m_distanceSubpixelProgram = bgfx::createProgram(vsh, fsh); - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); m_vertexDecl.begin(); m_vertexDecl.add(bgfx::Attrib::Position, 2, bgfx::AttribType::Float); diff --git a/examples/common/imgui/imgui.cpp b/examples/common/imgui/imgui.cpp index 491d06195..2120c5b87 100644 --- a/examples/common/imgui/imgui.cpp +++ b/examples/common/imgui/imgui.cpp @@ -204,20 +204,20 @@ struct Imgui break; } - bgfx::VertexShaderHandle vsh; - bgfx::FragmentShaderHandle fsh; + bgfx::ShaderHandle vsh; + bgfx::ShaderHandle fsh; - vsh = bgfx::createVertexShader(vs_imgui_color); - fsh = bgfx::createFragmentShader(fs_imgui_color); + vsh = bgfx::createShader(vs_imgui_color); + fsh = bgfx::createShader(fs_imgui_color); m_colorProgram = bgfx::createProgram(vsh, fsh); - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); - vsh = bgfx::createVertexShader(vs_imgui_texture); - fsh = bgfx::createFragmentShader(fs_imgui_texture); + vsh = bgfx::createShader(vs_imgui_texture); + fsh = bgfx::createShader(fs_imgui_texture); m_textureProgram = bgfx::createProgram(vsh, fsh); - bgfx::destroyVertexShader(vsh); - bgfx::destroyFragmentShader(fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); const bgfx::Memory* mem = bgfx::alloc(m_textureWidth * m_textureHeight); stbtt_BakeFontBitmap( (uint8_t*)_data, 0, 15.0f, mem->data, m_textureWidth, m_textureHeight, 32, 96, m_cdata); diff --git a/include/bgfx.h b/include/bgfx.h index 5d5c4eea3..ea7545b40 100644 --- a/include/bgfx.h +++ b/include/bgfx.h @@ -448,15 +448,14 @@ namespace bgfx BGFX_HANDLE(DynamicIndexBufferHandle); BGFX_HANDLE(DynamicVertexBufferHandle); - BGFX_HANDLE(FragmentShaderHandle); + BGFX_HANDLE(FrameBufferHandle); BGFX_HANDLE(IndexBufferHandle); BGFX_HANDLE(ProgramHandle); - BGFX_HANDLE(FrameBufferHandle); + BGFX_HANDLE(ShaderHandle); BGFX_HANDLE(TextureHandle); BGFX_HANDLE(UniformHandle); BGFX_HANDLE(VertexBufferHandle); BGFX_HANDLE(VertexDeclHandle); - BGFX_HANDLE(VertexShaderHandle); /// Callback interface to implement application specific behavior. /// Cached items are currently used only for OpenGL binary shaders. @@ -861,19 +860,12 @@ namespace bgfx /// const InstanceDataBuffer* allocInstanceDataBuffer(uint32_t _num, uint16_t _stride); - /// Create vertex shader from memory buffer. - VertexShaderHandle createVertexShader(const Memory* _mem); + /// Create shader from memory buffer. + ShaderHandle createShader(const Memory* _mem); - /// Destroy vertex shader. Once program is created with vertex shader - /// it is safe to destroy vertex shader. - void destroyVertexShader(VertexShaderHandle _handle); - - /// Create fragment shader from memory buffer. - FragmentShaderHandle createFragmentShader(const Memory* _mem); - - /// Destroy fragment shader. Once program is created with fragment shader - /// it is safe to destroy fragment shader. - void destroyFragmentShader(FragmentShaderHandle _handle); + /// Destroy shader. Once program is created with shader it is safe to + /// destroy shader. + void destroyShader(ShaderHandle _handle); /// Create program with vertex and fragment shaders. /// @@ -884,7 +876,7 @@ namespace bgfx /// @returns Program handle if vertex shader output and fragment shader /// input are matching, otherwise returns invalid program handle. /// - ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh, bool _destroyShaders = false); + ProgramHandle createProgram(ShaderHandle _vsh, ShaderHandle _fsh, bool _destroyShaders = false); /// Destroy program. void destroyProgram(ProgramHandle _handle); diff --git a/src/bgfx.cpp b/src/bgfx.cpp index 499064a37..d7fa7dd58 100644 --- a/src/bgfx.cpp +++ b/src/bgfx.cpp @@ -323,7 +323,7 @@ namespace bgfx #else mem = makeRef(vs_debugfont_glsl, sizeof(vs_debugfont_glsl) ); #endif // BGFX_CONFIG_RENDERER_ - VertexShaderHandle vsh = createVertexShader(mem); + ShaderHandle vsh = createShader(mem); #if BGFX_CONFIG_RENDERER_DIRECT3D9 mem = makeRef(fs_debugfont_dx9, sizeof(fs_debugfont_dx9) ); @@ -332,11 +332,9 @@ namespace bgfx #else mem = makeRef(fs_debugfont_glsl, sizeof(fs_debugfont_glsl) ); #endif // BGFX_CONFIG_RENDERER_ - FragmentShaderHandle fsh = createFragmentShader(mem); + ShaderHandle fsh = createShader(mem); - m_program = createProgram(vsh, fsh); - destroyVertexShader(vsh); - destroyFragmentShader(fsh); + m_program = createProgram(vsh, fsh, true); m_vb = s_ctx->createTransientVertexBuffer(numBatchVertices*m_decl.m_stride, &m_decl); m_ib = s_ctx->createTransientIndexBuffer(numBatchIndices*2); @@ -472,7 +470,7 @@ namespace bgfx m_decl.add(Attrib::Color0, 4, AttribType::Uint8, true); m_decl.end(); - VertexShaderHandle vsh = createVertexShader( + ShaderHandle vsh = createShader( # if BGFX_CONFIG_RENDERER_DIRECT3D11 makeRef(vs_clear_dx11, sizeof(vs_clear_dx11) ) # elif BGFX_CONFIG_RENDERER_OPENGL @@ -495,12 +493,12 @@ namespace bgfx for (uint32_t ii = 0; ii < BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS; ++ii) { - FragmentShaderHandle fsh = createFragmentShader(fragMem[ii]); + ShaderHandle fsh = createShader(fragMem[ii]); m_program[ii] = createProgram(vsh, fsh); - destroyFragmentShader(fsh); + destroyShader(fsh); } - destroyVertexShader(vsh); + destroyShader(vsh); m_vb = s_ctx->createTransientVertexBuffer(4*m_decl.m_stride, &m_decl); @@ -1008,8 +1006,7 @@ namespace bgfx CHECK_HANDLE_LEAK(m_indexBufferHandle); CHECK_HANDLE_LEAK(m_vertexDeclHandle); CHECK_HANDLE_LEAK(m_vertexBufferHandle); - CHECK_HANDLE_LEAK(m_vertexShaderHandle); - CHECK_HANDLE_LEAK(m_fragmentShaderHandle); + CHECK_HANDLE_LEAK(m_shaderHandle); CHECK_HANDLE_LEAK(m_programHandle); CHECK_HANDLE_LEAK(m_textureHandle); CHECK_HANDLE_LEAK(m_frameBufferHandle); @@ -1051,14 +1048,9 @@ namespace bgfx destroyVertexBufferInternal(_frame->m_freeVertexBufferHandle[ii]); } - for (uint16_t ii = 0, num = _frame->m_numFreeVertexShaderHandles; ii < num; ++ii) + for (uint16_t ii = 0, num = _frame->m_numFreeShaderHandles; ii < num; ++ii) { - m_vertexShaderHandle.free(_frame->m_freeVertexShaderHandle[ii].idx); - } - - for (uint16_t ii = 0, num = _frame->m_numFreeFragmentShaderHandles; ii < num; ++ii) - { - m_fragmentShaderHandle.free(_frame->m_freeFragmentShaderHandle[ii].idx); + m_shaderHandle.free(_frame->m_freeShaderHandle[ii].idx); } for (uint16_t ii = 0, num = _frame->m_numFreeProgramHandles; ii < num; ++ii) @@ -1433,49 +1425,26 @@ namespace bgfx } break; - case CommandBuffer::CreateVertexShader: + case CommandBuffer::CreateShader: { - VertexShaderHandle handle; + ShaderHandle handle; _cmdbuf.read(handle); Memory* mem; _cmdbuf.read(mem); - rendererCreateVertexShader(handle, mem); + rendererCreateShader(handle, mem); release(mem); } break; - case CommandBuffer::DestroyVertexShader: + case CommandBuffer::DestroyShader: { - VertexShaderHandle handle; + ShaderHandle handle; _cmdbuf.read(handle); - rendererDestroyVertexShader(handle); - } - break; - - case CommandBuffer::CreateFragmentShader: - { - FragmentShaderHandle handle; - _cmdbuf.read(handle); - - Memory* mem; - _cmdbuf.read(mem); - - rendererCreateFragmentShader(handle, mem); - - release(mem); - } - break; - - case CommandBuffer::DestroyFragmentShader: - { - FragmentShaderHandle handle; - _cmdbuf.read(handle); - - rendererDestroyFragmentShader(handle); + rendererDestroyShader(handle); } break; @@ -1484,10 +1453,10 @@ namespace bgfx ProgramHandle handle; _cmdbuf.read(handle); - VertexShaderHandle vsh; + ShaderHandle vsh; _cmdbuf.read(vsh); - FragmentShaderHandle fsh; + ShaderHandle fsh; _cmdbuf.read(fsh); rendererCreateProgram(handle, vsh, fsh); @@ -1853,41 +1822,28 @@ namespace bgfx return s_ctx->allocInstanceDataBuffer(_num, _stride); } - VertexShaderHandle createVertexShader(const Memory* _mem) + ShaderHandle createShader(const Memory* _mem) { BGFX_CHECK_MAIN_THREAD(); BX_CHECK(NULL != _mem, "_mem can't be NULL"); - return s_ctx->createVertexShader(_mem); + return s_ctx->createShader(_mem); } - void destroyVertexShader(VertexShaderHandle _handle) + void destroyShader(ShaderHandle _handle) { BGFX_CHECK_MAIN_THREAD(); - s_ctx->destroyVertexShader(_handle); + s_ctx->destroyShader(_handle); } - FragmentShaderHandle createFragmentShader(const Memory* _mem) - { - BGFX_CHECK_MAIN_THREAD(); - BX_CHECK(NULL != _mem, "_mem can't be NULL"); - return s_ctx->createFragmentShader(_mem); - } - - void destroyFragmentShader(FragmentShaderHandle _handle) - { - BGFX_CHECK_MAIN_THREAD(); - s_ctx->destroyFragmentShader(_handle); - } - - ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh, bool _destroyShaders) + ProgramHandle createProgram(ShaderHandle _vsh, ShaderHandle _fsh, bool _destroyShaders) { BGFX_CHECK_MAIN_THREAD(); ProgramHandle handle = s_ctx->createProgram(_vsh, _fsh); if (_destroyShaders) { - destroyVertexShader(_vsh); - destroyFragmentShader(_fsh); + destroyShader(_vsh); + destroyShader(_fsh); } return handle; diff --git a/src/bgfx_p.h b/src/bgfx_p.h index 6527a446e..115ff034a 100644 --- a/src/bgfx_p.h +++ b/src/bgfx_p.h @@ -505,8 +505,7 @@ namespace bgfx UpdateDynamicIndexBuffer, CreateDynamicVertexBuffer, UpdateDynamicVertexBuffer, - CreateVertexShader, - CreateFragmentShader, + CreateShader, CreateProgram, CreateTexture, UpdateTexture, @@ -520,8 +519,7 @@ namespace bgfx DestroyVertexBuffer, DestroyDynamicIndexBuffer, DestroyDynamicVertexBuffer, - DestroyVertexShader, - DestroyFragmentShader, + DestroyShader, DestroyProgram, DestroyTexture, DestroyFrameBuffer, @@ -1257,16 +1255,10 @@ namespace bgfx ++m_numFreeVertexBufferHandles; } - void free(VertexShaderHandle _handle) + void free(ShaderHandle _handle) { - m_freeVertexShaderHandle[m_numFreeVertexShaderHandles] = _handle; - ++m_numFreeVertexShaderHandles; - } - - void free(FragmentShaderHandle _handle) - { - m_freeFragmentShaderHandle[m_numFreeFragmentShaderHandles] = _handle; - ++m_numFreeFragmentShaderHandles; + m_freeShaderHandle[m_numFreeShaderHandles] = _handle; + ++m_numFreeShaderHandles; } void free(ProgramHandle _handle) @@ -1299,8 +1291,7 @@ namespace bgfx m_numFreeVertexDeclHandles = 0; m_numFreeVertexBufferHandles = 0; m_numFreeVertexShaderHandles = 0; - m_numFreeFragmentShaderHandles = 0; - m_numFreeFragmentShaderHandles = 0; + m_numFreeShaderHandles = 0; m_numFreeProgramHandles = 0; m_numFreeTextureHandles = 0; m_numFreeFrameBufferHandles = 0; @@ -1347,7 +1338,7 @@ namespace bgfx uint16_t m_numFreeVertexDeclHandles; uint16_t m_numFreeVertexBufferHandles; uint16_t m_numFreeVertexShaderHandles; - uint16_t m_numFreeFragmentShaderHandles; + uint16_t m_numFreeShaderHandles; uint16_t m_numFreeProgramHandles; uint16_t m_numFreeTextureHandles; uint16_t m_numFreeFrameBufferHandles; @@ -1356,8 +1347,7 @@ namespace bgfx IndexBufferHandle m_freeIndexBufferHandle[BGFX_CONFIG_MAX_INDEX_BUFFERS]; VertexDeclHandle m_freeVertexDeclHandle[BGFX_CONFIG_MAX_VERTEX_DECLS]; VertexBufferHandle m_freeVertexBufferHandle[BGFX_CONFIG_MAX_VERTEX_BUFFERS]; - VertexShaderHandle m_freeVertexShaderHandle[BGFX_CONFIG_MAX_VERTEX_SHADERS]; - FragmentShaderHandle m_freeFragmentShaderHandle[BGFX_CONFIG_MAX_FRAGMENT_SHADERS]; + ShaderHandle m_freeShaderHandle[BGFX_CONFIG_MAX_SHADERS]; ProgramHandle m_freeProgramHandle[BGFX_CONFIG_MAX_PROGRAMS]; TextureHandle m_freeTextureHandle[BGFX_CONFIG_MAX_TEXTURES]; FrameBufferHandle m_freeFrameBufferHandle[BGFX_CONFIG_MAX_FRAME_BUFFERS]; @@ -1979,90 +1969,31 @@ namespace bgfx return idb; } - BGFX_API_FUNC(VertexShaderHandle createVertexShader(const Memory* _mem) ) + BGFX_API_FUNC(ShaderHandle createShader(const Memory* _mem) ) { bx::MemoryReader reader(_mem->data, _mem->size); uint32_t magic; bx::read(&reader, magic); - if (BGFX_CHUNK_MAGIC_VSH != magic) + if (BGFX_CHUNK_MAGIC_VSH != magic + && BGFX_CHUNK_MAGIC_FSH != magic) { - BX_WARN(false, "Invalid vertex shader signature! 0x%08x", magic); - VertexShaderHandle invalid = BGFX_INVALID_HANDLE; + BX_WARN(false, "Invalid shader signature! 0x%08x", magic); + ShaderHandle invalid = BGFX_INVALID_HANDLE; return invalid; } - VertexShaderHandle handle = { m_vertexShaderHandle.alloc() }; + ShaderHandle handle = { m_shaderHandle.alloc() }; - BX_WARN(isValid(handle), "Failed to allocate vertex shader handle."); + BX_WARN(isValid(handle), "Failed to allocate shader handle."); if (isValid(handle) ) { - VertexShaderRef& vsr = m_vertexShaderRef[handle.idx]; - vsr.m_refCount = 1; - bx::read(&reader, vsr.m_outputHash); - - CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateVertexShader); - cmdbuf.write(handle); - cmdbuf.write(_mem); - } - - return handle; - } - - BGFX_API_FUNC(void destroyVertexShader(VertexShaderHandle _handle) ) - { - if (!isValid(_handle) ) - { - BX_WARN(false, "Passing invalid vertex shader handle to bgfx::destroyVertexShader"); - return; - } - - vertexShaderDecRef(_handle); - } - - void vertexShaderIncRef(VertexShaderHandle _handle) - { - VertexShaderRef& vsr = m_vertexShaderRef[_handle.idx]; - ++vsr.m_refCount; - } - - void vertexShaderDecRef(VertexShaderHandle _handle) - { - VertexShaderRef& vsr = m_vertexShaderRef[_handle.idx]; - int32_t refs = --vsr.m_refCount; - if (0 == refs) - { - CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::DestroyVertexShader); - cmdbuf.write(_handle); - m_submit->free(_handle); - } - } - - BGFX_API_FUNC(FragmentShaderHandle createFragmentShader(const Memory* _mem) ) - { - bx::MemoryReader reader(_mem->data, _mem->size); - - uint32_t magic; - bx::read(&reader, magic); - - if (BGFX_CHUNK_MAGIC_FSH != magic) - { - BX_WARN(false, "Invalid fragment shader signature! 0x%08x", magic); - FragmentShaderHandle invalid = BGFX_INVALID_HANDLE; - return invalid; - } - - FragmentShaderHandle handle = { m_fragmentShaderHandle.alloc() }; - - BX_WARN(isValid(handle), "Failed to allocate fragment shader handle."); - if (isValid(handle) ) - { - FragmentShaderRef& fsr = m_fragmentShaderRef[handle.idx]; + ShaderRef& fsr = m_shaderRef[handle.idx]; fsr.m_refCount = 1; - bx::read(&reader, fsr.m_inputHash); + bx::read(&reader, fsr.m_hash); - CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateFragmentShader); + CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateShader); cmdbuf.write(handle); cmdbuf.write(_mem); } @@ -2070,36 +2001,36 @@ namespace bgfx return handle; } - BGFX_API_FUNC(void destroyFragmentShader(FragmentShaderHandle _handle) ) + BGFX_API_FUNC(void destroyShader(ShaderHandle _handle) ) { if (!isValid(_handle) ) { - BX_WARN(false, "Passing invalid fragment shader handle to bgfx::destroyFragmentShader"); + BX_WARN(false, "Passing invalid shader handle to bgfx::destroyShader"); return; } - fragmentShaderDecRef(_handle); + shaderDecRef(_handle); } - void fragmentShaderIncRef(FragmentShaderHandle _handle) + void shaderIncRef(ShaderHandle _handle) { - FragmentShaderRef& fsr = m_fragmentShaderRef[_handle.idx]; - ++fsr.m_refCount; + ShaderRef& sr = m_shaderRef[_handle.idx]; + ++sr.m_refCount; } - void fragmentShaderDecRef(FragmentShaderHandle _handle) + void shaderDecRef(ShaderHandle _handle) { - FragmentShaderRef& fsr = m_fragmentShaderRef[_handle.idx]; - int32_t refs = --fsr.m_refCount; + ShaderRef& sr = m_shaderRef[_handle.idx]; + int32_t refs = --sr.m_refCount; if (0 == refs) { - CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::DestroyFragmentShader); + CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::DestroyShader); cmdbuf.write(_handle); m_submit->free(_handle); } } - BGFX_API_FUNC(ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh) ) + BGFX_API_FUNC(ProgramHandle createProgram(ShaderHandle _vsh, ShaderHandle _fsh) ) { if (!isValid(_vsh) || !isValid(_fsh) ) @@ -2109,11 +2040,11 @@ namespace bgfx return invalid; } - const VertexShaderRef& vsr = m_vertexShaderRef[_vsh.idx]; - const FragmentShaderRef& fsr = m_fragmentShaderRef[_fsh.idx]; - if (vsr.m_outputHash != fsr.m_inputHash) + const ShaderRef& vsr = m_shaderRef[_vsh.idx]; + const ShaderRef& fsr = m_shaderRef[_fsh.idx]; + if (vsr.m_hash != fsr.m_hash) { - BX_WARN(vsr.m_outputHash == fsr.m_inputHash, "Vertex shader output doesn't match fragment shader input."); + BX_WARN(vsr.m_hash == fsr.m_hash, "Vertex shader output doesn't match fragment shader input."); ProgramHandle invalid = BGFX_INVALID_HANDLE; return invalid; } @@ -2124,8 +2055,8 @@ namespace bgfx BX_WARN(isValid(handle), "Failed to allocate program handle."); if (isValid(handle) ) { - vertexShaderIncRef(_vsh); - fragmentShaderIncRef(_fsh); + shaderIncRef(_vsh); + shaderIncRef(_fsh); m_programRef[handle.idx].m_vsh = _vsh; m_programRef[handle.idx].m_fsh = _fsh; @@ -2144,8 +2075,8 @@ namespace bgfx cmdbuf.write(_handle); m_submit->free(_handle); - vertexShaderDecRef(m_programRef[_handle.idx].m_vsh); - fragmentShaderDecRef(m_programRef[_handle.idx].m_fsh); + shaderDecRef(m_programRef[_handle.idx].m_vsh); + shaderDecRef(m_programRef[_handle.idx].m_fsh); } BGFX_API_FUNC(TextureHandle createTexture(const Memory* _mem, uint32_t _flags, uint8_t _skip, TextureInfo* _info) ) @@ -2632,11 +2563,9 @@ namespace bgfx void rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle); void rendererCreateVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl); void rendererDestroyVertexDecl(VertexDeclHandle _handle); - void rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem); - void rendererDestroyVertexShader(VertexShaderHandle _handle); - void rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem); - void rendererDestroyFragmentShader(FragmentShaderHandle _handle); - void rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh); + void rendererCreateShader(ShaderHandle _handle, Memory* _mem); + void rendererDestroyShader(ShaderHandle _handle); + void rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh); void rendererDestroyProgram(ProgramHandle _handle); void rendererCreateTexture(TextureHandle _handle, Memory* _mem, uint32_t _flags, uint8_t _skip); void rendererUpdateTextureBegin(TextureHandle _handle, uint8_t _side, uint8_t _mip); @@ -2728,29 +2657,22 @@ namespace bgfx bx::HandleAllocT m_vertexDeclHandle; bx::HandleAllocT m_vertexBufferHandle; - bx::HandleAllocT m_vertexShaderHandle; - bx::HandleAllocT m_fragmentShaderHandle; + bx::HandleAllocT m_shaderHandle; bx::HandleAllocT m_programHandle; bx::HandleAllocT m_textureHandle; bx::HandleAllocT m_frameBufferHandle; bx::HandleAllocT m_uniformHandle; - struct FragmentShaderRef + struct ShaderRef { - uint32_t m_inputHash; + uint32_t m_hash; int16_t m_refCount; }; - struct VertexShaderRef - { - uint32_t m_outputHash; - int16_t m_refCount; - }; - struct ProgramRef { - VertexShaderHandle m_vsh; - FragmentShaderHandle m_fsh; + ShaderHandle m_vsh; + ShaderHandle m_fsh; }; struct UniformRef @@ -2773,8 +2695,7 @@ namespace bgfx typedef stl::unordered_map UniformHashMap; UniformHashMap m_uniformHashMap; UniformRef m_uniformRef[BGFX_CONFIG_MAX_UNIFORMS]; - VertexShaderRef m_vertexShaderRef[BGFX_CONFIG_MAX_VERTEX_SHADERS]; - FragmentShaderRef m_fragmentShaderRef[BGFX_CONFIG_MAX_FRAGMENT_SHADERS]; + ShaderRef m_shaderRef[BGFX_CONFIG_MAX_SHADERS]; ProgramRef m_programRef[BGFX_CONFIG_MAX_PROGRAMS]; TextureRef m_textureRef[BGFX_CONFIG_MAX_TEXTURES]; FrameBufferRef m_frameBufferRef[BGFX_CONFIG_MAX_FRAME_BUFFERS]; diff --git a/src/config.h b/src/config.h index 39cead567..a0166568a 100644 --- a/src/config.h +++ b/src/config.h @@ -167,12 +167,8 @@ # define BGFX_CONFIG_DYNAMIC_VERTEX_BUFFER_SIZE (3<<20) #endif // BGFX_CONFIG_DYNAMIC_VERTEX_BUFFER_SIZE -#ifndef BGFX_CONFIG_MAX_VERTEX_SHADERS -# define BGFX_CONFIG_MAX_VERTEX_SHADERS 256 -#endif // BGFX_CONFIG_MAX_VERTEX_SHADERS - -#ifndef BGFX_CONFIG_MAX_FRAGMENT_SHADERS -# define BGFX_CONFIG_MAX_FRAGMENT_SHADERS 256 +#ifndef BGFX_CONFIG_MAX_SHADERS +# define BGFX_CONFIG_MAX_SHADERS 512 #endif // BGFX_CONFIG_MAX_FRAGMENT_SHADERS #ifndef BGFX_CONFIG_MAX_PROGRAMS diff --git a/src/renderer_d3d11.cpp b/src/renderer_d3d11.cpp index b6e65ccc9..cb89a94b9 100644 --- a/src/renderer_d3d11.cpp +++ b/src/renderer_d3d11.cpp @@ -541,14 +541,9 @@ namespace bgfx m_vertexBuffers[ii].destroy(); } - for (uint32_t ii = 0; ii < BX_COUNTOF(m_vertexShaders); ++ii) + for (uint32_t ii = 0; ii < BX_COUNTOF(m_shaders); ++ii) { - m_vertexShaders[ii].destroy(); - } - - for (uint32_t ii = 0; ii < BX_COUNTOF(m_fragmentShaders); ++ii) - { - m_fragmentShaders[ii].destroy(); + m_shaders[ii].destroy(); } for (uint32_t ii = 0; ii < BX_COUNTOF(m_textures); ++ii) @@ -1275,8 +1270,7 @@ namespace bgfx IndexBuffer m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS]; VertexBuffer m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS]; - Shader m_vertexShaders[BGFX_CONFIG_MAX_VERTEX_SHADERS]; - Shader m_fragmentShaders[BGFX_CONFIG_MAX_FRAGMENT_SHADERS]; + Shader m_shaders[BGFX_CONFIG_MAX_SHADERS]; Program m_program[BGFX_CONFIG_MAX_PROGRAMS]; Texture m_textures[BGFX_CONFIG_MAX_TEXTURES]; VertexDecl m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS]; @@ -1653,13 +1647,26 @@ namespace bgfx } } - void Shader::create(bool _fragment, const Memory* _mem) + void Shader::create(const Memory* _mem) { bx::MemoryReader reader(_mem->data, _mem->size); uint32_t magic; bx::read(&reader, magic); + switch (magic) + { + case BGFX_CHUNK_MAGIC_FSH: + case BGFX_CHUNK_MAGIC_VSH: + break; + + default: + BGFX_FATAL(false, Fatal::InvalidShader, "Unknown shader format %x.", magic); + break; + } + + bool fragment = BGFX_CHUNK_MAGIC_FSH == magic; + uint32_t iohash; bx::read(&reader, iohash); @@ -1688,7 +1695,7 @@ namespace bgfx BX_TRACE("Shader consts %d", count); - uint8_t fragmentBit = _fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0; + uint8_t fragmentBit = fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0; if (0 < count) { @@ -1759,7 +1766,7 @@ namespace bgfx const DWORD* code = (const DWORD*)reader.getDataPtr(); bx::skip(&reader, shaderSize); - if (_fragment) + if (fragment) { DX_CHECK(s_renderCtx->m_device->CreatePixelShader(code, shaderSize, NULL, (ID3D11PixelShader**)&m_ptr) ); BGFX_FATAL(NULL != m_ptr, bgfx::Fatal::InvalidShader, "Failed to create fragment shader."); @@ -2223,29 +2230,19 @@ namespace bgfx s_renderCtx->m_vertexBuffers[_handle.idx].destroy(); } - void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem) + void Context::rendererCreateShader(ShaderHandle _handle, Memory* _mem) { - s_renderCtx->m_vertexShaders[_handle.idx].create(false, _mem); + s_renderCtx->m_shaders[_handle.idx].create(_mem); } - void Context::rendererDestroyVertexShader(VertexShaderHandle _handle) + void Context::rendererDestroyShader(ShaderHandle _handle) { - s_renderCtx->m_vertexShaders[_handle.idx].destroy(); + s_renderCtx->m_shaders[_handle.idx].destroy(); } - void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem) + void Context::rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh) { - s_renderCtx->m_fragmentShaders[_handle.idx].create(true, _mem); - } - - void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle) - { - s_renderCtx->m_fragmentShaders[_handle.idx].destroy(); - } - - void Context::rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh) - { - s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_vertexShaders[_vsh.idx], s_renderCtx->m_fragmentShaders[_fsh.idx]); + s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_shaders[_vsh.idx], s_renderCtx->m_shaders[_fsh.idx]); } void Context::rendererDestroyProgram(ProgramHandle _handle) diff --git a/src/renderer_d3d11.h b/src/renderer_d3d11.h index 77ce8349f..7f23f9dc4 100644 --- a/src/renderer_d3d11.h +++ b/src/renderer_d3d11.h @@ -149,7 +149,7 @@ namespace bgfx { } - void create(bool _fragment, const Memory* _mem); + void create(const Memory* _mem); DWORD* getShaderCode(uint8_t _fragmentBit, const Memory* _mem); void destroy() diff --git a/src/renderer_d3d9.cpp b/src/renderer_d3d9.cpp index 99ad4dc2e..38d164073 100644 --- a/src/renderer_d3d9.cpp +++ b/src/renderer_d3d9.cpp @@ -523,14 +523,9 @@ namespace bgfx m_vertexBuffers[ii].destroy(); } - for (uint32_t ii = 0; ii < BX_COUNTOF(m_vertexShaders); ++ii) + for (uint32_t ii = 0; ii < BX_COUNTOF(m_shaders); ++ii) { - m_vertexShaders[ii].destroy(); - } - - for (uint32_t ii = 0; ii < BX_COUNTOF(m_fragmentShaders); ++ii) - { - m_fragmentShaders[ii].destroy(); + m_shaders[ii].destroy(); } for (uint32_t ii = 0; ii < BX_COUNTOF(m_textures); ++ii) @@ -1031,8 +1026,7 @@ namespace bgfx IndexBuffer m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS]; VertexBuffer m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS]; - Shader m_vertexShaders[BGFX_CONFIG_MAX_VERTEX_SHADERS]; - Shader m_fragmentShaders[BGFX_CONFIG_MAX_FRAGMENT_SHADERS]; + Shader m_shaders[BGFX_CONFIG_MAX_SHADERS]; Program m_program[BGFX_CONFIG_MAX_PROGRAMS]; Texture m_textures[BGFX_CONFIG_MAX_TEXTURES]; VertexDeclaration m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS]; @@ -1259,13 +1253,26 @@ namespace bgfx m_ptr = createVertexDecl(_decl, 0); } - void Shader::create(bool _fragment, const Memory* _mem) + void Shader::create(const Memory* _mem) { bx::MemoryReader reader(_mem->data, _mem->size); uint32_t magic; bx::read(&reader, magic); + switch (magic) + { + case BGFX_CHUNK_MAGIC_FSH: + case BGFX_CHUNK_MAGIC_VSH: + break; + + default: + BGFX_FATAL(false, Fatal::InvalidShader, "Unknown shader format %x.", magic); + break; + } + + bool fragment = BGFX_CHUNK_MAGIC_FSH == magic; + uint32_t iohash; bx::read(&reader, iohash); @@ -1276,7 +1283,7 @@ namespace bgfx BX_TRACE("Shader consts %d", count); - uint8_t fragmentBit = _fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0; + uint8_t fragmentBit = fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0; if (0 < count) { @@ -1346,7 +1353,7 @@ namespace bgfx const DWORD* code = (const DWORD*)reader.getDataPtr(); - if (_fragment) + if (fragment) { DX_CHECK(s_renderCtx->m_device->CreatePixelShader(code, (IDirect3DPixelShader9**)&m_ptr) ); BGFX_FATAL(NULL != m_ptr, bgfx::Fatal::InvalidShader, "Failed to create fragment shader."); @@ -2241,29 +2248,19 @@ namespace bgfx s_renderCtx->m_vertexBuffers[_handle.idx].destroy(); } - void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem) + void Context::rendererCreateShader(ShaderHandle _handle, Memory* _mem) { - s_renderCtx->m_vertexShaders[_handle.idx].create(false, _mem); + s_renderCtx->m_shaders[_handle.idx].create(_mem); } - void Context::rendererDestroyVertexShader(VertexShaderHandle _handle) + void Context::rendererDestroyShader(ShaderHandle _handle) { - s_renderCtx->m_vertexShaders[_handle.idx].destroy(); + s_renderCtx->m_shaders[_handle.idx].destroy(); } - void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem) + void Context::rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh) { - s_renderCtx->m_fragmentShaders[_handle.idx].create(true, _mem); - } - - void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle) - { - s_renderCtx->m_fragmentShaders[_handle.idx].destroy(); - } - - void Context::rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh) - { - s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_vertexShaders[_vsh.idx], s_renderCtx->m_fragmentShaders[_fsh.idx]); + s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_shaders[_vsh.idx], s_renderCtx->m_shaders[_fsh.idx]); } void Context::rendererDestroyProgram(ProgramHandle _handle) diff --git a/src/renderer_d3d9.h b/src/renderer_d3d9.h index e25173d49..fa7e89d95 100644 --- a/src/renderer_d3d9.h +++ b/src/renderer_d3d9.h @@ -224,7 +224,7 @@ namespace bgfx { } - void create(bool _fragment, const Memory* _mem); + void create(const Memory* _mem); DWORD* getShaderCode(uint8_t _fragmentBit, const Memory* _mem); void destroy() diff --git a/src/renderer_gl.cpp b/src/renderer_gl.cpp index ac783a330..f80cf4645 100644 --- a/src/renderer_gl.cpp +++ b/src/renderer_gl.cpp @@ -1444,8 +1444,7 @@ namespace bgfx IndexBuffer m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS]; VertexBuffer m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS]; - Shader m_vertexShaders[BGFX_CONFIG_MAX_VERTEX_SHADERS]; - Shader m_fragmentShaders[BGFX_CONFIG_MAX_FRAGMENT_SHADERS]; + Shader m_shaders[BGFX_CONFIG_MAX_SHADERS]; Program m_program[BGFX_CONFIG_MAX_PROGRAMS]; Texture m_textures[BGFX_CONFIG_MAX_TEXTURES]; VertexDecl m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS]; @@ -2427,20 +2426,34 @@ namespace bgfx memcpy(_str, _insert, len); } - void Shader::create(GLenum _type, Memory* _mem) + void Shader::create(Memory* _mem) { - m_id = glCreateShader(_type); - m_type = _type; - bx::MemoryReader reader(_mem->data, _mem->size); m_hash = bx::hashMurmur2A(_mem->data, _mem->size); uint32_t magic; bx::read(&reader, magic); + switch (magic) + { + case BGFX_CHUNK_MAGIC_FSH: + m_type = GL_FRAGMENT_SHADER; + break; + + case BGFX_CHUNK_MAGIC_VSH: + m_type = GL_VERTEX_SHADER; + break; + + default: + BGFX_FATAL(false, Fatal::InvalidShader, "Unknown shader format %x.", magic); + break; + } + uint32_t iohash; bx::read(&reader, iohash); + m_id = glCreateShader(m_type); + const char* code = (const char*)reader.getDataPtr(); if (0 != m_id) @@ -2580,7 +2593,7 @@ namespace bgfx if (usesTextureLod) { writeString(&writer, "#version 120\n"); - if (_type == GL_FRAGMENT_SHADER) + if (m_type == GL_FRAGMENT_SHADER) { writeString(&writer, "#extension GL_ARB_shader_texture_lod : enable\n"); } @@ -2610,7 +2623,7 @@ namespace bgfx writeString(&writer, "#version 140\n"); } - if (_type == GL_FRAGMENT_SHADER) + if (m_type == GL_FRAGMENT_SHADER) { writeString(&writer, "#define varying in\n"); writeString(&writer, "#define texture2D texture\n"); @@ -3208,30 +3221,20 @@ namespace bgfx s_renderCtx->m_vertexBuffers[_handle.idx].destroy(); } - void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem) + void Context::rendererCreateShader(ShaderHandle _handle, Memory* _mem) { - s_renderCtx->m_vertexShaders[_handle.idx].create(GL_VERTEX_SHADER, _mem); + s_renderCtx->m_shaders[_handle.idx].create(_mem); } - void Context::rendererDestroyVertexShader(VertexShaderHandle _handle) + void Context::rendererDestroyShader(ShaderHandle _handle) { - s_renderCtx->m_vertexShaders[_handle.idx].destroy(); + s_renderCtx->m_shaders[_handle.idx].destroy(); } - void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem) - { - s_renderCtx->m_fragmentShaders[_handle.idx].create(GL_FRAGMENT_SHADER, _mem); - } - - void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle) - { - s_renderCtx->m_fragmentShaders[_handle.idx].destroy(); - } - - void Context::rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh) + void Context::rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh) { Shader dummyFragmentShader; - s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_vertexShaders[_vsh.idx], isValid(_fsh) ? s_renderCtx->m_fragmentShaders[_fsh.idx] : dummyFragmentShader); + s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_shaders[_vsh.idx], isValid(_fsh) ? s_renderCtx->m_shaders[_fsh.idx] : dummyFragmentShader); } void Context::rendererDestroyProgram(ProgramHandle _handle) diff --git a/src/renderer_gl.h b/src/renderer_gl.h index 162fc6445..afb50c23d 100644 --- a/src/renderer_gl.h +++ b/src/renderer_gl.h @@ -623,7 +623,7 @@ namespace bgfx { } - void create(GLenum _type, Memory* _mem); + void create(Memory* _mem); void destroy(); GLuint m_id; diff --git a/src/renderer_null.cpp b/src/renderer_null.cpp index d2b65647f..3552b68d6 100644 --- a/src/renderer_null.cpp +++ b/src/renderer_null.cpp @@ -81,23 +81,15 @@ namespace bgfx { } - void Context::rendererCreateVertexShader(VertexShaderHandle /*_handle*/, Memory* /*_mem*/) + void Context::rendererCreateShader(ShaderHandle /*_handle*/, Memory* /*_mem*/) { } - void Context::rendererDestroyVertexShader(VertexShaderHandle /*_handle*/) + void Context::rendererDestroyShader(ShaderHandle /*_handle*/) { } - void Context::rendererCreateFragmentShader(FragmentShaderHandle /*_handle*/, Memory* /*_mem*/) - { - } - - void Context::rendererDestroyFragmentShader(FragmentShaderHandle /*_handle*/) - { - } - - void Context::rendererCreateProgram(ProgramHandle /*_handle*/, VertexShaderHandle /*_vsh*/, FragmentShaderHandle /*_fsh*/) + void Context::rendererCreateProgram(ProgramHandle /*_handle*/, ShaderHandle /*_vsh*/, ShaderHandle /*_fsh*/) { }