scratchfoundation/bgfx
1
0
Fork 0
mirror of https://github.com/scratchfoundation/bgfx.git synced 2025-03-29 08:19:52 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Simplified API, removed difference between vertex and fragment shaders.

Browse source
This commit is contained in:
Branimir Karadžić 2014-03-29 19:42:57 -07:00
parent 2701350b7f
commit f436f79c10
30 changed files with 254 additions and 400 deletions

8
examples/01-cubes/cubes.cpp
View file

@ -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 };

8
examples/02-metaballs/metaballs.cpp
View file

@ -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

8
examples/03-raymarch/raymarch.cpp
View file

@ -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;
}

8
examples/04-mesh/mesh.cpp
View file

@ -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;
}

8
examples/05-instancing/instancing.cpp
View file

@ -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();

8
examples/06-bump/bump.cpp
View file

@ -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");

8
examples/07-callback/callback.cpp
View file

@ -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;

8
examples/08-update/update.cpp
View file

@ -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;
}

8
examples/09-hdr/hdr.cpp
View file

@ -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;
}

8
examples/12-lod/lod.cpp
View file

@ -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;
}

8
examples/13-stencil/stencil.cpp
View file

@ -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;
}

8
examples/14-shadowvolumes/shadowvolumes.cpp
View file

@ -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;
}

8
examples/15-shadowmaps-simple/shadowmaps_simple.cpp
View file

@ -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;
}

8
examples/16-shadowmaps/shadowmaps.cpp
View file

@ -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;
}

8
examples/17-drawstress/drawstress.cpp
View file

@ -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) );

8
examples/18-ibl/ibl.cpp
View file

@ -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;
}

4
examples/19-oit/oit.cpp
View file

@ -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);
}

28
examples/common/font/text_buffer_manager.cpp
View file

@ -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);

20
examples/common/imgui/imgui.cpp
View file

@ -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);

24
include/bgfx.h
View file

@ -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);

94
src/bgfx.cpp
View file

@ -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;

171
src/bgfx_p.h
View file

@ -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<BGFX_CONFIG_MAX_VERTEX_DECLS > m_vertexDeclHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_VERTEX_BUFFERS> m_vertexBufferHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_VERTEX_SHADERS> m_vertexShaderHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_FRAGMENT_SHADERS> m_fragmentShaderHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_SHADERS> m_shaderHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_PROGRAMS> m_programHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_TEXTURES> m_textureHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_FRAME_BUFFERS> m_frameBufferHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_UNIFORMS> 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<stl::string, UniformHandle> 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];

8
src/config.h
View file

@ -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

53
src/renderer_d3d11.cpp
View file

@ -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)

2
src/renderer_d3d11.h
View file

@ -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()

53
src/renderer_d3d9.cpp
View file

@ -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)

2
src/renderer_d3d9.h
View file

@ -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()

51
src/renderer_gl.cpp
View file

@ -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)

2
src/renderer_gl.h
View file

@ -623,7 +623,7 @@ namespace bgfx
{
}
void create(GLenum _type, Memory* _mem);
void create(Memory* _mem);
void destroy();
GLuint m_id;

14
src/renderer_null.cpp
View file

@ -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*/)
{
}