mirrors/bgfx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Standardized way to deal with embedded shaders.

Browse Source
This commit is contained in:
Branimir Karadžić 2016-12-04 19:43:07 -08:00
parent 093688de3c
commit 8068dd7f58
3 changed files with 190 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
examples/common/debugdraw/debugdraw.cpp
View File

@ -4,6 +4,7 @@
*/
#include <bgfx/bgfx.h>
#include <bgfx/embedded_shader.h>
#include "debugdraw.h"
#include <bx/fpumath.h>
@ -277,52 +278,19 @@ void getPoint(float* _result, Axis::Enum _axis, float _x, float _y)
#include "vs_debugdraw_fill_lit.bin.h"
#include "fs_debugdraw_fill_lit.bin.h"
struct EmbeddedShader
static const bgfx::EmbeddedShader s_embeddedShaders[] =
{
bgfx::RendererType::Enum type;
const uint8_t* data;
uint32_t size;
BGFX_EMBEDDED_SHADER(vs_debugdraw_lines),
BGFX_EMBEDDED_SHADER(fs_debugdraw_lines),
BGFX_EMBEDDED_SHADER(vs_debugdraw_lines_stipple),
BGFX_EMBEDDED_SHADER(fs_debugdraw_lines_stipple),
BGFX_EMBEDDED_SHADER(vs_debugdraw_fill),
BGFX_EMBEDDED_SHADER(fs_debugdraw_fill),
BGFX_EMBEDDED_SHADER(vs_debugdraw_fill_lit),
BGFX_EMBEDDED_SHADER(fs_debugdraw_fill_lit),
BGFX_EMBEDDED_SHADER_END()
};
#define BGFX_DECLARE_SHADER_EMBEDDED(_name) \
{ \
{ bgfx::RendererType::Direct3D9, BX_CONCATENATE(_name, _dx9 ), sizeof(BX_CONCATENATE(_name, _dx9 ) ) }, \
{ bgfx::RendererType::Direct3D11, BX_CONCATENATE(_name, _dx11), sizeof(BX_CONCATENATE(_name, _dx11) ) }, \
{ bgfx::RendererType::Direct3D12, BX_CONCATENATE(_name, _dx11), sizeof(BX_CONCATENATE(_name, _dx11) ) }, \
{ bgfx::RendererType::OpenGL, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) }, \
{ bgfx::RendererType::OpenGLES, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) }, \
{ bgfx::RendererType::Vulkan, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) }, \
{ bgfx::RendererType::Metal, BX_CONCATENATE(_name, _mtl ), sizeof(BX_CONCATENATE(_name, _mtl ) ) }, \
{ bgfx::RendererType::Noop, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) }, \
{ bgfx::RendererType::Count, NULL, 0 }, \
}
static const EmbeddedShader s_embeddedShaders[][9] =
{
BGFX_DECLARE_SHADER_EMBEDDED(vs_debugdraw_lines),
BGFX_DECLARE_SHADER_EMBEDDED(fs_debugdraw_lines),
BGFX_DECLARE_SHADER_EMBEDDED(vs_debugdraw_lines_stipple),
BGFX_DECLARE_SHADER_EMBEDDED(fs_debugdraw_lines_stipple),
BGFX_DECLARE_SHADER_EMBEDDED(vs_debugdraw_fill),
BGFX_DECLARE_SHADER_EMBEDDED(fs_debugdraw_fill),
BGFX_DECLARE_SHADER_EMBEDDED(vs_debugdraw_fill_lit),
BGFX_DECLARE_SHADER_EMBEDDED(fs_debugdraw_fill_lit),
};
static bgfx::ShaderHandle createEmbeddedShader(bgfx::RendererType::Enum _type, uint32_t _index)
{
for (const EmbeddedShader* es = s_embeddedShaders[_index]; bgfx::RendererType::Count != es->type; ++es)
{
if (_type == es->type)
{
return bgfx::createShader(bgfx::makeRef(es->data, es->size) );
}
}
bgfx::ShaderHandle handle = BGFX_INVALID_HANDLE;
return handle;
}
struct DebugDraw
{
DebugDraw()
@ -350,28 +318,32 @@ struct DebugDraw
bgfx::RendererType::Enum type = bgfx::getRendererType();
m_program[Program::Lines] =
bgfx::createProgram(createEmbeddedShader(type, 0)
, createEmbeddedShader(type, 1)
, true
);
bgfx::createProgram(
bgfx::createEmbeddedShader(s_embeddedShaders, type, "vs_debugdraw_lines")
, bgfx::createEmbeddedShader(s_embeddedShaders, type, "fs_debugdraw_lines")
, true
);
m_program[Program::LinesStipple] =
bgfx::createProgram(createEmbeddedShader(type, 2)
, createEmbeddedShader(type, 3)
, true
);
bgfx::createProgram(
bgfx::createEmbeddedShader(s_embeddedShaders, type, "vs_debugdraw_lines_stipple")
, bgfx::createEmbeddedShader(s_embeddedShaders, type, "fs_debugdraw_lines_stipple")
, true
);
m_program[Program::Fill] =
bgfx::createProgram(createEmbeddedShader(type, 4)
, createEmbeddedShader(type, 5)
, true
);
bgfx::createProgram(
bgfx::createEmbeddedShader(s_embeddedShaders, type, "vs_debugdraw_fill")
, bgfx::createEmbeddedShader(s_embeddedShaders, type, "fs_debugdraw_fill")
, true
);
m_program[Program::FillLit] =
bgfx::createProgram(createEmbeddedShader(type, 6)
, createEmbeddedShader(type, 7)
, true
);
bgfx::createProgram(
bgfx::createEmbeddedShader(s_embeddedShaders, type, "vs_debugdraw_fill_lit")
, bgfx::createEmbeddedShader(s_embeddedShaders, type, "fs_debugdraw_fill_lit")
, true
);
u_params = bgfx::createUniform("u_params", bgfx::UniformType::Vec4, 4);

138
include/bgfx/embedded_shader.h Normal file
View File

@ -0,0 +1,138 @@
/*
* Copyright 2011-2016 Branimir Karadzic. All rights reserved.
* License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
*/
#ifndef BGFX_EMBEDDED_SHADER_H_HEADER_GUARD
#define BGFX_EMBEDDED_SHADER_H_HEADER_GUARD
#include <bx/platform.h>
#include "bgfx.h"
#define BGFX_EMBEDDED_SHADER_DXBC(...)
#define BGFX_EMBEDDED_SHADER_DX9BC(...)
#define BGFX_EMBEDDED_SHADER_PSSL(...)
#define BGFX_EMBEDDED_SHADER_ESSL(...)
#define BGFX_EMBEDDED_SHADER_GLSL(...)
#define BGFX_EMBEDDED_SHADER_SPIRV(...)
#define BGFX_EMBEDDED_SHADER_METAL(...)
#define BGFX_PLATFORM_SUPPORTS_DX9BC (0 \
|| BX_PLATFORM_WINDOWS \
|| BX_PLATFORM_XBOX360 \
)
#define BGFX_PLATFORM_SUPPORTS_DXBC (0 \
|| BX_PLATFORM_WINDOWS \
|| BX_PLATFORM_WINRT \
|| BX_PLATFORM_XBOXONE \
)
#define BGFX_PLATFORM_SUPPORTS_PSSL (0 \
|| BX_PLATFORM_PS4 \
)
#define BGFX_PLATFORM_SUPPORTS_ESSL (0 \
|| BX_PLATFORM_ANDROID \
|| BX_PLATFORM_EMSCRIPTEN \
|| BX_PLATFORM_IOS \
|| BX_PLATFORM_LINUX \
|| BX_PLATFORM_NACL \
|| BX_PLATFORM_OSX \
|| BX_PLATFORM_QNX \
|| BX_PLATFORM_RPI \
|| BX_PLATFORM_STEAMLINK \
|| BX_PLATFORM_WINDOWS \
)
#define BGFX_PLATFORM_SUPPORTS_GLSL (0 \
|| BX_PLATFORM_BSD \
|| BX_PLATFORM_LINUX \
|| BX_PLATFORM_OSX \
|| BX_PLATFORM_WINDOWS \
)
#define BGFX_PLATFORM_SUPPORTS_METAL (0 \
|| BX_PLATFORM_IOS \
|| BX_PLATFORM_OSX \
)
#define BGFX_PLATFORM_SUPPORTS_SPIRV (0 \
|| BX_PLATFORM_ANDROID \
|| BX_PLATFORM_LINUX \
|| BX_PLATFORM_WINDOWS \
)
#if BGFX_PLATFORM_SUPPORTS_DX9BC
# undef BGFX_EMBEDDED_SHADER_DX9BC
# define BGFX_EMBEDDED_SHADER_DX9BC(_renderer, _name) { _renderer, BX_CONCATENATE(_name, _dx9 ), sizeof(BX_CONCATENATE(_name, _dx9 ) ) },
#endif // BGFX_PLATFORM_SUPPORTS_DX9BC
#if BGFX_PLATFORM_SUPPORTS_DXBC
# undef BGFX_EMBEDDED_SHADER_DXBC
# define BGFX_EMBEDDED_SHADER_DXBC(_renderer, _name) { _renderer, BX_CONCATENATE(_name, _dx11), sizeof(BX_CONCATENATE(_name, _dx11) ) },
#endif // BGFX_PLATFORM_SUPPORTS_DXBC
#if BGFX_PLATFORM_SUPPORTS_PSSL
# undef BGFX_EMBEDDED_SHADER_PSSL
# define BGFX_EMBEDDED_SHADER_PSSL(_renderer, _name) { _renderer, BX_CONCATENATE(_name, _pssl), BX_CONCATENATE(_name, _pssl_size) },
#endif // BGFX_PLATFORM_SUPPORTS_PSSL
#if BGFX_PLATFORM_SUPPORTS_ESSL
# undef BGFX_EMBEDDED_SHADER_ESSL
# define BGFX_EMBEDDED_SHADER_ESSL(_renderer, _name) { _renderer, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) },
#endif // BGFX_PLATFORM_SUPPORTS_PSSL
#if BGFX_PLATFORM_SUPPORTS_GLSL
# undef BGFX_EMBEDDED_SHADER_GLSL
# define BGFX_EMBEDDED_SHADER_GLSL(_renderer, _name) { _renderer, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) },
#endif // BGFX_PLATFORM_SUPPORTS_PSSL
#if 0 // BGFX_PLATFORM_SUPPORTS_SPIRV
# undef BGFX_EMBEDDED_SHADER_SPIRV
# define BGFX_EMBEDDED_SHADER_SPIRV(_renderer, _name) { _renderer, BX_CONCATENATE(_name, _spv), sizeof(BX_CONCATENATE(_name, _spv) ) },
#endif // BGFX_PLATFORM_SUPPORTS_PSSL
#if BGFX_PLATFORM_SUPPORTS_METAL
# undef BGFX_EMBEDDED_SHADER_METAL
# define BGFX_EMBEDDED_SHADER_METAL(_renderer, _name) { _renderer, BX_CONCATENATE(_name, _mtl), sizeof(BX_CONCATENATE(_name, _mtl) ) },
#endif // BGFX_PLATFORM_SUPPORTS_PSSL
#define BGFX_EMBEDDED_SHADER(_name) \
{ \
#_name, \
{ \
BGFX_EMBEDDED_SHADER_DX9BC(bgfx::RendererType::Direct3D9, _name) \
BGFX_EMBEDDED_SHADER_DXBC (bgfx::RendererType::Direct3D11, _name) \
BGFX_EMBEDDED_SHADER_DXBC (bgfx::RendererType::Direct3D12, _name) \
BGFX_EMBEDDED_SHADER_PSSL (bgfx::RendererType::Gnm, _name) \
BGFX_EMBEDDED_SHADER_ESSL (bgfx::RendererType::OpenGL, _name) \
BGFX_EMBEDDED_SHADER_GLSL (bgfx::RendererType::OpenGLES, _name) \
BGFX_EMBEDDED_SHADER_SPIRV(bgfx::RendererType::Vulkan, _name) \
BGFX_EMBEDDED_SHADER_METAL(bgfx::RendererType::Metal, _name) \
{ bgfx::RendererType::Count, NULL, 0 } \
} \
}
#define BGFX_EMBEDDED_SHADER_END() \
{ \
NULL, \
{ \
{ bgfx::RendererType::Count, NULL, 0 } \
} \
}
namespace bgfx
{
struct EmbeddedShader
{
struct Data
{
bgfx::RendererType::Enum type;
const uint8_t* data;
uint32_t size;
};
const char* name;
Data data[RendererType::Count];
};
ShaderHandle createEmbeddedShader(const bgfx::EmbeddedShader* _es, RendererType::Enum _type, const char* _name);
} // namespace bgfx
#endif // BGFX_EMBEDDED_SHADER_H_HEADER_GUARD

72
src/bgfx.cpp
View File

@ -11,6 +11,7 @@
#endif // BX_PLATFORM_WINDOWS
#include "bgfx_p.h"
#include <bgfx/embedded_shader.h>
#if BGFX_CONFIG_PROFILER_REMOTERY_BUILD_LIB
# define RMT_USE_D3D11 BGFX_CONFIG_RENDERER_DIRECT3D11
@ -440,65 +441,34 @@ namespace bgfx
#include "fs_clear6.bin.h"
#include "fs_clear7.bin.h"
struct EmbeddedShader
{
struct Data
{
bgfx::RendererType::Enum type;
const uint8_t* data;
uint32_t size;
};
const char* name;
Data data[RendererType::Count];
};
#define BGFX_DECLARE_SHADER_EMBEDDED(_name) \
{ \
#_name, \
{ \
{ bgfx::RendererType::Direct3D9, BX_CONCATENATE(_name, _dx9 ), sizeof(BX_CONCATENATE(_name, _dx9 ) ) }, \
{ bgfx::RendererType::Direct3D11, BX_CONCATENATE(_name, _dx11), sizeof(BX_CONCATENATE(_name, _dx11) ) }, \
{ bgfx::RendererType::Direct3D12, BX_CONCATENATE(_name, _dx11), sizeof(BX_CONCATENATE(_name, _dx11) ) }, \
{ bgfx::RendererType::Gnm, BX_CONCATENATE(_name, _pssl), BX_CONCATENATE(_name, _pssl_size) }, \
{ bgfx::RendererType::Metal, BX_CONCATENATE(_name, _mtl ), sizeof(BX_CONCATENATE(_name, _mtl ) ) }, \
{ bgfx::RendererType::OpenGL, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) }, \
{ bgfx::RendererType::OpenGLES, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) }, \
{ bgfx::RendererType::Vulkan, BX_CONCATENATE(_name, _glsl), sizeof(BX_CONCATENATE(_name, _glsl) ) }, \
{ bgfx::RendererType::Count, NULL, 0 }, \
} \
}
static const EmbeddedShader s_embeddedShaders[] =
{
BGFX_DECLARE_SHADER_EMBEDDED(vs_debugfont),
BGFX_DECLARE_SHADER_EMBEDDED(fs_debugfont),
BGFX_EMBEDDED_SHADER(vs_debugfont),
BGFX_EMBEDDED_SHADER(fs_debugfont),
BGFX_EMBEDDED_SHADER(vs_clear),
BGFX_EMBEDDED_SHADER(fs_clear0),
BGFX_EMBEDDED_SHADER(fs_clear1),
BGFX_EMBEDDED_SHADER(fs_clear2),
BGFX_EMBEDDED_SHADER(fs_clear3),
BGFX_EMBEDDED_SHADER(fs_clear4),
BGFX_EMBEDDED_SHADER(fs_clear5),
BGFX_EMBEDDED_SHADER(fs_clear6),
BGFX_EMBEDDED_SHADER(fs_clear7),
BGFX_DECLARE_SHADER_EMBEDDED(vs_clear),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear0),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear1),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear2),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear3),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear4),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear5),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear6),
BGFX_DECLARE_SHADER_EMBEDDED(fs_clear7),
{ NULL, { { bgfx::RendererType::Count, NULL, 0 } } }
BGFX_EMBEDDED_SHADER_END()
};
static ShaderHandle createEmbeddedShader(RendererType::Enum _type, const char* _name)
ShaderHandle createEmbeddedShader(const EmbeddedShader* _es, RendererType::Enum _type, const char* _name)
{
for (const EmbeddedShader* es = s_embeddedShaders; NULL != es->name; ++es)
for (const EmbeddedShader* es = _es; NULL != es->name; ++es)
{
if (0 == strcmp(_name, es->name) )
if (0 == strcmp(_name, es->name))
{
for (const EmbeddedShader::Data* esd = es->data; RendererType::Count != esd->type; ++esd)
{
if (_type == esd->type)
{
return createShader(makeRef(esd->data, esd->size) );
return createShader(makeRef(esd->data, esd->size));
}
}
}
@ -634,8 +604,8 @@ namespace bgfx
, mem
);
ShaderHandle vsh = createEmbeddedShader(g_caps.rendererType, "vs_debugfont");
ShaderHandle fsh = createEmbeddedShader(g_caps.rendererType, "fs_debugfont");
ShaderHandle vsh = createEmbeddedShader(s_embeddedShaders, g_caps.rendererType, "vs_debugfont");
ShaderHandle fsh = createEmbeddedShader(s_embeddedShaders, g_caps.rendererType, "fs_debugfont");
m_program = createProgram(vsh, fsh, true);
@ -774,13 +744,13 @@ namespace bgfx
.add(Attrib::Position, 3, AttribType::Float)
.end();
ShaderHandle vsh = createEmbeddedShader(g_caps.rendererType, "vs_clear");
ShaderHandle vsh = createEmbeddedShader(s_embeddedShaders, g_caps.rendererType, "vs_clear");
for (uint32_t ii = 0, num = g_caps.limits.maxFBAttachments; ii < num; ++ii)
{
char name[32];
bx::snprintf(name, BX_COUNTOF(name), "fs_clear%d", ii);
ShaderHandle fsh = createEmbeddedShader(g_caps.rendererType, name);
ShaderHandle fsh = createEmbeddedShader(s_embeddedShaders, g_caps.rendererType, name);
m_program[ii] = createProgram(vsh, fsh);
BX_CHECK(isValid(m_program[ii]), "Failed to create clear quad program.");