Mirrors/bgfx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bgfx.git synced 2026-02-17 20:52:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

Removed context static inialization.

Browse Source
This commit is contained in:
bkaradzic
2013-09-20 22:13:58 -07:00
parent 083ada2fbd
commit a5948679ca
13 changed files with 682 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
examples/07-callback/callback.cpp
View File

@@ -316,6 +316,8 @@ class BgfxAllocator : public bx::ReallocatorI
{
public:
BgfxAllocator()
: m_numBlocks(0)
, m_maxBlocks(0)
{
}
@@ -327,24 +329,43 @@ public:
{
BX_UNUSED(_file, _line);
void* ptr = ::malloc(_size);
BX_TRACE("ALLOC %p of %d byte(s) at %s line %d.", ptr, _size, _file, _line);
dbgPrintf("%s(%d): ALLOC %p of %d byte(s)\n", _file, _line, ptr, _size);
++m_numBlocks;
m_maxBlocks = bx::uint32_max(m_maxBlocks, m_numBlocks);
return ptr;
}
virtual void free(void* _ptr, const char* _file, uint32_t _line) BX_OVERRIDE
{
BX_TRACE("FREE %p at %s line %d.", ptr, _file, _line);
dbgPrintf("%s(%d): FREE %p\n", _file, _line, _ptr);
BX_UNUSED(_file, _line);
::free(_ptr);
--m_numBlocks;
}
virtual void* realloc(void* _ptr, size_t _size, const char* _file, uint32_t _line) BX_OVERRIDE
{
BX_UNUSED(_file, _line);
void* ptr = ::realloc(_ptr, _size);
BX_TRACE("REALLOC %p (old %p) of %d byte(s) at %s line %d.", ptr, _ptr, _size, _file, _line);
dbgPrintf("%s(%d): REALLOC %p (old %p) of %d byte(s)\n", _file, _line, ptr, _ptr, _size);
if (NULL == _ptr)
{
++m_numBlocks;
m_maxBlocks = bx::uint32_max(m_maxBlocks, m_numBlocks);
}
return ptr;
}
void dumpStats() const
{
dbgPrintf("Allocator stats: num blocks %d (peak: %d)\n", m_numBlocks, m_maxBlocks);
}
private:
uint32_t m_numBlocks;
uint32_t m_maxBlocks;
};
int _main_(int /*_argc*/, char** /*_argv*/)
@@ -513,5 +534,7 @@ int _main_(int /*_argc*/, char** /*_argv*/)
// Shutdown bgfx.
bgfx::shutdown();
allocator.dumpStats();
return 0;
}

8
examples/common/font/font_manager.cpp
View File

@@ -438,15 +438,11 @@ struct FontManager::CachedFont
int16_t padding;
};
const uint16_t MAX_OPENED_FILES = 64;
const uint16_t MAX_OPENED_FONT = 64;
const uint32_t MAX_FONT_BUFFER_SIZE = 512 * 512 * 4;
#define MAX_FONT_BUFFER_SIZE (512 * 512 * 4)
FontManager::FontManager(Atlas* _atlas)
: m_ownAtlas(false)
, m_atlas(_atlas)
, m_fontHandles(MAX_OPENED_FONT)
, m_filesHandles(MAX_OPENED_FILES)
{
init();
}
@@ -454,8 +450,6 @@ FontManager::FontManager(Atlas* _atlas)
FontManager::FontManager(uint32_t _textureSideWidth)
: m_ownAtlas(true)
, m_atlas(new Atlas(_textureSideWidth) )
, m_fontHandles(MAX_OPENED_FONT)
, m_filesHandles(MAX_OPENED_FILES)
{
init();
}

7
examples/common/font/font_manager.h
View File

@@ -11,6 +11,9 @@
class Atlas;
#define MAX_OPENED_FILES 64
#define MAX_OPENED_FONT 64
#define FONT_TYPE_ALPHA UINT32_C(0x00000100) // L8
// #define FONT_TYPE_LCD UINT32_C(0x00000200) // BGRA8
// #define FONT_TYPE_RGBA UINT32_C(0x00000300) // BGRA8
@@ -188,10 +191,10 @@ private:
bool m_ownAtlas;
Atlas* m_atlas;
bx::HandleAlloc m_fontHandles;
bx::HandleAllocT<MAX_OPENED_FONT> m_fontHandles;
CachedFont* m_cachedFonts;
bx::HandleAlloc m_filesHandles;
bx::HandleAllocT<MAX_OPENED_FILES> m_filesHandles;
CachedFile* m_cachedFiles;
GlyphInfo m_blackGlyph;

4
examples/common/font/text_buffer_manager.cpp
View File

@@ -21,7 +21,6 @@
#include "vs_font_distance_field_subpixel.bin.h"
#include "fs_font_distance_field_subpixel.bin.h"
#define MAX_TEXT_BUFFER_COUNT 64
#define MAX_BUFFERED_CHARACTERS (8192 - 5)
class TextBuffer
@@ -545,8 +544,7 @@ void TextBuffer::verticalCenterLastLine(float _dy, float _top, float _bottom)
}
TextBufferManager::TextBufferManager(FontManager* _fontManager)
: m_textBufferHandles(MAX_TEXT_BUFFER_COUNT)
, m_fontManager(_fontManager)
: m_fontManager(_fontManager)
{
m_textBuffers = new BufferCache[MAX_TEXT_BUFFER_COUNT];

4
examples/common/font/text_buffer_manager.h
View File

@@ -10,6 +10,8 @@
BGFX_HANDLE(TextBufferHandle);
#define MAX_TEXT_BUFFER_COUNT 64
/// type of vertex and index buffer to use with a TextBuffer
struct BufferType
{
@@ -83,7 +85,7 @@ private:
};
BufferCache* m_textBuffers;
bx::HandleAlloc m_textBufferHandles;
bx::HandleAllocT<MAX_TEXT_BUFFER_COUNT> m_textBufferHandles;
FontManager* m_fontManager;
bgfx::VertexDecl m_vertexDecl;
bgfx::UniformHandle u_texColor;

296
src/bgfx.cpp
View File

@@ -113,15 +113,65 @@ namespace bgfx
{
}
};
static CallbackStub s_callbackStub;
static bx::CrtAllocator s_allocatorStub;
CallbackI* g_callback = &s_callbackStub;
bx::ReallocatorI* g_allocator = &s_allocatorStub;
class AllocatorStub : public bx::ReallocatorI
{
public:
AllocatorStub()
: m_numBlocks(0)
, m_maxBlocks(0)
{
}
virtual void* alloc(size_t _size, const char* _file, uint32_t _line) BX_OVERRIDE
{
++m_numBlocks;
m_maxBlocks = bx::uint32_max(m_maxBlocks, m_numBlocks);
BX_UNUSED(_file, _line);
return ::malloc(_size);
}
virtual void free(void* _ptr, const char* _file, uint32_t _line) BX_OVERRIDE
{
BX_CHECK(_ptr != NULL, "Freeing NULL! Fix it!");
--m_numBlocks;
BX_UNUSED(_file, _line);
::free(_ptr);
}
virtual void* realloc(void* _ptr, size_t _size, const char* _file, uint32_t _line) BX_OVERRIDE
{
if (NULL == _ptr)
{
++m_numBlocks;
m_maxBlocks = bx::uint32_max(m_maxBlocks, m_numBlocks);
}
BX_UNUSED(_file, _line);
return ::realloc(_ptr, _size);
}
void checkLeaks() const
{
BX_WARN(0 == m_numBlocks, "MEMORY LEAK: %d (max: %d)", m_numBlocks, m_maxBlocks);
}
private:
uint32_t m_numBlocks;
uint32_t m_maxBlocks;
};
static CallbackStub* s_callbackStub = NULL;
static AllocatorStub* s_allocatorStub = NULL;
CallbackI* g_callback = NULL;
bx::ReallocatorI* g_allocator = NULL;
static BX_THREAD uint32_t s_threadIndex = 0;
static Context s_ctx;
static Context* s_ctx;
void fatal(Fatal::Enum _code, const char* _format, ...)
{
@@ -248,8 +298,8 @@ namespace bgfx
destroyVertexShader(vsh);
destroyFragmentShader(fsh);
m_vb = s_ctx.createTransientVertexBuffer(numBatchVertices*m_decl.m_stride, &m_decl);
m_ib = s_ctx.createTransientIndexBuffer(numBatchIndices*2);
m_vb = s_ctx->createTransientVertexBuffer(numBatchVertices*m_decl.m_stride, &m_decl);
m_ib = s_ctx->createTransientIndexBuffer(numBatchIndices*2);
}
void TextVideoMemBlitter::shutdown()
@@ -258,8 +308,8 @@ namespace bgfx
destroyProgram(m_program);
destroyTexture(m_texture);
s_ctx.destroyTransientVertexBuffer(m_vb);
s_ctx.destroyTransientIndexBuffer(m_ib);
s_ctx->destroyTransientVertexBuffer(m_vb);
s_ctx->destroyTransientIndexBuffer(m_ib);
}
void TextVideoMemBlitter::blit(const TextVideoMem& _mem)
@@ -402,7 +452,7 @@ namespace bgfx
destroyVertexShader(vsh);
destroyFragmentShader(fsh);
m_vb = s_ctx.createTransientVertexBuffer(4*m_decl.m_stride, &m_decl);
m_vb = s_ctx->createTransientVertexBuffer(4*m_decl.m_stride, &m_decl);
mem = alloc(6*sizeof(uint16_t) );
uint16_t* indices = (uint16_t*)mem->data;
@@ -412,7 +462,7 @@ namespace bgfx
indices[3] = 2;
indices[4] = 3;
indices[5] = 0;
m_ib = s_ctx.createIndexBuffer(mem);
m_ib = s_ctx->createIndexBuffer(mem);
#endif // BGFX_CONFIG_CLEAR_QUAD
}
@@ -423,7 +473,7 @@ namespace bgfx
#if BGFX_CONFIG_CLEAR_QUAD
destroyProgram(m_program);
destroyIndexBuffer(m_ib);
s_ctx.destroyTransientVertexBuffer(m_vb);
s_ctx->destroyTransientVertexBuffer(m_vb);
#endif // BGFX_CONFIG_CLEAR_QUAD
}
@@ -479,8 +529,8 @@ namespace bgfx
{
m_key.m_depth = _depth;
m_key.m_view = _id;
m_key.m_seq = s_ctx.m_seq[_id] & s_ctx.m_seqMask[_id];
s_ctx.m_seq[_id]++;
m_key.m_seq = s_ctx->m_seq[_id] & s_ctx->m_seqMask[_id];
s_ctx->m_seq[_id]++;
uint64_t key = m_key.encode();
m_sortKeys[m_num] = key;
m_sortValues[m_num] = m_numRenderStates;
@@ -522,8 +572,8 @@ namespace bgfx
id += ntz;
m_key.m_view = id;
m_key.m_seq = s_ctx.m_seq[id] & s_ctx.m_seqMask[id];
s_ctx.m_seq[id]++;
m_key.m_seq = s_ctx->m_seq[id] & s_ctx->m_seqMask[id];
s_ctx->m_seq[id]++;
uint64_t key = m_key.encode();
m_sortKeys[m_num] = key;
m_sortValues[m_num] = m_numRenderStates;
@@ -542,7 +592,7 @@ namespace bgfx
void Frame::sort()
{
bx::radixSort64(m_sortKeys, s_ctx.m_tempKeys, m_sortValues, s_ctx.m_tempValues, m_num);
bx::radixSort64(m_sortKeys, s_ctx->m_tempKeys, m_sortValues, s_ctx->m_tempValues, m_num);
}
RendererType::Enum getRendererType()
@@ -564,48 +614,80 @@ namespace bgfx
void init(CallbackI* _callback, bx::ReallocatorI* _allocator)
{
if (NULL != _callback)
{
g_callback = _callback;
}
if (NULL != _allocator)
{
g_allocator = _allocator;
}
else
{
bx::CrtAllocator allocator;
g_allocator =
s_allocatorStub = BX_NEW(&allocator, AllocatorStub);
}
if (NULL != _callback)
{
g_callback = _callback;
}
else
{
g_callback =
s_callbackStub = BX_NEW(g_allocator, CallbackStub);
}
s_threadIndex = BGFX_MAIN_THREAD_MAGIC;
s_ctx = BX_NEW(g_allocator, Context);
// On NaCl renderer is on the main thread.
s_ctx.init(!BX_PLATFORM_NACL && !BX_PLATFORM_IOS);
s_ctx->init(!BX_PLATFORM_NACL && !BX_PLATFORM_IOS);
}
void shutdown()
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.shutdown();
s_ctx->shutdown();
BX_DELETE(g_allocator, s_ctx);
if (NULL != s_callbackStub)
{
BX_DELETE(g_allocator, s_callbackStub);
s_callbackStub = NULL;
}
if (NULL != s_allocatorStub)
{
s_allocatorStub->checkLeaks();
bx::CrtAllocator allocator;
BX_DELETE(&allocator, s_allocatorStub);
s_allocatorStub = NULL;
}
s_threadIndex = 0;
g_callback = &s_callbackStub;
g_allocator = &s_allocatorStub;
g_callback = NULL;
g_allocator = NULL;
BX_TRACE("Shutdown complete.");
}
void reset(uint32_t _width, uint32_t _height, uint32_t _flags)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.reset(_width, _height, _flags);
s_ctx->reset(_width, _height, _flags);
}
void frame()
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.frame();
s_ctx->frame();
}
bool renderFrame()
{
BGFX_CHECK_RENDER_THREAD();
return s_ctx.renderFrame();
return s_ctx->renderFrame();
}
const uint32_t g_uniformTypeSize[UniformType::Count+1] =
@@ -742,7 +824,11 @@ namespace bgfx
#if BGFX_CONFIG_DEBUG
# define CHECK_HANDLE_LEAK(_handleAlloc) \
do { \
BX_WARN(0 == _handleAlloc.getNumHandles(), "LEAK: " #_handleAlloc " %d (max: %d)", _handleAlloc.getNumHandles(), _handleAlloc.getMaxHandles() ); \
BX_WARN(0 == _handleAlloc.getNumHandles() \
, "LEAK: " #_handleAlloc " %d (max: %d)" \
, _handleAlloc.getNumHandles() \
, _handleAlloc.getMaxHandles() \
); \
} while (0)
CHECK_HANDLE_LEAK(m_dynamicIndexBufferHandle);
@@ -786,13 +872,13 @@ namespace bgfx
void setDebug(uint32_t _debug)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_debug = _debug;
s_ctx->m_debug = _debug;
}
void dbgTextClear(uint8_t _attr, bool _small)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.dbgTextClear(_attr, _small);
s_ctx->dbgTextClear(_attr, _small);
}
void dbgTextPrintf(uint16_t _x, uint16_t _y, uint8_t _attr, const char* _format, ...)
@@ -800,66 +886,66 @@ namespace bgfx
BGFX_CHECK_MAIN_THREAD();
va_list argList;
va_start(argList, _format);
s_ctx.dbgTextPrintfVargs(_x, _y, _attr, _format, argList);
s_ctx->dbgTextPrintfVargs(_x, _y, _attr, _format, argList);
va_end(argList);
}
IndexBufferHandle createIndexBuffer(const Memory* _mem)
{
BGFX_CHECK_MAIN_THREAD();
return s_ctx.createIndexBuffer(_mem);
return s_ctx->createIndexBuffer(_mem);
}
void destroyIndexBuffer(IndexBufferHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyIndexBuffer(_handle);
s_ctx->destroyIndexBuffer(_handle);
}
VertexBufferHandle createVertexBuffer(const Memory* _mem, const VertexDecl& _decl)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(0 != _decl.m_stride, "Invalid VertexDecl.");
return s_ctx.createVertexBuffer(_mem, _decl);
return s_ctx->createVertexBuffer(_mem, _decl);
}
void destroyVertexBuffer(VertexBufferHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyVertexBuffer(_handle);
s_ctx->destroyVertexBuffer(_handle);
}
DynamicIndexBufferHandle createDynamicIndexBuffer(uint16_t _num)
{
BGFX_CHECK_MAIN_THREAD();
return s_ctx.createDynamicIndexBuffer(_num);
return s_ctx->createDynamicIndexBuffer(_num);
}
DynamicIndexBufferHandle createDynamicIndexBuffer(const Memory* _mem)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _mem, "_mem can't be NULL");
return s_ctx.createDynamicIndexBuffer(_mem);
return s_ctx->createDynamicIndexBuffer(_mem);
}
void updateDynamicIndexBuffer(DynamicIndexBufferHandle _handle, const Memory* _mem)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _mem, "_mem can't be NULL");
s_ctx.updateDynamicIndexBuffer(_handle, _mem);
s_ctx->updateDynamicIndexBuffer(_handle, _mem);
}
void destroyDynamicIndexBuffer(DynamicIndexBufferHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyDynamicIndexBuffer(_handle);
s_ctx->destroyDynamicIndexBuffer(_handle);
}
DynamicVertexBufferHandle createDynamicVertexBuffer(uint16_t _num, const VertexDecl& _decl)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(0 != _decl.m_stride, "Invalid VertexDecl.");
return s_ctx.createDynamicVertexBuffer(_num, _decl);
return s_ctx->createDynamicVertexBuffer(_num, _decl);
}
DynamicVertexBufferHandle createDynamicVertexBuffer(const Memory* _mem, const VertexDecl& _decl)
@@ -867,27 +953,27 @@ namespace bgfx
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _mem, "_mem can't be NULL");
BX_CHECK(0 != _decl.m_stride, "Invalid VertexDecl.");
return s_ctx.createDynamicVertexBuffer(_mem, _decl);
return s_ctx->createDynamicVertexBuffer(_mem, _decl);
}
void updateDynamicVertexBuffer(DynamicVertexBufferHandle _handle, const Memory* _mem)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _mem, "_mem can't be NULL");
s_ctx.updateDynamicVertexBuffer(_handle, _mem);
s_ctx->updateDynamicVertexBuffer(_handle, _mem);
}
void destroyDynamicVertexBuffer(DynamicVertexBufferHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyDynamicVertexBuffer(_handle);
s_ctx->destroyDynamicVertexBuffer(_handle);
}
bool checkAvailTransientIndexBuffer(uint32_t _num)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(0 < _num, "Requesting 0 indices.");
return s_ctx.m_submit->checkAvailTransientIndexBuffer(_num);
return s_ctx->m_submit->checkAvailTransientIndexBuffer(_num);
}
bool checkAvailTransientVertexBuffer(uint32_t _num, const VertexDecl& _decl)
@@ -895,14 +981,14 @@ namespace bgfx
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(0 < _num, "Requesting 0 vertices.");
BX_CHECK(0 != _decl.m_stride, "Invalid VertexDecl.");
return s_ctx.m_submit->checkAvailTransientVertexBuffer(_num, _decl.m_stride);
return s_ctx->m_submit->checkAvailTransientVertexBuffer(_num, _decl.m_stride);
}
bool checkAvailInstanceDataBuffer(uint32_t _num, uint16_t _stride)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(0 < _num, "Requesting 0 instances.");
return s_ctx.m_submit->checkAvailTransientVertexBuffer(_num, _stride);
return s_ctx->m_submit->checkAvailTransientVertexBuffer(_num, _stride);
}
bool checkAvailTransientBuffers(uint32_t _numVertices, const VertexDecl& _decl, uint32_t _numIndices)
@@ -918,7 +1004,7 @@ namespace bgfx
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _tib, "_tib can't be NULL");
BX_CHECK(0 < _num, "Requesting 0 indices.");
return s_ctx.allocTransientIndexBuffer(_tib, _num);
return s_ctx->allocTransientIndexBuffer(_tib, _num);
}
void allocTransientVertexBuffer(TransientVertexBuffer* _tvb, uint32_t _num, const VertexDecl& _decl)
@@ -928,52 +1014,52 @@ namespace bgfx
BX_CHECK(0 < _num, "Requesting 0 vertices.");
BX_CHECK(UINT16_MAX >= _num, "Requesting %d vertices (max: %d).", _num, UINT16_MAX);
BX_CHECK(0 != _decl.m_stride, "Invalid VertexDecl.");
return s_ctx.allocTransientVertexBuffer(_tvb, _num, _decl);
return s_ctx->allocTransientVertexBuffer(_tvb, _num, _decl);
}
const InstanceDataBuffer* allocInstanceDataBuffer(uint32_t _num, uint16_t _stride)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(0 < _num, "Requesting 0 instanced data vertices.");
return s_ctx.allocInstanceDataBuffer(_num, _stride);
return s_ctx->allocInstanceDataBuffer(_num, _stride);
}
VertexShaderHandle createVertexShader(const Memory* _mem)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _mem, "_mem can't be NULL");
return s_ctx.createVertexShader(_mem);
return s_ctx->createVertexShader(_mem);
}
void destroyVertexShader(VertexShaderHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyVertexShader(_handle);
s_ctx->destroyVertexShader(_handle);
}
FragmentShaderHandle createFragmentShader(const Memory* _mem)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _mem, "_mem can't be NULL");
return s_ctx.createFragmentShader(_mem);
return s_ctx->createFragmentShader(_mem);
}
void destroyFragmentShader(FragmentShaderHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyFragmentShader(_handle);
s_ctx->destroyFragmentShader(_handle);
}
ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh)
{
BGFX_CHECK_MAIN_THREAD();
return s_ctx.createProgram(_vsh, _fsh);
return s_ctx->createProgram(_vsh, _fsh);
}
void destroyProgram(ProgramHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyProgram(_handle);
s_ctx->destroyProgram(_handle);
}
void calcTextureSize(TextureInfo& _info, uint16_t _width, uint16_t _height, uint16_t _depth, uint8_t _numMips, TextureFormat::Enum _format)
@@ -1016,7 +1102,7 @@ namespace bgfx
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _mem, "_mem can't be NULL");
return s_ctx.createTexture(_mem, _flags, _info);
return s_ctx->createTexture(_mem, _flags, _info);
}
TextureHandle createTexture2D(uint16_t _width, uint16_t _height, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem)
@@ -1055,7 +1141,7 @@ namespace bgfx
tc.m_mem = _mem;
bx::write(&writer, tc);
return s_ctx.createTexture(mem, _flags, NULL);
return s_ctx->createTexture(mem, _flags, NULL);
}
TextureHandle createTexture3D(uint16_t _width, uint16_t _height, uint16_t _depth, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem)
@@ -1094,7 +1180,7 @@ namespace bgfx
tc.m_mem = _mem;
bx::write(&writer, tc);
return s_ctx.createTexture(mem, _flags, NULL);
return s_ctx->createTexture(mem, _flags, NULL);
}
TextureHandle createTextureCube(uint16_t _sides, uint16_t _width, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem)
@@ -1133,13 +1219,13 @@ namespace bgfx
tc.m_mem = _mem;
bx::write(&writer, tc);
return s_ctx.createTexture(mem, _flags, NULL);
return s_ctx->createTexture(mem, _flags, NULL);
}
void destroyTexture(TextureHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyTexture(_handle);
s_ctx->destroyTexture(_handle);
}
void updateTexture2D(TextureHandle _handle, uint8_t _mip, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height, const Memory* _mem)
@@ -1153,7 +1239,7 @@ namespace bgfx
}
else
{
s_ctx.updateTexture(_handle, 0, _mip, _x, _y, 0, _width, _height, 1, _mem);
s_ctx->updateTexture(_handle, 0, _mip, _x, _y, 0, _width, _height, 1, _mem);
}
}
@@ -1169,7 +1255,7 @@ namespace bgfx
}
else
{
s_ctx.updateTexture(_handle, 0, _mip, _x, _y, _z, _width, _height, _depth, _mem);
s_ctx->updateTexture(_handle, 0, _mip, _x, _y, _z, _width, _height, _depth, _mem);
}
}
@@ -1185,7 +1271,7 @@ namespace bgfx
}
else
{
s_ctx.updateTexture(_handle, _side, _mip, _x, _y, 0, _width, _height, 1, _mem);
s_ctx->updateTexture(_handle, _side, _mip, _x, _y, 0, _width, _height, 1, _mem);
}
}
@@ -1193,163 +1279,163 @@ namespace bgfx
{
BGFX_CHECK_MAIN_THREAD();
BX_WARN(0 != _width && 0 != _height, "Render target resolution width or height cannot be 0 (width %d, height %d).", _width, _height);
return s_ctx.createRenderTarget(bx::uint16_max(1, _width), bx::uint16_max(1, _height), _flags, _textureFlags);
return s_ctx->createRenderTarget(bx::uint16_max(1, _width), bx::uint16_max(1, _height), _flags, _textureFlags);
}
void destroyRenderTarget(RenderTargetHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyRenderTarget(_handle);
s_ctx->destroyRenderTarget(_handle);
}
UniformHandle createUniform(const char* _name, UniformType::Enum _type, uint16_t _num)
{
BGFX_CHECK_MAIN_THREAD();
return s_ctx.createUniform(_name, _type, _num);
return s_ctx->createUniform(_name, _type, _num);
}
void destroyUniform(UniformHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.destroyUniform(_handle);
s_ctx->destroyUniform(_handle);
}
void setViewName(uint8_t _id, const char* _name)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewName(_id, _name);
s_ctx->setViewName(_id, _name);
}
void setViewRect(uint8_t _id, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewRect(_id, _x, _y, _width, _height);
s_ctx->setViewRect(_id, _x, _y, _width, _height);
}
void setViewRectMask(uint32_t _viewMask, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewRectMask(_viewMask, _x, _y, _width, _height);
s_ctx->setViewRectMask(_viewMask, _x, _y, _width, _height);
}
void setViewScissor(uint8_t _id, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewScissor(_id, _x, _y, _width, _height);
s_ctx->setViewScissor(_id, _x, _y, _width, _height);
}
void setViewScissorMask(uint32_t _viewMask, uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewScissorMask(_viewMask, _x, _y, _width, _height);
s_ctx->setViewScissorMask(_viewMask, _x, _y, _width, _height);
}
void setViewClear(uint8_t _id, uint8_t _flags, uint32_t _rgba, float _depth, uint8_t _stencil)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewClear(_id, _flags, _rgba, _depth, _stencil);
s_ctx->setViewClear(_id, _flags, _rgba, _depth, _stencil);
}
void setViewClearMask(uint32_t _viewMask, uint8_t _flags, uint32_t _rgba, float _depth, uint8_t _stencil)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewClearMask(_viewMask, _flags, _rgba, _depth, _stencil);
s_ctx->setViewClearMask(_viewMask, _flags, _rgba, _depth, _stencil);
}
void setViewSeq(uint8_t _id, bool _enabled)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewSeq(_id, _enabled);
s_ctx->setViewSeq(_id, _enabled);
}
void setViewSeqMask(uint32_t _viewMask, bool _enabled)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewSeqMask(_viewMask, _enabled);
s_ctx->setViewSeqMask(_viewMask, _enabled);
}
void setViewRenderTarget(uint8_t _id, RenderTargetHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewRenderTarget(_id, _handle);
s_ctx->setViewRenderTarget(_id, _handle);
}
void setViewRenderTargetMask(uint32_t _mask, RenderTargetHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewRenderTargetMask(_mask, _handle);
s_ctx->setViewRenderTargetMask(_mask, _handle);
}
void setViewTransform(uint8_t _id, const void* _view, const void* _proj, uint8_t _other)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewTransform(_id, _view, _proj, _other);
s_ctx->setViewTransform(_id, _view, _proj, _other);
}
void setViewTransformMask(uint32_t _viewMask, const void* _view, const void* _proj, uint8_t _other)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setViewTransformMask(_viewMask, _view, _proj, _other);
s_ctx->setViewTransformMask(_viewMask, _view, _proj, _other);
}
void setMarker(const char* _marker)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setMarker(_marker);
s_ctx->m_submit->setMarker(_marker);
}
void setState(uint64_t _state, uint32_t _rgba)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setState(_state, _rgba);
s_ctx->m_submit->setState(_state, _rgba);
}
void setStencil(uint32_t _fstencil, uint32_t _bstencil)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setStencil(_fstencil, _bstencil);
s_ctx->m_submit->setStencil(_fstencil, _bstencil);
}
uint16_t setScissor(uint16_t _x, uint16_t _y, uint16_t _width, uint16_t _height)
{
BGFX_CHECK_MAIN_THREAD();
return s_ctx.m_submit->setScissor(_x, _y, _width, _height);
return s_ctx->m_submit->setScissor(_x, _y, _width, _height);
}
void setScissor(uint16_t _cache)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setScissor(_cache);
s_ctx->m_submit->setScissor(_cache);
}
uint32_t setTransform(const void* _mtx, uint16_t _num)
{
BGFX_CHECK_MAIN_THREAD();
return s_ctx.m_submit->setTransform(_mtx, _num);
return s_ctx->m_submit->setTransform(_mtx, _num);
}
void setTransform(uint32_t _cache, uint16_t _num)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setTransform(_cache, _num);
s_ctx->m_submit->setTransform(_cache, _num);
}
void setUniform(UniformHandle _handle, const void* _value, uint16_t _num)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.setUniform(_handle, _value, _num);
s_ctx->setUniform(_handle, _value, _num);
}
void setIndexBuffer(IndexBufferHandle _handle, uint32_t _firstIndex, uint32_t _numIndices)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setIndexBuffer(_handle, _firstIndex, _numIndices);
s_ctx->m_submit->setIndexBuffer(_handle, _firstIndex, _numIndices);
}
void setIndexBuffer(DynamicIndexBufferHandle _handle, uint32_t _firstIndex, uint32_t _numIndices)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setIndexBuffer(s_ctx.m_dynamicIndexBuffers[_handle.idx].m_handle, _firstIndex, _numIndices);
s_ctx->m_submit->setIndexBuffer(s_ctx->m_dynamicIndexBuffers[_handle.idx].m_handle, _firstIndex, _numIndices);
}
void setIndexBuffer(const TransientIndexBuffer* _tib, uint32_t _numIndices)
@@ -1357,73 +1443,73 @@ namespace bgfx
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _tib, "_tib can't be NULL");
uint32_t numIndices = bx::uint32_min(_numIndices, _tib->size/2);
s_ctx.m_submit->setIndexBuffer(_tib, numIndices);
s_ctx->m_submit->setIndexBuffer(_tib, numIndices);
}
void setVertexBuffer(VertexBufferHandle _handle, uint32_t _numVertices)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setVertexBuffer(_handle, _numVertices);
s_ctx->m_submit->setVertexBuffer(_handle, _numVertices);
}
void setVertexBuffer(DynamicVertexBufferHandle _handle, uint32_t _numVertices)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setVertexBuffer(s_ctx.m_dynamicVertexBuffers[_handle.idx], _numVertices);
s_ctx->m_submit->setVertexBuffer(s_ctx->m_dynamicVertexBuffers[_handle.idx], _numVertices);
}
void setVertexBuffer(const TransientVertexBuffer* _tvb, uint32_t _numVertices)
{
BGFX_CHECK_MAIN_THREAD();
BX_CHECK(NULL != _tvb, "_tvb can't be NULL");
s_ctx.m_submit->setVertexBuffer(_tvb, _numVertices);
s_ctx->m_submit->setVertexBuffer(_tvb, _numVertices);
}
void setInstanceDataBuffer(const InstanceDataBuffer* _idb, uint16_t _num)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setInstanceDataBuffer(_idb, _num);
s_ctx->m_submit->setInstanceDataBuffer(_idb, _num);
}
void setProgram(ProgramHandle _handle)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setProgram(_handle);
s_ctx->m_submit->setProgram(_handle);
}
void setTexture(uint8_t _stage, UniformHandle _sampler, TextureHandle _handle, uint32_t _flags)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setTexture(_stage, _sampler, _handle, _flags);
s_ctx->m_submit->setTexture(_stage, _sampler, _handle, _flags);
}
void setTexture(uint8_t _stage, UniformHandle _sampler, RenderTargetHandle _handle, bool _depth, uint32_t _flags)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->setTexture(_stage, _sampler, _handle, _depth, _flags);
s_ctx->m_submit->setTexture(_stage, _sampler, _handle, _depth, _flags);
}
void submit(uint8_t _id, int32_t _depth)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->submit(_id, _depth);
s_ctx->m_submit->submit(_id, _depth);
}
void submitMask(uint32_t _viewMask, int32_t _depth)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->submitMask(_viewMask, _depth);
s_ctx->m_submit->submitMask(_viewMask, _depth);
}
void discard()
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.m_submit->discard();
s_ctx->m_submit->discard();
}
void saveScreenShot(const char* _filePath)
{
BGFX_CHECK_MAIN_THREAD();
s_ctx.saveScreenShot(_filePath);
s_ctx->saveScreenShot(_filePath);
}
}

42
src/bgfx_p.h
View File

@@ -999,17 +999,18 @@ namespace bgfx
m_constantBuffer = ConstantBuffer::create(BGFX_CONFIG_MAX_CONSTANT_BUFFER_SIZE);
reset();
finish();
m_textVideoMem = new TextVideoMem;
m_textVideoMem = BX_NEW(g_allocator, TextVideoMem);
}
void destroy()
{
ConstantBuffer::destroy(m_constantBuffer);
delete m_textVideoMem;
BX_DELETE(g_allocator, m_textVideoMem);
}
void reset()
{
m_flags = BGFX_STATE_NONE;
m_state.reset();
m_matrixCache.reset();
m_rectCache.reset();
@@ -1370,7 +1371,8 @@ namespace bgfx
memset(m_vertexBufferRef, 0xff, sizeof(m_vertexBufferRef) );
}
void shutdown(bx::HandleAlloc& _handleAlloc)
template <uint16_t MaxHandlesT>
void shutdown(bx::HandleAllocT<MaxHandlesT>& _handleAlloc)
{
for (VertexDeclMap::iterator it = m_vertexDeclMap.begin(), itEnd = m_vertexDeclMap.end(); it != itEnd; ++it)
{
@@ -1533,17 +1535,6 @@ namespace bgfx
, m_submit(&m_frame[1])
, m_numFreeDynamicIndexBufferHandles(0)
, m_numFreeDynamicVertexBufferHandles(0)
, m_dynamicIndexBufferHandle(BGFX_CONFIG_MAX_DYNAMIC_INDEX_BUFFERS)
, m_dynamicVertexBufferHandle(BGFX_CONFIG_MAX_DYNAMIC_VERTEX_BUFFERS)
, m_indexBufferHandle(BGFX_CONFIG_MAX_INDEX_BUFFERS)
, m_vertexDeclHandle(BGFX_CONFIG_MAX_VERTEX_DECLS)
, m_vertexBufferHandle(BGFX_CONFIG_MAX_VERTEX_BUFFERS)
, m_vertexShaderHandle(BGFX_CONFIG_MAX_VERTEX_SHADERS)
, m_fragmentShaderHandle(BGFX_CONFIG_MAX_FRAGMENT_SHADERS)
, m_programHandle(BGFX_CONFIG_MAX_PROGRAMS)
, m_textureHandle(BGFX_CONFIG_MAX_TEXTURES)
, m_renderTargetHandle(BGFX_CONFIG_MAX_RENDER_TARGETS)
, m_uniformHandle(BGFX_CONFIG_MAX_UNIFORMS)
, m_frames(0)
, m_debug(BGFX_DEBUG_NONE)
, m_rendererInitialized(false)
@@ -3163,19 +3154,20 @@ namespace bgfx
DynamicVertexBufferHandle m_freeDynamicVertexBufferHandle[BGFX_CONFIG_MAX_DYNAMIC_VERTEX_BUFFERS];
NonLocalAllocator m_dynamicIndexBufferAllocator;
bx::HandleAlloc m_dynamicIndexBufferHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_DYNAMIC_INDEX_BUFFERS> m_dynamicIndexBufferHandle;
NonLocalAllocator m_dynamicVertexBufferAllocator;
bx::HandleAlloc m_dynamicVertexBufferHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_DYNAMIC_VERTEX_BUFFERS> m_dynamicVertexBufferHandle;
bx::HandleAlloc m_indexBufferHandle;
bx::HandleAlloc m_vertexDeclHandle;
bx::HandleAlloc m_vertexBufferHandle;
bx::HandleAlloc m_vertexShaderHandle;
bx::HandleAlloc m_fragmentShaderHandle;
bx::HandleAlloc m_programHandle;
bx::HandleAlloc m_textureHandle;
bx::HandleAlloc m_renderTargetHandle;
bx::HandleAlloc m_uniformHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_INDEX_BUFFERS> m_indexBufferHandle;
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_PROGRAMS> m_programHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_TEXTURES> m_textureHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_RENDER_TARGETS> m_renderTargetHandle;
bx::HandleAllocT<BGFX_CONFIG_MAX_UNIFORMS> m_uniformHandle;
struct VertexShaderRef
{

6
src/renderer_d3d.h
View File

@@ -44,9 +44,9 @@ namespace bgfx
typedef void (WINAPI *D3DPERF_SetOptionsFunc)(DWORD _options);
typedef DWORD (WINAPI *D3DPERF_GetStatusFunc)();
#define _PIX_SETMARKER(_col, _name) s_renderCtx.m_D3DPERF_SetMarker(_col, _name)
#define _PIX_BEGINEVENT(_col, _name) s_renderCtx.m_D3DPERF_BeginEvent(_col, _name)
#define _PIX_ENDEVENT() s_renderCtx.m_D3DPERF_EndEvent()
#define _PIX_SETMARKER(_col, _name) s_renderCtx->m_D3DPERF_SetMarker(_col, _name)
#define _PIX_BEGINEVENT(_col, _name) s_renderCtx->m_D3DPERF_BeginEvent(_col, _name)
#define _PIX_ENDEVENT() s_renderCtx->m_D3DPERF_EndEvent()
#if BGFX_CONFIG_DEBUG_PIX
# define PIX_SETMARKER(_color, _name) _PIX_SETMARKER(_color, _name)

282
src/renderer_d3d11.cpp
View File

@@ -1181,7 +1181,7 @@ namespace bgfx
uint32_t m_fsChanges;
};
static RendererContext s_renderCtx;
static RendererContext* s_renderCtx;
void IndexBuffer::create(uint32_t _size, void* _data)
{
@@ -1199,7 +1199,7 @@ namespace bgfx
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
DX_CHECK(s_renderCtx.m_device->CreateBuffer(&desc
DX_CHECK(s_renderCtx->m_device->CreateBuffer(&desc
, NULL
, &m_ptr
) );
@@ -1214,7 +1214,7 @@ namespace bgfx
srd.SysMemPitch = 0;
srd.SysMemSlicePitch = 0;
DX_CHECK(s_renderCtx.m_device->CreateBuffer(&desc
DX_CHECK(s_renderCtx->m_device->CreateBuffer(&desc
, &srd
, &m_ptr
) );
@@ -1223,7 +1223,7 @@ namespace bgfx
void IndexBuffer::update(uint32_t _offset, uint32_t _size, void* _data)
{
ID3D11DeviceContext* deviceCtx = s_renderCtx.m_deviceCtx;
ID3D11DeviceContext* deviceCtx = s_renderCtx->m_deviceCtx;
BX_CHECK(m_dynamic, "Must be dynamic!");
D3D11_MAPPED_SUBRESOURCE mapped;
@@ -1250,7 +1250,7 @@ namespace bgfx
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.StructureByteStride = 0;
DX_CHECK(s_renderCtx.m_device->CreateBuffer(&desc
DX_CHECK(s_renderCtx->m_device->CreateBuffer(&desc
, NULL
, &m_ptr
) );
@@ -1266,7 +1266,7 @@ namespace bgfx
srd.SysMemPitch = 0;
srd.SysMemSlicePitch = 0;
DX_CHECK(s_renderCtx.m_device->CreateBuffer(&desc
DX_CHECK(s_renderCtx->m_device->CreateBuffer(&desc
, &srd
, &m_ptr
) );
@@ -1275,7 +1275,7 @@ namespace bgfx
void VertexBuffer::update(uint32_t _offset, uint32_t _size, void* _data)
{
ID3D11DeviceContext* deviceCtx = s_renderCtx.m_deviceCtx;
ID3D11DeviceContext* deviceCtx = s_renderCtx->m_deviceCtx;
BX_CHECK(m_dynamic, "Must be dynamic!");
D3D11_MAPPED_SUBRESOURCE mapped;
@@ -1318,7 +1318,7 @@ namespace bgfx
case UniformType::_uniform: \
case UniformType::_uniform|BGFX_UNIFORM_FRAGMENTBIT: \
{ \
s_renderCtx.setShaderConstant(type, loc, data, num); \
s_renderCtx->setShaderConstant(type, loc, data, num); \
} \
break;
@@ -1349,13 +1349,13 @@ namespace bgfx
void TextVideoMemBlitter::setup()
{
ID3D11DeviceContext* deviceCtx = s_renderCtx.m_deviceCtx;
ID3D11DeviceContext* deviceCtx = s_renderCtx->m_deviceCtx;
uint32_t width = s_renderCtx.m_scd.BufferDesc.Width;
uint32_t height = s_renderCtx.m_scd.BufferDesc.Height;
uint32_t width = s_renderCtx->m_scd.BufferDesc.Width;
uint32_t height = s_renderCtx->m_scd.BufferDesc.Height;
RenderTargetHandle rt = BGFX_INVALID_HANDLE;
s_renderCtx.setRenderTarget(rt, false);
s_renderCtx->setRenderTarget(rt, false);
D3D11_VIEWPORT vp;
vp.TopLeftX = 0;
@@ -1371,25 +1371,25 @@ namespace bgfx
| BGFX_STATE_DEPTH_TEST_ALWAYS
;
s_renderCtx.setBlendState(state);
s_renderCtx.setDepthStencilState(state);
s_renderCtx.setRasterizerState(state);
s_renderCtx->setBlendState(state);
s_renderCtx->setDepthStencilState(state);
s_renderCtx->setRasterizerState(state);
Program& program = s_renderCtx.m_program[m_program.idx];
s_renderCtx.m_currentProgram = &program;
Program& program = s_renderCtx->m_program[m_program.idx];
s_renderCtx->m_currentProgram = &program;
deviceCtx->VSSetShader( (ID3D11VertexShader*)program.m_vsh->m_ptr, NULL, 0);
deviceCtx->VSSetConstantBuffers(0, 1, &program.m_vsh->m_buffer);
deviceCtx->PSSetShader( (ID3D11PixelShader*)program.m_fsh->m_ptr, NULL, 0);
deviceCtx->PSSetConstantBuffers(0, 1, &program.m_fsh->m_buffer);
VertexBuffer& vb = s_renderCtx.m_vertexBuffers[m_vb->handle.idx];
VertexDecl& vertexDecl = s_renderCtx.m_vertexDecls[m_vb->decl.idx];
VertexBuffer& vb = s_renderCtx->m_vertexBuffers[m_vb->handle.idx];
VertexDecl& vertexDecl = s_renderCtx->m_vertexDecls[m_vb->decl.idx];
uint32_t stride = vertexDecl.m_stride;
uint32_t offset = 0;
deviceCtx->IASetVertexBuffers(0, 1, &vb.m_ptr, &stride, &offset);
s_renderCtx.setInputLayout(vertexDecl, program, 0);
s_renderCtx->setInputLayout(vertexDecl, program, 0);
IndexBuffer& ib = s_renderCtx.m_indexBuffers[m_ib->handle.idx];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[m_ib->handle.idx];
deviceCtx->IASetIndexBuffer(ib.m_ptr, DXGI_FORMAT_R16_UINT, 0);
float proj[16];
@@ -1397,22 +1397,22 @@ namespace bgfx
PredefinedUniform& predefined = program.m_predefined[0];
uint8_t flags = predefined.m_type;
s_renderCtx.setShaderConstant(flags, predefined.m_loc, proj, 4);
s_renderCtx->setShaderConstant(flags, predefined.m_loc, proj, 4);
s_renderCtx.commitShaderConstants();
s_renderCtx.m_textures[m_texture.idx].commit(0);
s_renderCtx.commitTextureStage();
s_renderCtx->commitShaderConstants();
s_renderCtx->m_textures[m_texture.idx].commit(0);
s_renderCtx->commitTextureStage();
}
void TextVideoMemBlitter::render(uint32_t _numIndices)
{
ID3D11DeviceContext* deviceCtx = s_renderCtx.m_deviceCtx;
ID3D11DeviceContext* deviceCtx = s_renderCtx->m_deviceCtx;
IndexBuffer& ib = s_renderCtx.m_indexBuffers[m_ib->handle.idx];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[m_ib->handle.idx];
ib.update(0, _numIndices*2, m_ib->data);
uint32_t numVertices = _numIndices*4/6;
s_renderCtx.m_vertexBuffers[m_vb->handle.idx].update(0, numVertices*m_decl.m_stride, m_vb->data);
s_renderCtx->m_vertexBuffers[m_vb->handle.idx].update(0, numVertices*m_decl.m_stride, m_vb->data);
deviceCtx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
deviceCtx->DrawIndexed(_numIndices, 0, 0);
@@ -1421,19 +1421,19 @@ namespace bgfx
void ClearQuad::clear(const Rect& _rect, const Clear& _clear, uint32_t _height)
{
BX_UNUSED(_height);
uint32_t width = s_renderCtx.m_scd.BufferDesc.Width;
uint32_t height = s_renderCtx.m_scd.BufferDesc.Height;
uint32_t width = s_renderCtx->m_scd.BufferDesc.Width;
uint32_t height = s_renderCtx->m_scd.BufferDesc.Height;
if (0 == _rect.m_x
&& 0 == _rect.m_y
&& width == _rect.m_width
&& height == _rect.m_height)
{
s_renderCtx.clear(_clear);
s_renderCtx->clear(_clear);
}
else
{
ID3D11DeviceContext* deviceCtx = s_renderCtx.m_deviceCtx;
ID3D11DeviceContext* deviceCtx = s_renderCtx->m_deviceCtx;
uint64_t state = 0;
state |= _clear.m_flags & BGFX_CLEAR_COLOR_BIT ? BGFX_STATE_RGB_WRITE|BGFX_STATE_ALPHA_WRITE : 0;
@@ -1450,19 +1450,19 @@ namespace bgfx
: 0
;
s_renderCtx.setBlendState(state);
s_renderCtx.setDepthStencilState(state, stencil);
s_renderCtx.setRasterizerState(state);
s_renderCtx->setBlendState(state);
s_renderCtx->setDepthStencilState(state, stencil);
s_renderCtx->setRasterizerState(state);
Program& program = s_renderCtx.m_program[m_program.idx];
s_renderCtx.m_currentProgram = &program;
Program& program = s_renderCtx->m_program[m_program.idx];
s_renderCtx->m_currentProgram = &program;
deviceCtx->VSSetShader( (ID3D11VertexShader*)program.m_vsh->m_ptr, NULL, 0);
deviceCtx->VSSetConstantBuffers(0, 0, NULL);
deviceCtx->PSSetShader( (ID3D11PixelShader*)program.m_fsh->m_ptr, NULL, 0);
deviceCtx->PSSetConstantBuffers(0, 0, NULL);
VertexBuffer& vb = s_renderCtx.m_vertexBuffers[m_vb->handle.idx];
VertexDecl& vertexDecl = s_renderCtx.m_vertexDecls[m_vb->decl.idx];
VertexBuffer& vb = s_renderCtx->m_vertexBuffers[m_vb->handle.idx];
VertexDecl& vertexDecl = s_renderCtx->m_vertexDecls[m_vb->decl.idx];
uint32_t stride = vertexDecl.m_stride;
uint32_t offset = 0;
@@ -1500,11 +1500,11 @@ namespace bgfx
vertex->m_abgr = abgr;
}
s_renderCtx.m_vertexBuffers[m_vb->handle.idx].update(0, 4*m_decl.m_stride, m_vb->data);
s_renderCtx->m_vertexBuffers[m_vb->handle.idx].update(0, 4*m_decl.m_stride, m_vb->data);
deviceCtx->IASetVertexBuffers(0, 1, &vb.m_ptr, &stride, &offset);
s_renderCtx.setInputLayout(vertexDecl, program, 0);
s_renderCtx->setInputLayout(vertexDecl, program, 0);
IndexBuffer& ib = s_renderCtx.m_indexBuffers[m_ib.idx];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[m_ib.idx];
deviceCtx->IASetIndexBuffer(ib.m_ptr, DXGI_FORMAT_R16_UINT, 0);
deviceCtx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@@ -1539,7 +1539,7 @@ namespace bgfx
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
DX_CHECK(s_renderCtx.m_device->CreateBuffer(&desc, NULL, &m_buffer) );
DX_CHECK(s_renderCtx->m_device->CreateBuffer(&desc, NULL, &m_buffer) );
}
m_numPredefined = 0;
@@ -1588,7 +1588,7 @@ namespace bgfx
}
else
{
const UniformInfo* info = s_renderCtx.m_uniformReg.find(name);
const UniformInfo* info = s_renderCtx->m_uniformReg.find(name);
UniformBuffer* uniform = info != NULL ? (UniformBuffer*)info->m_data : NULL;
if (NULL != uniform)
@@ -1620,7 +1620,7 @@ namespace bgfx
if (_fragment)
{
DX_CHECK(s_renderCtx.m_device->CreatePixelShader(code, shaderSize, NULL, (ID3D11PixelShader**)&m_ptr) );
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.");
}
else
@@ -1629,14 +1629,14 @@ namespace bgfx
m_code = alloc(shaderSize);
memcpy(m_code->data, code, shaderSize);
DX_CHECK(s_renderCtx.m_device->CreateVertexShader(code, shaderSize, NULL, (ID3D11VertexShader**)&m_ptr) );
DX_CHECK(s_renderCtx->m_device->CreateVertexShader(code, shaderSize, NULL, (ID3D11VertexShader**)&m_ptr) );
BGFX_FATAL(NULL != m_ptr, bgfx::Fatal::InvalidShader, "Failed to create vertex shader.");
}
}
void Texture::create(const Memory* _mem, uint32_t _flags)
{
m_sampler = s_renderCtx.getSamplerState(_flags);
m_sampler = s_renderCtx->getSamplerState(_flags);
ImageContainer imageContainer;
@@ -1757,7 +1757,7 @@ namespace bgfx
srvd.Texture2D.MipLevels = imageContainer.m_numMips;
}
DX_CHECK(s_renderCtx.m_device->CreateTexture2D(&desc, kk == 0 ? NULL : srd, &m_texture2d) );
DX_CHECK(s_renderCtx->m_device->CreateTexture2D(&desc, kk == 0 ? NULL : srd, &m_texture2d) );
}
break;
@@ -1777,12 +1777,12 @@ namespace bgfx
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
srvd.Texture3D.MipLevels = imageContainer.m_numMips;
DX_CHECK(s_renderCtx.m_device->CreateTexture3D(&desc, kk == 0 ? NULL : srd, &m_texture3d) );
DX_CHECK(s_renderCtx->m_device->CreateTexture3D(&desc, kk == 0 ? NULL : srd, &m_texture3d) );
}
break;
}
DX_CHECK(s_renderCtx.m_device->CreateShaderResourceView(m_ptr, &srvd, &m_srv) );
DX_CHECK(s_renderCtx->m_device->CreateShaderResourceView(m_ptr, &srvd, &m_srv) );
if (convert
&& 0 != kk)
@@ -1808,17 +1808,17 @@ namespace bgfx
void Texture::commit(uint8_t _stage, uint32_t _flags)
{
TextureStage& ts = s_renderCtx.m_textureStage;
TextureStage& ts = s_renderCtx->m_textureStage;
ts.m_srv[_stage] = m_srv;
ts.m_sampler[_stage] = 0 == (BGFX_SAMPLER_DEFAULT_FLAGS & _flags)
? s_renderCtx.getSamplerState(_flags)
? s_renderCtx->getSamplerState(_flags)
: m_sampler
;
}
void Texture::update(uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, const Memory* _mem)
{
ID3D11DeviceContext* deviceCtx = s_renderCtx.m_deviceCtx;
ID3D11DeviceContext* deviceCtx = s_renderCtx->m_deviceCtx;
D3D11_BOX box;
box.left = _rect.m_x;
@@ -1875,9 +1875,9 @@ namespace bgfx
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
DX_CHECK(s_renderCtx.m_device->CreateTexture2D(&desc, NULL, &m_colorTexture) );
DX_CHECK(s_renderCtx.m_device->CreateRenderTargetView(m_colorTexture, NULL, &m_rtv) );
DX_CHECK(s_renderCtx.m_device->CreateShaderResourceView(m_colorTexture, NULL, &m_srv) );
DX_CHECK(s_renderCtx->m_device->CreateTexture2D(&desc, NULL, &m_colorTexture) );
DX_CHECK(s_renderCtx->m_device->CreateRenderTargetView(m_colorTexture, NULL, &m_rtv) );
DX_CHECK(s_renderCtx->m_device->CreateShaderResourceView(m_colorTexture, NULL, &m_srv) );
if (0 < depthFormat)
{
@@ -1894,12 +1894,12 @@ namespace bgfx
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
DX_CHECK(s_renderCtx.m_device->CreateTexture2D(&desc, NULL, &m_depthTexture) );
DX_CHECK(s_renderCtx.m_device->CreateDepthStencilView(m_depthTexture, NULL, &m_dsv) );
// DX_CHECK(s_renderCtx.m_device->CreateShaderResourceView(m_depthTexture, NULL, &m_srv) );
DX_CHECK(s_renderCtx->m_device->CreateTexture2D(&desc, NULL, &m_depthTexture) );
DX_CHECK(s_renderCtx->m_device->CreateDepthStencilView(m_depthTexture, NULL, &m_dsv) );
// DX_CHECK(s_renderCtx->m_device->CreateShaderResourceView(m_depthTexture, NULL, &m_srv) );
}
m_sampler = s_renderCtx.getSamplerState(_textureFlags);
m_sampler = s_renderCtx->getSamplerState(_textureFlags);
}
void RenderTarget::destroy()
@@ -1915,10 +1915,10 @@ namespace bgfx
void RenderTarget::commit(uint8_t _stage, uint32_t _flags)
{
TextureStage& ts = s_renderCtx.m_textureStage;
TextureStage& ts = s_renderCtx->m_textureStage;
ts.m_srv[_stage] = m_srv;
ts.m_sampler[_stage] = 0 == (BGFX_SAMPLER_DEFAULT_FLAGS & _flags)
? s_renderCtx.getSamplerState(_flags)
? s_renderCtx->getSamplerState(_flags)
: m_sampler
;
}
@@ -1939,7 +1939,7 @@ namespace bgfx
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
DX_CHECK(s_renderCtx.m_device->CreateBuffer(&desc, NULL, &m_ptr) );
DX_CHECK(s_renderCtx->m_device->CreateBuffer(&desc, NULL, &m_ptr) );
}
void UniformBuffer::destroy()
@@ -1955,32 +1955,38 @@ namespace bgfx
void Context::flip()
{
s_renderCtx.flip();
if (NULL != s_renderCtx)
{
s_renderCtx->flip();
}
}
void Context::rendererInit()
{
s_renderCtx.init();
s_renderCtx = BX_NEW(g_allocator, RendererContext);
s_renderCtx->init();
}
void Context::rendererShutdown()
{
s_renderCtx.shutdown();
s_renderCtx->shutdown();
BX_DELETE(g_allocator, s_renderCtx);
s_renderCtx = NULL;
}
void Context::rendererCreateIndexBuffer(IndexBufferHandle _handle, Memory* _mem)
{
s_renderCtx.m_indexBuffers[_handle.idx].create(_mem->size, _mem->data);
s_renderCtx->m_indexBuffers[_handle.idx].create(_mem->size, _mem->data);
}
void Context::rendererDestroyIndexBuffer(IndexBufferHandle _handle)
{
s_renderCtx.m_indexBuffers[_handle.idx].destroy();
s_renderCtx->m_indexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl)
{
VertexDecl& decl = s_renderCtx.m_vertexDecls[_handle.idx];
VertexDecl& decl = s_renderCtx->m_vertexDecls[_handle.idx];
memcpy(&decl, &_decl, sizeof(VertexDecl) );
dump(decl);
}
@@ -1991,78 +1997,78 @@ namespace bgfx
void Context::rendererCreateVertexBuffer(VertexBufferHandle _handle, Memory* _mem, VertexDeclHandle _declHandle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle);
s_renderCtx->m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle);
}
void Context::rendererDestroyVertexBuffer(VertexBufferHandle _handle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].destroy();
s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _size)
{
s_renderCtx.m_indexBuffers[_handle.idx].create(_size, NULL);
s_renderCtx->m_indexBuffers[_handle.idx].create(_size, NULL);
}
void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{
s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
s_renderCtx->m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
}
void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle)
{
s_renderCtx.m_indexBuffers[_handle.idx].destroy();
s_renderCtx->m_indexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _size)
{
VertexDeclHandle decl = BGFX_INVALID_HANDLE;
s_renderCtx.m_vertexBuffers[_handle.idx].create(_size, NULL, decl);
s_renderCtx->m_vertexBuffers[_handle.idx].create(_size, NULL, decl);
}
void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{
s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
s_renderCtx->m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
}
void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].destroy();
s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem)
{
s_renderCtx.m_vertexShaders[_handle.idx].create(false, _mem);
s_renderCtx->m_vertexShaders[_handle.idx].create(false, _mem);
}
void Context::rendererDestroyVertexShader(VertexShaderHandle _handle)
{
s_renderCtx.m_vertexShaders[_handle.idx].destroy();
s_renderCtx->m_vertexShaders[_handle.idx].destroy();
}
void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem)
{
s_renderCtx.m_fragmentShaders[_handle.idx].create(true, _mem);
s_renderCtx->m_fragmentShaders[_handle.idx].create(true, _mem);
}
void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle)
{
s_renderCtx.m_fragmentShaders[_handle.idx].destroy();
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_vertexShaders[_vsh.idx], s_renderCtx->m_fragmentShaders[_fsh.idx]);
}
void Context::rendererDestroyProgram(FragmentShaderHandle _handle)
{
s_renderCtx.m_program[_handle.idx].destroy();
s_renderCtx->m_program[_handle.idx].destroy();
}
void Context::rendererCreateTexture(TextureHandle _handle, Memory* _mem, uint32_t _flags)
{
s_renderCtx.m_textures[_handle.idx].create(_mem, _flags);
s_renderCtx->m_textures[_handle.idx].create(_mem, _flags);
}
void Context::rendererUpdateTextureBegin(TextureHandle /*_handle*/, uint8_t /*_side*/, uint8_t /*_mip*/)
@@ -2071,7 +2077,7 @@ namespace bgfx
void Context::rendererUpdateTexture(TextureHandle _handle, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, const Memory* _mem)
{
s_renderCtx.m_textures[_handle.idx].update(_side, _mip, _rect, _z, _depth, _mem);
s_renderCtx->m_textures[_handle.idx].update(_side, _mip, _rect, _z, _depth, _mem);
}
void Context::rendererUpdateTextureEnd()
@@ -2080,33 +2086,33 @@ namespace bgfx
void Context::rendererDestroyTexture(TextureHandle _handle)
{
s_renderCtx.m_textures[_handle.idx].destroy();
s_renderCtx->m_textures[_handle.idx].destroy();
}
void Context::rendererCreateRenderTarget(RenderTargetHandle _handle, uint16_t _width, uint16_t _height, uint32_t _flags, uint32_t _textureFlags)
{
s_renderCtx.m_renderTargets[_handle.idx].create(_width, _height, _flags, _textureFlags);
s_renderCtx->m_renderTargets[_handle.idx].create(_width, _height, _flags, _textureFlags);
}
void Context::rendererDestroyRenderTarget(RenderTargetHandle _handle)
{
s_renderCtx.m_renderTargets[_handle.idx].destroy();
s_renderCtx->m_renderTargets[_handle.idx].destroy();
}
void Context::rendererCreateUniform(UniformHandle _handle, UniformType::Enum _type, uint16_t _num, const char* _name)
{
s_renderCtx.m_uniforms[_handle.idx].create(_type, _num);
s_renderCtx.m_uniformReg.add(_name, &s_renderCtx.m_uniforms[_handle.idx]);
s_renderCtx->m_uniforms[_handle.idx].create(_type, _num);
s_renderCtx->m_uniformReg.add(_name, &s_renderCtx->m_uniforms[_handle.idx]);
}
void Context::rendererDestroyUniform(UniformHandle _handle)
{
s_renderCtx.m_uniforms[_handle.idx].destroy();
s_renderCtx->m_uniforms[_handle.idx].destroy();
}
void Context::rendererSaveScreenShot(const char* _filePath)
{
s_renderCtx.saveScreenShot(_filePath);
s_renderCtx->saveScreenShot(_filePath);
}
void Context::rendererUpdateViewName(uint8_t _id, const char* _name)
@@ -2116,7 +2122,7 @@ namespace bgfx
void Context::rendererUpdateUniform(uint16_t _loc, const void* _data, uint32_t _size)
{
memcpy(s_renderCtx.m_uniforms[_loc].m_data, _data, _size);
memcpy(s_renderCtx->m_uniforms[_loc].m_data, _data, _size);
}
void Context::rendererSetMarker(const char* _marker, uint32_t _size)
@@ -2134,9 +2140,9 @@ namespace bgfx
{
PIX_BEGINEVENT(D3DCOLOR_RGBA(0xff, 0x00, 0x00, 0xff), L"rendererSubmit");
ID3D11DeviceContext* deviceCtx = s_renderCtx.m_deviceCtx;
ID3D11DeviceContext* deviceCtx = s_renderCtx->m_deviceCtx;
s_renderCtx.updateResolution(m_render->m_resolution);
s_renderCtx->updateResolution(m_render->m_resolution);
int64_t elapsed = -bx::getHPCounter();
int64_t captureElapsed = 0;
@@ -2144,13 +2150,13 @@ namespace bgfx
if (0 < m_render->m_iboffset)
{
TransientIndexBuffer* ib = m_render->m_transientIb;
s_renderCtx.m_indexBuffers[ib->handle.idx].update(0, m_render->m_iboffset, ib->data);
s_renderCtx->m_indexBuffers[ib->handle.idx].update(0, m_render->m_iboffset, ib->data);
}
if (0 < m_render->m_vboffset)
{
TransientVertexBuffer* vb = m_render->m_transientVb;
s_renderCtx.m_vertexBuffers[vb->handle.idx].update(0, m_render->m_vboffset, vb->data);
s_renderCtx->m_vertexBuffers[vb->handle.idx].update(0, m_render->m_vboffset, vb->data);
}
m_render->sort();
@@ -2168,7 +2174,7 @@ namespace bgfx
bool wireframe = !!(m_render->m_debug&BGFX_DEBUG_WIREFRAME);
bool scissorEnabled = false;
s_renderCtx.setDebugWireframe(wireframe);
s_renderCtx->setDebugWireframe(wireframe);
uint16_t programIdx = invalidHandle;
SortKey key;
@@ -2220,7 +2226,7 @@ namespace bgfx
if (m_render->m_rt[view].idx != rt.idx)
{
rt = m_render->m_rt[view];
s_renderCtx.setRenderTarget(rt);
s_renderCtx->setRenderTarget(rt);
}
const Rect& rect = m_render->m_rect[view];
@@ -2243,8 +2249,8 @@ namespace bgfx
m_clearQuad.clear(rect, clear);
}
s_renderCtx.setBlendState(newFlags);
s_renderCtx.setDepthStencilState(newFlags, packStencil(BGFX_STENCIL_DEFAULT, BGFX_STENCIL_DEFAULT) );
s_renderCtx->setBlendState(newFlags);
s_renderCtx->setDepthStencilState(newFlags, packStencil(BGFX_STENCIL_DEFAULT, BGFX_STENCIL_DEFAULT) );
uint8_t primIndex = uint8_t( (newFlags&BGFX_STATE_PT_MASK)>>BGFX_STATE_PT_SHIFT);
if (primType != s_primType[primIndex])
@@ -2286,13 +2292,13 @@ namespace bgfx
deviceCtx->RSSetScissorRects(1, &rc);
}
s_renderCtx.setRasterizerState(newFlags, wireframe, scissorEnabled);
s_renderCtx->setRasterizerState(newFlags, wireframe, scissorEnabled);
}
if ( (BGFX_STATE_DEPTH_WRITE|BGFX_STATE_DEPTH_TEST_MASK) & changedFlags
|| 0 != changedStencil)
{
s_renderCtx.setDepthStencilState(newFlags, newStencil);
s_renderCtx->setDepthStencilState(newFlags, newStencil);
}
if ( (0
@@ -2309,12 +2315,12 @@ namespace bgfx
{
if ( (BGFX_STATE_BLEND_MASK|BGFX_STATE_BLEND_EQUATION_MASK|BGFX_STATE_ALPHA_WRITE|BGFX_STATE_RGB_WRITE) & changedFlags)
{
s_renderCtx.setBlendState(newFlags, state.m_rgba);
s_renderCtx->setBlendState(newFlags, state.m_rgba);
}
if ( (BGFX_STATE_CULL_MASK|BGFX_STATE_MSAA) & changedFlags)
{
s_renderCtx.setRasterizerState(newFlags, wireframe, scissorEnabled);
s_renderCtx->setRasterizerState(newFlags, wireframe, scissorEnabled);
}
if (BGFX_STATE_ALPHA_REF_MASK & changedFlags)
@@ -2342,15 +2348,15 @@ namespace bgfx
if (invalidHandle == programIdx)
{
s_renderCtx.m_currentProgram = NULL;
s_renderCtx->m_currentProgram = NULL;
deviceCtx->VSSetShader(NULL, 0, 0);
deviceCtx->PSSetShader(NULL, 0, 0);
}
else
{
Program& program = s_renderCtx.m_program[programIdx];
s_renderCtx.m_currentProgram = &program;
Program& program = s_renderCtx->m_program[programIdx];
s_renderCtx->m_currentProgram = &program;
deviceCtx->VSSetShader( (ID3D11VertexShader*)program.m_vsh->m_ptr, NULL, 0);
deviceCtx->VSSetConstantBuffers(0, 1, &program.m_vsh->m_buffer);
@@ -2365,7 +2371,7 @@ namespace bgfx
if (invalidHandle != programIdx)
{
Program& program = s_renderCtx.m_program[programIdx];
Program& program = s_renderCtx->m_program[programIdx];
if (constantsChanged)
{
@@ -2386,7 +2392,7 @@ namespace bgfx
rect[2] = m_render->m_rect[view].m_width;
rect[3] = m_render->m_rect[view].m_height;
s_renderCtx.setShaderConstant(flags, predefined.m_loc, &rect[0], 1);
s_renderCtx->setShaderConstant(flags, predefined.m_loc, &rect[0], 1);
}
break;
@@ -2396,26 +2402,26 @@ namespace bgfx
rect[0] = 1.0f/float(m_render->m_rect[view].m_width);
rect[1] = 1.0f/float(m_render->m_rect[view].m_height);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, &rect[0], 1);
s_renderCtx->setShaderConstant(flags, predefined.m_loc, &rect[0], 1);
}
break;
case PredefinedUniform::View:
{
s_renderCtx.setShaderConstant(flags, predefined.m_loc, m_render->m_view[view].val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstant(flags, predefined.m_loc, m_render->m_view[view].val, bx::uint32_min(4, predefined.m_count) );
}
break;
case PredefinedUniform::ViewProj:
{
s_renderCtx.setShaderConstant(flags, predefined.m_loc, viewProj[view].val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstant(flags, predefined.m_loc, viewProj[view].val, bx::uint32_min(4, predefined.m_count) );
}
break;
case PredefinedUniform::Model:
{
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
s_renderCtx.setShaderConstant(flags, predefined.m_loc, model.val, bx::uint32_min(state.m_num*4, predefined.m_count) );
s_renderCtx->setShaderConstant(flags, predefined.m_loc, model.val, bx::uint32_min(state.m_num*4, predefined.m_count) );
}
break;
@@ -2424,7 +2430,7 @@ namespace bgfx
Matrix4 modelView;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelView.val, model.val, m_render->m_view[view].val);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelView.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstant(flags, predefined.m_loc, modelView.val, bx::uint32_min(4, predefined.m_count) );
}
break;
@@ -2433,7 +2439,7 @@ namespace bgfx
Matrix4 modelViewProj;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelViewProj.val, model.val, viewProj[view].val);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstant(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
}
break;
@@ -2456,7 +2462,7 @@ namespace bgfx
Matrix4 modelViewProj;
mtxMul(modelViewProj.val, model.val, viewProjBias.val);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstant(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
}
break;
@@ -2474,13 +2480,13 @@ namespace bgfx
Matrix4 viewProjBias;
mtxMul(viewProjBias.val, viewProj[other].val, s_bias);
s_renderCtx.setShaderConstant(flags, predefined.m_loc, viewProjBias.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstant(flags, predefined.m_loc, viewProjBias.val, bx::uint32_min(4, predefined.m_count) );
}
break;
case PredefinedUniform::AlphaRef:
{
s_renderCtx.setShaderConstant(flags, predefined.m_loc, &alphaRef, 1);
s_renderCtx->setShaderConstant(flags, predefined.m_loc, &alphaRef, 1);
}
break;
@@ -2493,7 +2499,7 @@ namespace bgfx
if (constantsChanged
|| program.m_numPredefined > 0)
{
s_renderCtx.commitShaderConstants();
s_renderCtx->commitShaderConstants();
}
}
@@ -2515,29 +2521,29 @@ namespace bgfx
{
case BGFX_SAMPLER_TEXTURE:
{
Texture& texture = s_renderCtx.m_textures[sampler.m_idx];
Texture& texture = s_renderCtx->m_textures[sampler.m_idx];
texture.commit(stage, sampler.m_flags);
}
break;
case BGFX_SAMPLER_RENDERTARGET_COLOR:
{
RenderTarget& rt = s_renderCtx.m_renderTargets[sampler.m_idx];
RenderTarget& rt = s_renderCtx->m_renderTargets[sampler.m_idx];
rt.commit(stage, sampler.m_flags);
}
break;
case BGFX_SAMPLER_RENDERTARGET_DEPTH:
{
// id = s_renderCtx.m_renderTargets[sampler.m_idx].m_depth.m_id;
// id = s_renderCtx->m_renderTargets[sampler.m_idx].m_depth.m_id;
}
break;
}
}
else
{
s_renderCtx.m_textureStage.m_srv[stage] = NULL;
s_renderCtx.m_textureStage.m_sampler[stage] = NULL;
s_renderCtx->m_textureStage.m_srv[stage] = NULL;
s_renderCtx->m_textureStage.m_sampler[stage] = NULL;
}
++changes;
@@ -2549,7 +2555,7 @@ namespace bgfx
if (0 < changes)
{
s_renderCtx.commitTextureStage();
s_renderCtx->commitTextureStage();
}
}
@@ -2567,25 +2573,25 @@ namespace bgfx
uint16_t handle = state.m_vertexBuffer.idx;
if (invalidHandle != handle)
{
const VertexBuffer& vb = s_renderCtx.m_vertexBuffers[handle];
const VertexBuffer& vb = s_renderCtx->m_vertexBuffers[handle];
uint16_t decl = vb.m_decl.idx == invalidHandle ? state.m_vertexDecl.idx : vb.m_decl.idx;
const VertexDecl& vertexDecl = s_renderCtx.m_vertexDecls[decl];
const VertexDecl& vertexDecl = s_renderCtx->m_vertexDecls[decl];
uint32_t stride = vertexDecl.m_stride;
uint32_t offset = 0;
deviceCtx->IASetVertexBuffers(0, 1, &vb.m_ptr, &stride, &offset);
if (invalidHandle != state.m_instanceDataBuffer.idx)
{
const VertexBuffer& inst = s_renderCtx.m_vertexBuffers[state.m_instanceDataBuffer.idx];
const VertexBuffer& inst = s_renderCtx->m_vertexBuffers[state.m_instanceDataBuffer.idx];
uint32_t instStride = state.m_instanceDataStride;
deviceCtx->IASetVertexBuffers(1, 1, &inst.m_ptr, &instStride, &state.m_instanceDataOffset);
s_renderCtx.setInputLayout(vertexDecl, s_renderCtx.m_program[programIdx], state.m_instanceDataStride/16);
s_renderCtx->setInputLayout(vertexDecl, s_renderCtx->m_program[programIdx], state.m_instanceDataStride/16);
}
else
{
deviceCtx->IASetVertexBuffers(1, 0, NULL, NULL, NULL);
s_renderCtx.setInputLayout(vertexDecl, s_renderCtx.m_program[programIdx], 0);
s_renderCtx->setInputLayout(vertexDecl, s_renderCtx->m_program[programIdx], 0);
}
}
else
@@ -2601,7 +2607,7 @@ namespace bgfx
uint16_t handle = state.m_indexBuffer.idx;
if (invalidHandle != handle)
{
const IndexBuffer& ib = s_renderCtx.m_indexBuffers[handle];
const IndexBuffer& ib = s_renderCtx->m_indexBuffers[handle];
deviceCtx->IASetIndexBuffer(ib.m_ptr, DXGI_FORMAT_R16_UINT, 0);
}
else
@@ -2615,9 +2621,9 @@ namespace bgfx
uint32_t numVertices = state.m_numVertices;
if (UINT32_C(0xffffffff) == numVertices)
{
const VertexBuffer& vb = s_renderCtx.m_vertexBuffers[currentState.m_vertexBuffer.idx];
const VertexBuffer& vb = s_renderCtx->m_vertexBuffers[currentState.m_vertexBuffer.idx];
uint16_t decl = vb.m_decl.idx == invalidHandle ? state.m_vertexDecl.idx : vb.m_decl.idx;
const VertexDecl& vertexDecl = s_renderCtx.m_vertexDecls[decl];
const VertexDecl& vertexDecl = s_renderCtx->m_vertexDecls[decl];
numVertices = vb.m_size/vertexDecl.m_stride;
}
@@ -2630,7 +2636,7 @@ namespace bgfx
{
if (UINT32_MAX == state.m_numIndices)
{
numIndices = s_renderCtx.m_indexBuffers[state.m_indexBuffer.idx].m_size/2;
numIndices = s_renderCtx->m_indexBuffers[state.m_indexBuffer.idx].m_size/2;
numPrimsSubmitted = numIndices/primNumVerts;
numInstances = state.m_numInstances;
numPrimsRendered = numPrimsSubmitted*state.m_numInstances;
@@ -2680,7 +2686,7 @@ namespace bgfx
if (0 < m_render->m_num)
{
captureElapsed = -bx::getHPCounter();
s_renderCtx.capture();
s_renderCtx->capture();
captureElapsed += bx::getHPCounter();
}
}
@@ -2701,7 +2707,7 @@ namespace bgfx
{
PIX_BEGINEVENT(D3DCOLOR_RGBA(0x40, 0x40, 0x40, 0xff), L"debugstats");
TextVideoMem& tvm = s_renderCtx.m_textVideoMem;
TextVideoMem& tvm = s_renderCtx->m_textVideoMem;
static int64_t next = now;
@@ -2715,7 +2721,7 @@ namespace bgfx
uint16_t pos = 0;
tvm.printf(0, pos++, BGFX_CONFIG_DEBUG ? 0x89 : 0x8f, " " BGFX_RENDERER_NAME " ");
const DXGI_ADAPTER_DESC& desc = s_renderCtx.m_adapterDesc;
const DXGI_ADAPTER_DESC& desc = s_renderCtx->m_adapterDesc;
char description[BX_COUNTOF(desc.Description)];
wcstombs(description, desc.Description, BX_COUNTOF(desc.Description) );
tvm.printf(0, pos++, 0x0f, " Device: %s", description);

11
src/renderer_d3d11.h
View File

@@ -134,7 +134,10 @@ namespace bgfx
: m_ptr(NULL)
, m_code(NULL)
, m_buffer(NULL)
, m_constantBuffer(NULL)
, m_hash(0)
, m_numUniforms(0)
, m_numPredefined(0)
{
}
@@ -143,8 +146,12 @@ namespace bgfx
void destroy()
{
ConstantBuffer::destroy(m_constantBuffer);
m_constantBuffer = NULL;
if (NULL != m_constantBuffer)
{
ConstantBuffer::destroy(m_constantBuffer);
m_constantBuffer = NULL;
}
m_numPredefined = 0;
if (NULL != m_buffer)

246
src/renderer_d3d9.cpp
View File

@@ -232,7 +232,14 @@ namespace bgfx
struct RendererContext
{
RendererContext()
: m_flags(BGFX_RESET_NONE)
: m_d3d9(NULL)
, m_device(NULL)
, m_backBufferColor(NULL)
, m_backBufferDepthStencil(NULL)
, m_captureTexture(NULL)
, m_captureSurface(NULL)
, m_captureResolve(NULL)
, m_flags(BGFX_RESET_NONE)
, m_initialized(false)
, m_amd(false)
, m_nvidia(false)
@@ -1010,7 +1017,7 @@ namespace bgfx
bool m_rtMsaa;
};
static RendererContext s_renderCtx;
static RendererContext* s_renderCtx;
void IndexBuffer::create(uint32_t _size, void* _data)
{
@@ -1018,7 +1025,7 @@ namespace bgfx
m_dynamic = NULL == _data;
uint32_t usage = D3DUSAGE_WRITEONLY;
D3DPOOL pool = s_renderCtx.m_pool;
D3DPOOL pool = s_renderCtx->m_pool;
if (m_dynamic)
{
@@ -1026,7 +1033,7 @@ namespace bgfx
pool = D3DPOOL_DEFAULT;
}
DX_CHECK(s_renderCtx.m_device->CreateIndexBuffer(m_size
DX_CHECK(s_renderCtx->m_device->CreateIndexBuffer(m_size
, usage
, D3DFMT_INDEX16
, pool
@@ -1052,7 +1059,7 @@ namespace bgfx
{
if (m_dynamic)
{
DX_CHECK(s_renderCtx.m_device->CreateIndexBuffer(m_size
DX_CHECK(s_renderCtx->m_device->CreateIndexBuffer(m_size
, D3DUSAGE_WRITEONLY|D3DUSAGE_DYNAMIC
, D3DFMT_INDEX16
, D3DPOOL_DEFAULT
@@ -1069,7 +1076,7 @@ namespace bgfx
m_dynamic = NULL == _data;
uint32_t usage = D3DUSAGE_WRITEONLY;
D3DPOOL pool = s_renderCtx.m_pool;
D3DPOOL pool = s_renderCtx->m_pool;
if (m_dynamic)
{
@@ -1077,7 +1084,7 @@ namespace bgfx
pool = D3DPOOL_DEFAULT;
}
DX_CHECK(s_renderCtx.m_device->CreateVertexBuffer(m_size
DX_CHECK(s_renderCtx->m_device->CreateVertexBuffer(m_size
, usage
, 0
, pool
@@ -1103,7 +1110,7 @@ namespace bgfx
{
if (m_dynamic)
{
DX_CHECK(s_renderCtx.m_device->CreateVertexBuffer(m_size
DX_CHECK(s_renderCtx->m_device->CreateVertexBuffer(m_size
, D3DUSAGE_WRITEONLY|D3DUSAGE_DYNAMIC
, 0
, D3DPOOL_DEFAULT
@@ -1204,7 +1211,7 @@ namespace bgfx
memcpy(elem, &s_attrib[Attrib::Count], sizeof(D3DVERTEXELEMENT9) );
IDirect3DVertexDeclaration9* ptr;
DX_CHECK(s_renderCtx.m_device->CreateVertexDeclaration(vertexElements, &ptr) );
DX_CHECK(s_renderCtx->m_device->CreateVertexDeclaration(vertexElements, &ptr) );
return ptr;
}
@@ -1273,7 +1280,7 @@ namespace bgfx
}
else
{
const UniformInfo* info = s_renderCtx.m_uniformReg.find(name);
const UniformInfo* info = s_renderCtx->m_uniformReg.find(name);
BX_CHECK(NULL != info, "User defined uniform '%s' is not found, it won't be set.", name);
if (NULL != info)
{
@@ -1304,12 +1311,12 @@ namespace bgfx
if (_fragment)
{
DX_CHECK(s_renderCtx.m_device->CreatePixelShader(code, (IDirect3DPixelShader9**)&m_ptr) );
DX_CHECK(s_renderCtx->m_device->CreatePixelShader(code, (IDirect3DPixelShader9**)&m_ptr) );
BGFX_FATAL(NULL != m_ptr, bgfx::Fatal::InvalidShader, "Failed to create fragment shader.");
}
else
{
DX_CHECK(s_renderCtx.m_device->CreateVertexShader(code, (IDirect3DVertexShader9**)&m_ptr) );
DX_CHECK(s_renderCtx->m_device->CreateVertexShader(code, (IDirect3DVertexShader9**)&m_ptr) );
BGFX_FATAL(NULL != m_ptr, bgfx::Fatal::InvalidShader, "Failed to create vertex shader.");
}
}
@@ -1318,12 +1325,12 @@ namespace bgfx
{
m_type = Texture2D;
DX_CHECK(s_renderCtx.m_device->CreateTexture(_width
DX_CHECK(s_renderCtx->m_device->CreateTexture(_width
, _height
, _numMips
, 0
, _fmt
, s_renderCtx.m_pool
, s_renderCtx->m_pool
, &m_texture2d
, NULL
) );
@@ -1340,13 +1347,13 @@ namespace bgfx
{
m_type = Texture3D;
DX_CHECK(s_renderCtx.m_device->CreateVolumeTexture(_width
DX_CHECK(s_renderCtx->m_device->CreateVolumeTexture(_width
, _height
, _depth
, _numMips
, 0
, _fmt
, s_renderCtx.m_pool
, s_renderCtx->m_pool
, &m_texture3d
, NULL
) );
@@ -1364,11 +1371,11 @@ namespace bgfx
{
m_type = TextureCube;
DX_CHECK(s_renderCtx.m_device->CreateCubeTexture(_edge
DX_CHECK(s_renderCtx->m_device->CreateCubeTexture(_edge
, _numMips
, 0
, _fmt
, s_renderCtx.m_pool
, s_renderCtx->m_pool
, &m_textureCube
, NULL
) );
@@ -1631,17 +1638,17 @@ namespace bgfx
void Texture::updateBegin(uint8_t _side, uint8_t _mip)
{
uint32_t slicePitch;
s_renderCtx.m_updateTextureSide = _side;
s_renderCtx.m_updateTextureMip = _mip;
s_renderCtx.m_updateTextureBits = lock(_side, _mip, s_renderCtx.m_updateTexturePitch, slicePitch);
s_renderCtx->m_updateTextureSide = _side;
s_renderCtx->m_updateTextureMip = _mip;
s_renderCtx->m_updateTextureBits = lock(_side, _mip, s_renderCtx->m_updateTexturePitch, slicePitch);
}
void Texture::update(uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, const Memory* _mem)
{
uint32_t bpp = getBitsPerPixel(TextureFormat::Enum(m_textureFormat) );
uint32_t srcpitch = _rect.m_width*bpp/8;
uint32_t dstpitch = s_renderCtx.m_updateTexturePitch;
uint8_t* bits = s_renderCtx.m_updateTextureBits + _rect.m_y*dstpitch + _rect.m_x*bpp/8;
uint32_t dstpitch = s_renderCtx->m_updateTexturePitch;
uint8_t* bits = s_renderCtx->m_updateTextureBits + _rect.m_y*dstpitch + _rect.m_x*bpp/8;
const bool convert = m_textureFormat != m_requestedFormat;
@@ -1682,13 +1689,13 @@ namespace bgfx
void Texture::updateEnd()
{
unlock(s_renderCtx.m_updateTextureSide, s_renderCtx.m_updateTextureMip);
unlock(s_renderCtx->m_updateTextureSide, s_renderCtx->m_updateTextureMip);
}
void Texture::commit(uint8_t _stage, uint32_t _flags)
{
s_renderCtx.setSamplerState(_stage, 0 == (BGFX_SAMPLER_DEFAULT_FLAGS & _flags) ? _flags : m_flags);
DX_CHECK(s_renderCtx.m_device->SetTexture(_stage, m_ptr) );
s_renderCtx->setSamplerState(_stage, 0 == (BGFX_SAMPLER_DEFAULT_FLAGS & _flags) ? _flags : m_flags);
DX_CHECK(s_renderCtx->m_device->SetTexture(_stage, m_ptr) );
}
void RenderTarget::create(uint16_t _width, uint16_t _height, uint32_t _flags, uint32_t _textureFlags)
@@ -1717,7 +1724,7 @@ namespace bgfx
if (m_depthOnly)
{
DX_CHECK(s_renderCtx.m_device->CreateRenderTarget(1
DX_CHECK(s_renderCtx->m_device->CreateRenderTarget(1
, 1
, D3DFMT_R5G6B5
, D3DMULTISAMPLE_NONE
@@ -1729,7 +1736,7 @@ namespace bgfx
BGFX_FATAL(m_rt, Fatal::UnableToCreateRenderTarget, "Unable to create 1x1 render target.");
DX_CHECK(s_renderCtx.m_device->CreateTexture(m_width
DX_CHECK(s_renderCtx->m_device->CreateTexture(m_width
, m_height
, 1
, D3DUSAGE_DEPTHSTENCIL
@@ -1747,7 +1754,7 @@ namespace bgfx
{
if (D3DMULTISAMPLE_NONE != m_msaa.m_type)
{
DX_CHECK(s_renderCtx.m_device->CreateRenderTarget(m_width
DX_CHECK(s_renderCtx->m_device->CreateRenderTarget(m_width
, m_height
, s_colorFormat[colorFormat]
, m_msaa.m_type
@@ -1762,7 +1769,7 @@ namespace bgfx
if (0 < colorFormat)
{
DX_CHECK(s_renderCtx.m_device->CreateTexture(m_width
DX_CHECK(s_renderCtx->m_device->CreateTexture(m_width
, m_height
, 1
, D3DUSAGE_RENDERTARGET
@@ -1779,9 +1786,9 @@ namespace bgfx
if (0 < depthFormat)
{
DX_CHECK(s_renderCtx.m_device->CreateDepthStencilSurface(m_width
DX_CHECK(s_renderCtx->m_device->CreateDepthStencilSurface(m_width
, m_height
, s_depthFormat[depthFormat] // s_renderCtx.m_fmtDepth
, s_depthFormat[depthFormat] // s_renderCtx->m_fmtDepth
, m_msaa.m_type
, m_msaa.m_quality
, FALSE
@@ -1832,14 +1839,14 @@ namespace bgfx
void RenderTarget::commit(uint8_t _stage, uint32_t _textureFlags)
{
s_renderCtx.setSamplerState(_stage, 0 == (BGFX_SAMPLER_DEFAULT_FLAGS & _textureFlags) ? _textureFlags : m_textureFlags);
DX_CHECK(s_renderCtx.m_device->SetTexture(_stage, m_depthOnly ? m_depthTexture : m_colorTexture) );
s_renderCtx->setSamplerState(_stage, 0 == (BGFX_SAMPLER_DEFAULT_FLAGS & _textureFlags) ? _textureFlags : m_textureFlags);
DX_CHECK(s_renderCtx->m_device->SetTexture(_stage, m_depthOnly ? m_depthTexture : m_colorTexture) );
}
void RenderTarget::resolve()
{
#if BX_PLATFORM_WINDOWS
DX_CHECK(s_renderCtx.m_device->StretchRect(m_rt
DX_CHECK(s_renderCtx->m_device->StretchRect(m_rt
, NULL
, m_color
, NULL
@@ -1881,14 +1888,14 @@ namespace bgfx
case UniformType::_uniform: \
{ \
_type* value = (_type*)data; \
s_renderCtx.m_device->SetVertexShaderConstant##_dxsuffix(loc, value, num); \
s_renderCtx->m_device->SetVertexShaderConstant##_dxsuffix(loc, value, num); \
} \
break; \
\
case UniformType::_uniform|BGFX_UNIFORM_FRAGMENTBIT: \
{ \
_type* value = (_type*)data; \
s_renderCtx.m_device->SetPixelShaderConstant##_dxsuffix(loc, value, num); \
s_renderCtx->m_device->SetPixelShaderConstant##_dxsuffix(loc, value, num); \
} \
break
@@ -1919,11 +1926,11 @@ namespace bgfx
void TextVideoMemBlitter::setup()
{
uint32_t width = s_renderCtx.m_params.BackBufferWidth;
uint32_t height = s_renderCtx.m_params.BackBufferHeight;
uint32_t width = s_renderCtx->m_params.BackBufferWidth;
uint32_t height = s_renderCtx->m_params.BackBufferHeight;
RenderTargetHandle rt = BGFX_INVALID_HANDLE;
s_renderCtx.setRenderTarget(rt, false);
s_renderCtx->setRenderTarget(rt, false);
D3DVIEWPORT9 vp;
vp.X = 0;
@@ -1933,7 +1940,7 @@ namespace bgfx
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
IDirect3DDevice9* device = s_renderCtx.m_device;
IDirect3DDevice9* device = s_renderCtx->m_device;
DX_CHECK(device->SetViewport(&vp) );
DX_CHECK(device->SetRenderState(D3DRS_STENCILENABLE, FALSE) );
DX_CHECK(device->SetRenderState(D3DRS_ZENABLE, FALSE) );
@@ -1944,16 +1951,16 @@ namespace bgfx
DX_CHECK(device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_BLUE) );
DX_CHECK(device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID) );
Program& program = s_renderCtx.m_program[m_program.idx];
Program& program = s_renderCtx->m_program[m_program.idx];
device->SetVertexShader( (IDirect3DVertexShader9*)program.m_vsh->m_ptr);
device->SetPixelShader( (IDirect3DPixelShader9*)program.m_fsh->m_ptr);
VertexBuffer& vb = s_renderCtx.m_vertexBuffers[m_vb->handle.idx];
VertexDeclaration& vertexDecl = s_renderCtx.m_vertexDecls[m_vb->decl.idx];
VertexBuffer& vb = s_renderCtx->m_vertexBuffers[m_vb->handle.idx];
VertexDeclaration& vertexDecl = s_renderCtx->m_vertexDecls[m_vb->decl.idx];
DX_CHECK(device->SetStreamSource(0, vb.m_ptr, 0, vertexDecl.m_decl.m_stride) );
DX_CHECK(device->SetVertexDeclaration(vertexDecl.m_ptr) );
IndexBuffer& ib = s_renderCtx.m_indexBuffers[m_ib->handle.idx];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[m_ib->handle.idx];
DX_CHECK(device->SetIndices(ib.m_ptr) );
float proj[16];
@@ -1961,18 +1968,18 @@ namespace bgfx
PredefinedUniform& predefined = program.m_predefined[0];
uint8_t flags = predefined.m_type;
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, proj, 4);
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, proj, 4);
s_renderCtx.m_textures[m_texture.idx].commit(0);
s_renderCtx->m_textures[m_texture.idx].commit(0);
}
void TextVideoMemBlitter::render(uint32_t _numIndices)
{
uint32_t numVertices = _numIndices*4/6;
s_renderCtx.m_indexBuffers[m_ib->handle.idx].update(0, _numIndices*2, m_ib->data, true);
s_renderCtx.m_vertexBuffers[m_vb->handle.idx].update(0, numVertices*m_decl.m_stride, m_vb->data, true);
s_renderCtx->m_indexBuffers[m_ib->handle.idx].update(0, _numIndices*2, m_ib->data, true);
s_renderCtx->m_vertexBuffers[m_vb->handle.idx].update(0, numVertices*m_decl.m_stride, m_vb->data, true);
DX_CHECK(s_renderCtx.m_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST
DX_CHECK(s_renderCtx->m_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST
, 0
, 0
, numVertices
@@ -1983,145 +1990,150 @@ namespace bgfx
void Context::flip()
{
s_renderCtx.flip();
if (NULL != s_renderCtx)
{
s_renderCtx->flip();
}
}
void Context::rendererInit()
{
s_renderCtx.init();
s_renderCtx = BX_NEW(g_allocator, RendererContext);
s_renderCtx->init();
}
void Context::rendererShutdown()
{
s_renderCtx.shutdown();
s_renderCtx->shutdown();
BX_DELETE(g_allocator, s_renderCtx);
}
void Context::rendererCreateIndexBuffer(IndexBufferHandle _handle, Memory* _mem)
{
s_renderCtx.m_indexBuffers[_handle.idx].create(_mem->size, _mem->data);
s_renderCtx->m_indexBuffers[_handle.idx].create(_mem->size, _mem->data);
}
void Context::rendererDestroyIndexBuffer(IndexBufferHandle _handle)
{
s_renderCtx.m_indexBuffers[_handle.idx].destroy();
s_renderCtx->m_indexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl)
{
s_renderCtx.m_vertexDecls[_handle.idx].create(_decl);
s_renderCtx->m_vertexDecls[_handle.idx].create(_decl);
}
void Context::rendererDestroyVertexDecl(VertexDeclHandle _handle)
{
s_renderCtx.m_vertexDecls[_handle.idx].destroy();
s_renderCtx->m_vertexDecls[_handle.idx].destroy();
}
void Context::rendererCreateVertexBuffer(VertexBufferHandle _handle, Memory* _mem, VertexDeclHandle _declHandle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle);
s_renderCtx->m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle);
}
void Context::rendererDestroyVertexBuffer(VertexBufferHandle _handle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].destroy();
s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _size)
{
s_renderCtx.m_indexBuffers[_handle.idx].create(_size, NULL);
s_renderCtx->m_indexBuffers[_handle.idx].create(_size, NULL);
}
void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{
s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
s_renderCtx->m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
}
void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle)
{
s_renderCtx.m_indexBuffers[_handle.idx].destroy();
s_renderCtx->m_indexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _size)
{
VertexDeclHandle decl = BGFX_INVALID_HANDLE;
s_renderCtx.m_vertexBuffers[_handle.idx].create(_size, NULL, decl);
s_renderCtx->m_vertexBuffers[_handle.idx].create(_size, NULL, decl);
}
void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{
s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
s_renderCtx->m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
}
void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].destroy();
s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem)
{
s_renderCtx.m_vertexShaders[_handle.idx].create(false, _mem);
s_renderCtx->m_vertexShaders[_handle.idx].create(false, _mem);
}
void Context::rendererDestroyVertexShader(VertexShaderHandle _handle)
{
s_renderCtx.m_vertexShaders[_handle.idx].destroy();
s_renderCtx->m_vertexShaders[_handle.idx].destroy();
}
void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem)
{
s_renderCtx.m_fragmentShaders[_handle.idx].create(true, _mem);
s_renderCtx->m_fragmentShaders[_handle.idx].create(true, _mem);
}
void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle)
{
s_renderCtx.m_fragmentShaders[_handle.idx].destroy();
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_vertexShaders[_vsh.idx], s_renderCtx->m_fragmentShaders[_fsh.idx]);
}
void Context::rendererDestroyProgram(FragmentShaderHandle _handle)
{
s_renderCtx.m_program[_handle.idx].destroy();
s_renderCtx->m_program[_handle.idx].destroy();
}
void Context::rendererCreateTexture(TextureHandle _handle, Memory* _mem, uint32_t _flags)
{
s_renderCtx.m_textures[_handle.idx].create(_mem, _flags);
s_renderCtx->m_textures[_handle.idx].create(_mem, _flags);
}
void Context::rendererUpdateTextureBegin(TextureHandle _handle, uint8_t _side, uint8_t _mip)
{
s_renderCtx.m_updateTexture = &s_renderCtx.m_textures[_handle.idx];
s_renderCtx.m_updateTexture->updateBegin(_side, _mip);
s_renderCtx->m_updateTexture = &s_renderCtx->m_textures[_handle.idx];
s_renderCtx->m_updateTexture->updateBegin(_side, _mip);
}
void Context::rendererUpdateTexture(TextureHandle /*_handle*/, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, const Memory* _mem)
{
s_renderCtx.m_updateTexture->update(_side, _mip, _rect, _z, _depth, _mem);
s_renderCtx->m_updateTexture->update(_side, _mip, _rect, _z, _depth, _mem);
}
void Context::rendererUpdateTextureEnd()
{
s_renderCtx.m_updateTexture->updateEnd();
s_renderCtx.m_updateTexture = NULL;
s_renderCtx->m_updateTexture->updateEnd();
s_renderCtx->m_updateTexture = NULL;
}
void Context::rendererDestroyTexture(TextureHandle _handle)
{
s_renderCtx.m_textures[_handle.idx].destroy();
s_renderCtx->m_textures[_handle.idx].destroy();
}
void Context::rendererCreateRenderTarget(RenderTargetHandle _handle, uint16_t _width, uint16_t _height, uint32_t _flags, uint32_t _textureFlags)
{
s_renderCtx.m_renderTargets[_handle.idx].create(_width, _height, _flags, _textureFlags);
s_renderCtx->m_renderTargets[_handle.idx].create(_width, _height, _flags, _textureFlags);
}
void Context::rendererDestroyRenderTarget(RenderTargetHandle _handle)
{
s_renderCtx.m_renderTargets[_handle.idx].destroy();
s_renderCtx->m_renderTargets[_handle.idx].destroy();
}
void Context::rendererCreateUniform(UniformHandle _handle, UniformType::Enum _type, uint16_t _num, const char* _name)
@@ -2129,18 +2141,18 @@ namespace bgfx
uint32_t size = BX_ALIGN_16(g_uniformTypeSize[_type]*_num);
void* data = BX_ALLOC(g_allocator, size);
memset(data, 0, size);
s_renderCtx.m_uniforms[_handle.idx] = data;
s_renderCtx.m_uniformReg.add(_name, s_renderCtx.m_uniforms[_handle.idx]);
s_renderCtx->m_uniforms[_handle.idx] = data;
s_renderCtx->m_uniformReg.add(_name, s_renderCtx->m_uniforms[_handle.idx]);
}
void Context::rendererDestroyUniform(UniformHandle _handle)
{
BX_FREE(g_allocator, s_renderCtx.m_uniforms[_handle.idx]);
BX_FREE(g_allocator, s_renderCtx->m_uniforms[_handle.idx]);
}
void Context::rendererSaveScreenShot(const char* _filePath)
{
s_renderCtx.saveScreenShot(_filePath);
s_renderCtx->saveScreenShot(_filePath);
}
void Context::rendererUpdateViewName(uint8_t _id, const char* _name)
@@ -2150,7 +2162,7 @@ namespace bgfx
void Context::rendererUpdateUniform(uint16_t _loc, const void* _data, uint32_t _size)
{
memcpy(s_renderCtx.m_uniforms[_loc], _data, _size);
memcpy(s_renderCtx->m_uniforms[_loc], _data, _size);
}
void Context::rendererSetMarker(const char* _marker, uint32_t _size)
@@ -2166,11 +2178,11 @@ namespace bgfx
void Context::rendererSubmit()
{
IDirect3DDevice9* device = s_renderCtx.m_device;
IDirect3DDevice9* device = s_renderCtx->m_device;
PIX_BEGINEVENT(D3DCOLOR_RGBA(0xff, 0x00, 0x00, 0xff), L"rendererSubmit");
s_renderCtx.updateResolution(m_render->m_resolution);
s_renderCtx->updateResolution(m_render->m_resolution);
int64_t elapsed = -bx::getHPCounter();
int64_t captureElapsed = 0;
@@ -2180,13 +2192,13 @@ namespace bgfx
if (0 < m_render->m_iboffset)
{
TransientIndexBuffer* ib = m_render->m_transientIb;
s_renderCtx.m_indexBuffers[ib->handle.idx].update(0, m_render->m_iboffset, ib->data, true);
s_renderCtx->m_indexBuffers[ib->handle.idx].update(0, m_render->m_iboffset, ib->data, true);
}
if (0 < m_render->m_vboffset)
{
TransientVertexBuffer* vb = m_render->m_transientVb;
s_renderCtx.m_vertexBuffers[vb->handle.idx].update(0, m_render->m_vboffset, vb->data, true);
s_renderCtx->m_vertexBuffers[vb->handle.idx].update(0, m_render->m_vboffset, vb->data, true);
}
m_render->sort();
@@ -2220,7 +2232,7 @@ namespace bgfx
uint32_t statsNumInstances = 0;
uint32_t statsNumPrimsRendered = 0;
s_renderCtx.invalidateSamplerState();
s_renderCtx->invalidateSamplerState();
if (0 == (m_render->m_debug&BGFX_DEBUG_IFH) )
{
@@ -2255,7 +2267,7 @@ namespace bgfx
if (m_render->m_rt[view].idx != rt.idx)
{
rt = m_render->m_rt[view];
s_renderCtx.setRenderTarget(rt);
s_renderCtx->setRenderTarget(rt);
}
const Rect& rect = m_render->m_rect[view];
@@ -2515,7 +2527,7 @@ namespace bgfx
}
else
{
Program& program = s_renderCtx.m_program[programIdx];
Program& program = s_renderCtx->m_program[programIdx];
device->SetVertexShader( (IDirect3DVertexShader9*)program.m_vsh->m_ptr);
device->SetPixelShader( (IDirect3DPixelShader9*)program.m_fsh->m_ptr);
}
@@ -2526,7 +2538,7 @@ namespace bgfx
if (invalidHandle != programIdx)
{
Program& program = s_renderCtx.m_program[programIdx];
Program& program = s_renderCtx->m_program[programIdx];
if (constantsChanged)
{
@@ -2547,7 +2559,7 @@ namespace bgfx
rect[2] = m_render->m_rect[view].m_width;
rect[3] = m_render->m_rect[view].m_height;
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, &rect[0], 1);
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, &rect[0], 1);
}
break;
@@ -2557,26 +2569,26 @@ namespace bgfx
rect[0] = 1.0f/float(m_render->m_rect[view].m_width);
rect[1] = 1.0f/float(m_render->m_rect[view].m_height);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, &rect[0], 1);
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, &rect[0], 1);
}
break;
case PredefinedUniform::View:
{
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, m_render->m_view[view].val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, m_render->m_view[view].val, bx::uint32_min(4, predefined.m_count) );
}
break;
case PredefinedUniform::ViewProj:
{
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, viewProj[view].val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, viewProj[view].val, bx::uint32_min(4, predefined.m_count) );
}
break;
case PredefinedUniform::Model:
{
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, model.val, bx::uint32_min(state.m_num*4, predefined.m_count) );
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, model.val, bx::uint32_min(state.m_num*4, predefined.m_count) );
}
break;
@@ -2585,7 +2597,7 @@ namespace bgfx
Matrix4 modelView;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelView.val, model.val, m_render->m_view[view].val);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelView.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, modelView.val, bx::uint32_min(4, predefined.m_count) );
}
break;
@@ -2594,7 +2606,7 @@ namespace bgfx
Matrix4 modelViewProj;
const Matrix4& model = m_render->m_matrixCache.m_cache[state.m_matrix];
mtxMul(modelViewProj.val, model.val, viewProj[view].val);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
}
break;
@@ -2617,7 +2629,7 @@ namespace bgfx
Matrix4 modelViewProj;
mtxMul(modelViewProj.val, model.val, viewProjBias.val);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, modelViewProj.val, bx::uint32_min(4, predefined.m_count) );
}
break;
@@ -2635,13 +2647,13 @@ namespace bgfx
Matrix4 viewProjBias;
mtxMul(viewProjBias.val, viewProj[other].val, s_bias);
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, viewProjBias.val, bx::uint32_min(4, predefined.m_count) );
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, viewProjBias.val, bx::uint32_min(4, predefined.m_count) );
}
break;
case PredefinedUniform::AlphaRef:
{
s_renderCtx.setShaderConstantF(flags, predefined.m_loc, &alphaRef, 1);
s_renderCtx->setShaderConstantF(flags, predefined.m_loc, &alphaRef, 1);
}
break;
@@ -2668,15 +2680,15 @@ namespace bgfx
switch (sampler.m_flags&BGFX_SAMPLER_TYPE_MASK)
{
case BGFX_SAMPLER_TEXTURE:
s_renderCtx.m_textures[sampler.m_idx].commit(stage, sampler.m_flags);
s_renderCtx->m_textures[sampler.m_idx].commit(stage, sampler.m_flags);
break;
case BGFX_SAMPLER_RENDERTARGET_COLOR:
s_renderCtx.m_renderTargets[sampler.m_idx].commit(stage, sampler.m_flags);
s_renderCtx->m_renderTargets[sampler.m_idx].commit(stage, sampler.m_flags);
break;
case BGFX_SAMPLER_RENDERTARGET_DEPTH:
// id = s_renderCtx.m_renderTargets[sampler.m_idx].m_depth.m_id;
// id = s_renderCtx->m_renderTargets[sampler.m_idx].m_depth.m_id;
break;
}
}
@@ -2705,16 +2717,16 @@ namespace bgfx
uint16_t handle = state.m_vertexBuffer.idx;
if (invalidHandle != handle)
{
const VertexBuffer& vb = s_renderCtx.m_vertexBuffers[handle];
const VertexBuffer& vb = s_renderCtx->m_vertexBuffers[handle];
uint16_t decl = vb.m_decl.idx == invalidHandle ? state.m_vertexDecl.idx : vb.m_decl.idx;
const VertexDeclaration& vertexDecl = s_renderCtx.m_vertexDecls[decl];
const VertexDeclaration& vertexDecl = s_renderCtx->m_vertexDecls[decl];
DX_CHECK(device->SetStreamSource(0, vb.m_ptr, 0, vertexDecl.m_decl.m_stride) );
if (invalidHandle != state.m_instanceDataBuffer.idx
&& s_renderCtx.m_instancing)
&& s_renderCtx->m_instancing)
{
const VertexBuffer& inst = s_renderCtx.m_vertexBuffers[state.m_instanceDataBuffer.idx];
const VertexBuffer& inst = s_renderCtx->m_vertexBuffers[state.m_instanceDataBuffer.idx];
DX_CHECK(device->SetStreamSourceFreq(0, D3DSTREAMSOURCE_INDEXEDDATA|state.m_numInstances) );
DX_CHECK(device->SetStreamSourceFreq(1, D3DSTREAMSOURCE_INSTANCEDATA|1) );
DX_CHECK(device->SetStreamSource(1, inst.m_ptr, state.m_instanceDataOffset, state.m_instanceDataStride) );
@@ -2744,7 +2756,7 @@ namespace bgfx
uint16_t handle = state.m_indexBuffer.idx;
if (invalidHandle != handle)
{
const IndexBuffer& ib = s_renderCtx.m_indexBuffers[handle];
const IndexBuffer& ib = s_renderCtx->m_indexBuffers[handle];
DX_CHECK(device->SetIndices(ib.m_ptr) );
}
else
@@ -2758,9 +2770,9 @@ namespace bgfx
uint32_t numVertices = state.m_numVertices;
if (UINT32_C(0xffffffff) == numVertices)
{
const VertexBuffer& vb = s_renderCtx.m_vertexBuffers[currentState.m_vertexBuffer.idx];
const VertexBuffer& vb = s_renderCtx->m_vertexBuffers[currentState.m_vertexBuffer.idx];
uint16_t decl = vb.m_decl.idx == invalidHandle ? state.m_vertexDecl.idx : vb.m_decl.idx;
const VertexDeclaration& vertexDecl = s_renderCtx.m_vertexDecls[decl];
const VertexDeclaration& vertexDecl = s_renderCtx->m_vertexDecls[decl];
numVertices = vb.m_size/vertexDecl.m_decl.m_stride;
}
@@ -2773,7 +2785,7 @@ namespace bgfx
{
if (UINT32_MAX == state.m_numIndices)
{
numIndices = s_renderCtx.m_indexBuffers[state.m_indexBuffer.idx].m_size/2;
numIndices = s_renderCtx->m_indexBuffers[state.m_indexBuffer.idx].m_size/2;
numPrimsSubmitted = numIndices/primNumVerts;
numInstances = state.m_numInstances;
numPrimsRendered = numPrimsSubmitted*state.m_numInstances;
@@ -2826,7 +2838,7 @@ namespace bgfx
if (0 < m_render->m_num)
{
captureElapsed = -bx::getHPCounter();
s_renderCtx.capture();
s_renderCtx->capture();
captureElapsed += bx::getHPCounter();
}
}
@@ -2847,7 +2859,7 @@ namespace bgfx
{
PIX_BEGINEVENT(D3DCOLOR_RGBA(0x40, 0x40, 0x40, 0xff), L"debugstats");
TextVideoMem& tvm = s_renderCtx.m_textVideoMem;
TextVideoMem& tvm = s_renderCtx->m_textVideoMem;
static int64_t next = now;
@@ -2862,7 +2874,7 @@ namespace bgfx
uint16_t pos = 0;
tvm.printf(0, pos++, BGFX_CONFIG_DEBUG ? 0x89 : 0x8f, " " BGFX_RENDERER_NAME " ");
const D3DADAPTER_IDENTIFIER9& identifier = s_renderCtx.m_identifier;
const D3DADAPTER_IDENTIFIER9& identifier = s_renderCtx->m_identifier;
tvm.printf(0, pos++, 0x0f, " Device: %s (%s)", identifier.Description, identifier.Driver);
pos = 10;

14
src/renderer_d3d9.h
View File

@@ -199,6 +199,11 @@ namespace bgfx
struct VertexDeclaration
{
VertexDeclaration()
: m_ptr(NULL)
{
}
void create(const VertexDecl& _decl);
void destroy()
@@ -214,6 +219,8 @@ namespace bgfx
{
Shader()
: m_ptr(NULL)
, m_constantBuffer(NULL)
, m_numPredefined(0)
{
}
@@ -222,8 +229,11 @@ namespace bgfx
void destroy()
{
ConstantBuffer::destroy(m_constantBuffer);
m_constantBuffer = NULL;
if (NULL != m_constantBuffer)
{
ConstantBuffer::destroy(m_constantBuffer);
m_constantBuffer = NULL;
}
m_numPredefined = 0;
DX_RELEASE(m_ptr, 0);

275
src/renderer_gl.cpp
View File

@@ -888,34 +888,34 @@ namespace bgfx
const char* m_glslVersion;
};
RendererContext s_renderCtx;
RendererContext* s_renderCtx;
#if BX_PLATFORM_NACL
static void GL_APIENTRY naclVertexAttribDivisor(GLuint _index, GLuint _divisor)
{
s_renderCtx.m_glctx.m_instancedArrays->VertexAttribDivisorANGLE(s_renderCtx.m_glctx.m_context, _index, _divisor);
s_renderCtx->m_glctx.m_instancedArrays->VertexAttribDivisorANGLE(s_renderCtx->m_glctx.m_context, _index, _divisor);
}
static void GL_APIENTRY naclDrawArraysInstanced(GLenum _mode, GLint _first, GLsizei _count, GLsizei _primcount)
{
s_renderCtx.m_glctx.m_instancedArrays->DrawArraysInstancedANGLE(s_renderCtx.m_glctx.m_context, _mode, _first, _count, _primcount);
s_renderCtx->m_glctx.m_instancedArrays->DrawArraysInstancedANGLE(s_renderCtx->m_glctx.m_context, _mode, _first, _count, _primcount);
}
static void GL_APIENTRY naclDrawElementsInstanced(GLenum _mode, GLsizei _count, GLenum _type, const GLvoid* _indices, GLsizei _primcount)
{
s_renderCtx.m_glctx.m_instancedArrays->DrawElementsInstancedANGLE(s_renderCtx.m_glctx.m_context, _mode, _count, _type, _indices, _primcount);
s_renderCtx->m_glctx.m_instancedArrays->DrawElementsInstancedANGLE(s_renderCtx->m_glctx.m_context, _mode, _count, _type, _indices, _primcount);
}
void naclSetIntefraces(PP_Instance _instance, const PPB_Instance* _instInterface, const PPB_Graphics3D* _graphicsInterface, PostSwapBuffersFn _postSwapBuffers)
{
s_renderCtx.m_glctx.m_instance = _instance;
s_renderCtx.m_glctx.m_instInterface = _instInterface;
s_renderCtx.m_glctx.m_graphicsInterface = _graphicsInterface;
s_renderCtx.m_postSwapBuffers = _postSwapBuffers;
s_renderCtx.m_glctx.m_instancedArrays = glGetInstancedArraysInterfacePPAPI();
s_renderCtx.setRenderContextSize(BGFX_DEFAULT_WIDTH, BGFX_DEFAULT_HEIGHT);
s_renderCtx->m_glctx.m_instance = _instance;
s_renderCtx->m_glctx.m_instInterface = _instInterface;
s_renderCtx->m_glctx.m_graphicsInterface = _graphicsInterface;
s_renderCtx->m_postSwapBuffers = _postSwapBuffers;
s_renderCtx->m_glctx.m_instancedArrays = glGetInstancedArraysInterfacePPAPI();
s_renderCtx->setRenderContextSize(BGFX_DEFAULT_WIDTH, BGFX_DEFAULT_HEIGHT);
if (NULL != s_renderCtx.m_glctx.m_instancedArrays)
if (NULL != s_renderCtx->m_glctx.m_instancedArrays)
{
s_vertexAttribDivisor = naclVertexAttribDivisor;
s_drawArraysInstanced = naclDrawArraysInstanced;
@@ -1029,9 +1029,9 @@ namespace bgfx
bool cached = false;
uint64_t id = (uint64_t(_vsh.m_hash)<<32) | _fsh.m_hash;
id ^= s_renderCtx.m_hash;
id ^= s_renderCtx->m_hash;
if (s_renderCtx.m_programBinarySupport)
if (s_renderCtx->m_programBinarySupport)
{
uint32_t length = g_callback->cacheReadSize(id);
cached = length > 0;
@@ -1078,7 +1078,7 @@ namespace bgfx
return;
}
if (s_renderCtx.m_programBinarySupport)
if (s_renderCtx->m_programBinarySupport)
{
GLint programLength;
GLenum format;
@@ -1106,7 +1106,7 @@ namespace bgfx
GL_CHECK(glUseProgram(0) );
GL_CHECK(glDeleteProgram(m_id) );
m_vcref.invalidate(s_renderCtx.m_vaoStateCache);
m_vcref.invalidate(s_renderCtx->m_vaoStateCache);
}
void Program::init()
@@ -1182,7 +1182,7 @@ namespace bgfx
}
else
{
const UniformInfo* info = s_renderCtx.m_uniformReg.find(name);
const UniformInfo* info = s_renderCtx->m_uniformReg.find(name);
if (NULL != info)
{
data = info->m_data;
@@ -1309,7 +1309,7 @@ namespace bgfx
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) );
GL_CHECK(glDeleteBuffers(1, &m_id) );
m_vcref.invalidate(s_renderCtx.m_vaoStateCache);
m_vcref.invalidate(s_renderCtx->m_vaoStateCache);
}
void VertexBuffer::destroy()
@@ -1317,7 +1317,7 @@ namespace bgfx
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, 0) );
GL_CHECK(glDeleteBuffers(1, &m_id) );
m_vcref.invalidate(s_renderCtx.m_vaoStateCache);
m_vcref.invalidate(s_renderCtx->m_vaoStateCache);
}
static void texImage(GLenum _target, GLint _level, GLint _internalFormat, GLsizei _width, GLsizei _height, GLsizei _depth, GLint _border, GLenum _format, GLenum _type, const GLvoid* _data)
@@ -1412,7 +1412,7 @@ namespace bgfx
#if BGFX_CONFIG_RENDERER_OPENGL
if (GL_RGBA == m_fmt
&& s_renderCtx.m_textureSwizzleSupport)
&& s_renderCtx->m_textureSwizzleSupport)
{
GLint swizzleMask[] = { GL_BLUE, GL_GREEN, GL_RED, GL_ALPHA };
GL_CHECK(glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask) );
@@ -1450,7 +1450,7 @@ namespace bgfx
const GLenum internalFmt = s_textureFormat[m_textureFormat].m_internalFmt;
const bool swizzle = GL_RGBA == internalFmt && !s_renderCtx.m_textureSwizzleSupport;
const bool swizzle = GL_RGBA == internalFmt && !s_renderCtx->m_textureSwizzleSupport;
const bool convert = m_textureFormat != m_requestedFormat;
const bool compressed = TextureFormat::Unknown > m_textureFormat;
const uint32_t min = convert && compressed ? 4 : 1;
@@ -1660,7 +1660,7 @@ namespace bgfx
GLenum target = GL_TEXTURE_CUBE_MAP == m_target ? GL_TEXTURE_CUBE_MAP_POSITIVE_X : m_target;
const bool swizzle = GL_RGBA == m_fmt && !s_renderCtx.m_textureSwizzleSupport;
const bool swizzle = GL_RGBA == m_fmt && !s_renderCtx->m_textureSwizzleSupport;
const bool convert = m_textureFormat != m_requestedFormat;
const bool compressed = TextureFormat::Unknown > m_textureFormat;
@@ -1752,9 +1752,9 @@ namespace bgfx
GL_CHECK(glTexParameteri(target, GL_TEXTURE_MAG_FILTER, s_textureFilterMag[mag]) );
GL_CHECK(glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter) );
if (0 != (flags & (BGFX_TEXTURE_MIN_ANISOTROPIC|BGFX_TEXTURE_MAG_ANISOTROPIC) )
&& 0.0f < s_renderCtx.m_maxAnisotropy)
&& 0.0f < s_renderCtx->m_maxAnisotropy)
{
GL_CHECK(glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, s_renderCtx.m_maxAnisotropy) );
GL_CHECK(glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, s_renderCtx->m_maxAnisotropy) );
}
m_currentFlags = flags;
@@ -1771,9 +1771,9 @@ namespace bgfx
setSamplerState(_flags);
#elif BGFX_CONFIG_RENDERER_OPENGL < 31
// In case that GL 2.1 sampler object is supported via extension.
if (s_renderCtx.m_samplerObjectSupport)
if (s_renderCtx->m_samplerObjectSupport)
{
s_renderCtx.setSamplerState(_stage, m_numMips, _flags);
s_renderCtx->setSamplerState(_stage, m_numMips, _flags);
}
else
{
@@ -1781,7 +1781,7 @@ namespace bgfx
}
#else
// Everything else has sampler object.
s_renderCtx.setSamplerState(_stage, m_numMips, _flags);
s_renderCtx->setSamplerState(_stage, m_numMips, _flags);
#endif // BGFX_CONFIG_RENDERER_*
}
@@ -1792,7 +1792,7 @@ namespace bgfx
m_width = _width;
m_height = _height;
uint32_t msaa = (_flags&BGFX_RENDER_TARGET_MSAA_MASK)>>BGFX_RENDER_TARGET_MSAA_SHIFT;
m_msaa = bx::uint32_min(s_renderCtx.m_maxMsaa, msaa == 0 ? 0 : 1<<msaa);
m_msaa = bx::uint32_min(s_renderCtx->m_maxMsaa, msaa == 0 ? 0 : 1<<msaa);
uint32_t colorFormat = (_flags&BGFX_RENDER_TARGET_COLOR_MASK)>>BGFX_RENDER_TARGET_COLOR_SHIFT;
uint32_t depthFormat = (_flags&BGFX_RENDER_TARGET_DEPTH_MASK)>>BGFX_RENDER_TARGET_DEPTH_SHIFT;
@@ -1904,7 +1904,7 @@ namespace bgfx
);
}
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx.m_msaaBackBufferFbo) );
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx->m_msaaBackBufferFbo) );
}
void RenderTarget::destroy()
@@ -1946,7 +1946,7 @@ namespace bgfx
, GL_COLOR_BUFFER_BIT
, GL_LINEAR
) );
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx.m_msaaBackBufferFbo) );
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx->m_msaaBackBufferFbo) );
#endif // BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
}
@@ -2033,15 +2033,15 @@ namespace bgfx
void TextVideoMemBlitter::setup()
{
if (0 != s_renderCtx.m_vao)
if (0 != s_renderCtx->m_vao)
{
GL_CHECK(glBindVertexArray(s_renderCtx.m_vao) );
GL_CHECK(glBindVertexArray(s_renderCtx->m_vao) );
}
uint32_t width = s_renderCtx.m_resolution.m_width;
uint32_t height = s_renderCtx.m_resolution.m_height;
uint32_t width = s_renderCtx->m_resolution.m_width;
uint32_t height = s_renderCtx->m_resolution.m_height;
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx.m_backBufferFbo) );
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx->m_backBufferFbo) );
GL_CHECK(glViewport(0, 0, width, height) );
GL_CHECK(glDisable(GL_SCISSOR_TEST) );
@@ -2052,7 +2052,7 @@ namespace bgfx
GL_CHECK(glDisable(GL_BLEND) );
GL_CHECK(glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) );
Program& program = s_renderCtx.m_program[m_program.idx];
Program& program = s_renderCtx->m_program[m_program.idx];
GL_CHECK(glUseProgram(program.m_id) );
GL_CHECK(glUniform1i(program.m_sampler[0], 0) );
@@ -2066,22 +2066,22 @@ namespace bgfx
) );
GL_CHECK(glActiveTexture(GL_TEXTURE0) );
GL_CHECK(glBindTexture(GL_TEXTURE_2D, s_renderCtx.m_textures[m_texture.idx].m_id) );
GL_CHECK(glBindTexture(GL_TEXTURE_2D, s_renderCtx->m_textures[m_texture.idx].m_id) );
}
void TextVideoMemBlitter::render(uint32_t _numIndices)
{
uint32_t numVertices = _numIndices*4/6;
s_renderCtx.m_indexBuffers[m_ib->handle.idx].update(0, _numIndices*2, m_ib->data);
s_renderCtx.m_vertexBuffers[m_vb->handle.idx].update(0, numVertices*m_decl.m_stride, m_vb->data);
s_renderCtx->m_indexBuffers[m_ib->handle.idx].update(0, _numIndices*2, m_ib->data);
s_renderCtx->m_vertexBuffers[m_vb->handle.idx].update(0, numVertices*m_decl.m_stride, m_vb->data);
VertexBuffer& vb = s_renderCtx.m_vertexBuffers[m_vb->handle.idx];
VertexBuffer& vb = s_renderCtx->m_vertexBuffers[m_vb->handle.idx];
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, vb.m_id) );
IndexBuffer& ib = s_renderCtx.m_indexBuffers[m_ib->handle.idx];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[m_ib->handle.idx];
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib.m_id) );
Program& program = s_renderCtx.m_program[m_program.idx];
Program& program = s_renderCtx->m_program[m_program.idx];
program.bindAttributes(m_decl, 0);
GL_CHECK(glDrawElements(GL_TRIANGLES
@@ -2094,7 +2094,7 @@ namespace bgfx
void ClearQuad::clear(const Rect& _rect, const Clear& _clear, uint32_t _height)
{
#if BGFX_CONFIG_CLEAR_QUAD
if (s_renderCtx.m_useClearQuad)
if (s_renderCtx->m_useClearQuad)
{
GL_CHECK(glDisable(GL_SCISSOR_TEST) );
GL_CHECK(glDisable(GL_CULL_FACE) );
@@ -2125,8 +2125,8 @@ namespace bgfx
GL_CHECK(glDisable(GL_STENCIL_TEST) );
}
VertexBuffer& vb = s_renderCtx.m_vertexBuffers[m_vb->handle.idx];
VertexDecl& vertexDecl = s_renderCtx.m_vertexDecls[m_vb->decl.idx];
VertexBuffer& vb = s_renderCtx->m_vertexBuffers[m_vb->handle.idx];
VertexDecl& vertexDecl = s_renderCtx->m_vertexDecls[m_vb->decl.idx];
{
struct Vertex
@@ -2162,14 +2162,14 @@ namespace bgfx
vertex->m_abgr = abgr;
}
s_renderCtx.m_vertexBuffers[m_vb->handle.idx].update(0, 4*m_decl.m_stride, m_vb->data);
s_renderCtx->m_vertexBuffers[m_vb->handle.idx].update(0, 4*m_decl.m_stride, m_vb->data);
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, vb.m_id) );
IndexBuffer& ib = s_renderCtx.m_indexBuffers[m_ib.idx];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[m_ib.idx];
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib.m_id) );
Program& program = s_renderCtx.m_program[m_program.idx];
Program& program = s_renderCtx->m_program[m_program.idx];
GL_CHECK(glUseProgram(program.m_id) );
program.bindAttributes(vertexDecl, 0);
@@ -2220,7 +2220,10 @@ namespace bgfx
void Context::flip()
{
s_renderCtx.flip();
if (NULL != s_renderCtx)
{
s_renderCtx->flip();
}
}
GLint glGet(GLenum _pname)
@@ -2235,7 +2238,8 @@ namespace bgfx
void Context::rendererInit()
{
s_renderCtx.init();
s_renderCtx = BX_NEW(g_allocator, RendererContext);
s_renderCtx->init();
#if BGFX_CONFIG_DEBUG
GLint numCmpFormats;
@@ -2305,14 +2309,14 @@ namespace bgfx
GL_GET(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, 0);
GL_GET(GL_MAX_RENDERBUFFER_SIZE, 1);
BX_TRACE(" Vendor: %s", s_renderCtx.m_vendor);
BX_TRACE(" Renderer: %s", s_renderCtx.m_renderer);
BX_TRACE(" Version: %s", s_renderCtx.m_version);
BX_TRACE("GLSL version: %s", s_renderCtx.m_glslVersion);
BX_TRACE(" Vendor: %s", s_renderCtx->m_vendor);
BX_TRACE(" Renderer: %s", s_renderCtx->m_renderer);
BX_TRACE(" Version: %s", s_renderCtx->m_version);
BX_TRACE("GLSL version: %s", s_renderCtx->m_glslVersion);
#endif // BGFX_CONFIG_DEBUG
// Initial binary shader hash depends on driver version.
s_renderCtx.m_hash = ( (BX_PLATFORM_WINDOWS<<1) | BX_ARCH_64BIT)
s_renderCtx->m_hash = ( (BX_PLATFORM_WINDOWS<<1) | BX_ARCH_64BIT)
^ (uint64_t(getGLStringHash(GL_VENDOR ) )<<32)
^ (uint64_t(getGLStringHash(GL_RENDERER) )<<0 )
^ (uint64_t(getGLStringHash(GL_VERSION ) )<<16)
@@ -2416,46 +2420,46 @@ namespace bgfx
s_textureFormat[TextureFormat::PTC22].m_supported = ptc2Supported;
s_textureFormat[TextureFormat::PTC24].m_supported = ptc2Supported;
s_renderCtx.m_vaoSupport = !!BGFX_CONFIG_RENDERER_OPENGLES3
s_renderCtx->m_vaoSupport = !!BGFX_CONFIG_RENDERER_OPENGLES3
|| s_extension[Extension::ARB_vertex_array_object].m_supported
|| s_extension[Extension::OES_vertex_array_object].m_supported
;
s_renderCtx.m_samplerObjectSupport = !!BGFX_CONFIG_RENDERER_OPENGLES3
s_renderCtx->m_samplerObjectSupport = !!BGFX_CONFIG_RENDERER_OPENGLES3
|| s_extension[Extension::ARB_sampler_objects].m_supported
;
s_renderCtx.m_programBinarySupport = !!BGFX_CONFIG_RENDERER_OPENGLES3
s_renderCtx->m_programBinarySupport = !!BGFX_CONFIG_RENDERER_OPENGLES3
|| s_extension[Extension::ARB_get_program_binary].m_supported
|| s_extension[Extension::OES_get_program_binary].m_supported
|| s_extension[Extension::IMG_shader_binary].m_supported
;
s_renderCtx.m_textureSwizzleSupport = false
s_renderCtx->m_textureSwizzleSupport = false
|| s_extension[Extension::ARB_texture_swizzle].m_supported
|| s_extension[Extension::EXT_texture_swizzle].m_supported
;
if (s_extension[Extension::EXT_texture_filter_anisotropic].m_supported)
{
GL_CHECK(glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &s_renderCtx.m_maxAnisotropy) );
GL_CHECK(glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &s_renderCtx->m_maxAnisotropy) );
}
#if BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
if (s_extension[Extension::ARB_texture_multisample].m_supported)
{
GL_CHECK(glGetIntegerv(GL_MAX_SAMPLES, &s_renderCtx.m_maxMsaa) );
GL_CHECK(glGetIntegerv(GL_MAX_SAMPLES, &s_renderCtx->m_maxMsaa) );
}
#endif // BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
if (s_extension[Extension::IMG_read_format].m_supported
&& s_extension[Extension::OES_read_format].m_supported)
{
s_renderCtx.m_readPixelsFmt = GL_BGRA_EXT;
s_renderCtx->m_readPixelsFmt = GL_BGRA_EXT;
}
else
{
s_renderCtx.m_readPixelsFmt = GL_RGBA;
s_renderCtx->m_readPixelsFmt = GL_RGBA;
}
if (s_extension[Extension::EXT_texture_format_BGRA8888].m_supported
@@ -2464,7 +2468,7 @@ namespace bgfx
|| s_extension[Extension::APPLE_texture_format_BGRA8888].m_supported)
{
#if BGFX_CONFIG_RENDERER_OPENGL
s_renderCtx.m_readPixelsFmt = GL_BGRA_EXT;
s_renderCtx->m_readPixelsFmt = GL_BGRA_EXT;
#endif // BGFX_CONFIG_RENDERER_OPENGL
s_textureFormat[TextureFormat::BGRA8].m_fmt = GL_BGRA_EXT;
@@ -2512,9 +2516,9 @@ namespace bgfx
# endif // !BX_PLATFORM_IOS
#endif // !BGFX_CONFIG_RENDERER_OPENGLES3
if (s_renderCtx.m_vaoSupport)
if (s_renderCtx->m_vaoSupport)
{
GL_CHECK(glGenVertexArrays(1, &s_renderCtx.m_vao) );
GL_CHECK(glGenVertexArrays(1, &s_renderCtx->m_vao) );
}
#if BGFX_CONFIG_RENDERER_OPENGL
@@ -2543,29 +2547,32 @@ namespace bgfx
void Context::rendererShutdown()
{
if (s_renderCtx.m_vaoSupport)
if (s_renderCtx->m_vaoSupport)
{
GL_CHECK(glBindVertexArray(0) );
GL_CHECK(glDeleteVertexArrays(1, &s_renderCtx.m_vao) );
s_renderCtx.m_vao = 0;
GL_CHECK(glDeleteVertexArrays(1, &s_renderCtx->m_vao) );
s_renderCtx->m_vao = 0;
}
s_renderCtx.shutdown();
s_renderCtx->shutdown();
BX_DELETE(g_allocator, s_renderCtx);
s_renderCtx = NULL;
}
void Context::rendererCreateIndexBuffer(IndexBufferHandle _handle, Memory* _mem)
{
s_renderCtx.m_indexBuffers[_handle.idx].create(_mem->size, _mem->data);
s_renderCtx->m_indexBuffers[_handle.idx].create(_mem->size, _mem->data);
}
void Context::rendererDestroyIndexBuffer(IndexBufferHandle _handle)
{
s_renderCtx.m_indexBuffers[_handle.idx].destroy();
s_renderCtx->m_indexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl)
{
VertexDecl& decl = s_renderCtx.m_vertexDecls[_handle.idx];
VertexDecl& decl = s_renderCtx->m_vertexDecls[_handle.idx];
memcpy(&decl, &_decl, sizeof(VertexDecl) );
dump(decl);
}
@@ -2576,78 +2583,78 @@ namespace bgfx
void Context::rendererCreateVertexBuffer(VertexBufferHandle _handle, Memory* _mem, VertexDeclHandle _declHandle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle);
s_renderCtx->m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle);
}
void Context::rendererDestroyVertexBuffer(VertexBufferHandle _handle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].destroy();
s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _size)
{
s_renderCtx.m_indexBuffers[_handle.idx].create(_size, NULL);
s_renderCtx->m_indexBuffers[_handle.idx].create(_size, NULL);
}
void Context::rendererUpdateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{
s_renderCtx.m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
s_renderCtx->m_indexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
}
void Context::rendererDestroyDynamicIndexBuffer(IndexBufferHandle _handle)
{
s_renderCtx.m_indexBuffers[_handle.idx].destroy();
s_renderCtx->m_indexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _size)
{
VertexDeclHandle decl = BGFX_INVALID_HANDLE;
s_renderCtx.m_vertexBuffers[_handle.idx].create(_size, NULL, decl);
s_renderCtx->m_vertexBuffers[_handle.idx].create(_size, NULL, decl);
}
void Context::rendererUpdateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, Memory* _mem)
{
s_renderCtx.m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
s_renderCtx->m_vertexBuffers[_handle.idx].update(_offset, bx::uint32_min(_size, _mem->size), _mem->data);
}
void Context::rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle)
{
s_renderCtx.m_vertexBuffers[_handle.idx].destroy();
s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
}
void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem)
{
s_renderCtx.m_vertexShaders[_handle.idx].create(GL_VERTEX_SHADER, _mem);
s_renderCtx->m_vertexShaders[_handle.idx].create(GL_VERTEX_SHADER, _mem);
}
void Context::rendererDestroyVertexShader(VertexShaderHandle _handle)
{
s_renderCtx.m_vertexShaders[_handle.idx].destroy();
s_renderCtx->m_vertexShaders[_handle.idx].destroy();
}
void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem)
{
s_renderCtx.m_fragmentShaders[_handle.idx].create(GL_FRAGMENT_SHADER, _mem);
s_renderCtx->m_fragmentShaders[_handle.idx].create(GL_FRAGMENT_SHADER, _mem);
}
void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle)
{
s_renderCtx.m_fragmentShaders[_handle.idx].destroy();
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_vertexShaders[_vsh.idx], s_renderCtx->m_fragmentShaders[_fsh.idx]);
}
void Context::rendererDestroyProgram(FragmentShaderHandle _handle)
{
s_renderCtx.m_program[_handle.idx].destroy();
s_renderCtx->m_program[_handle.idx].destroy();
}
void Context::rendererCreateTexture(TextureHandle _handle, Memory* _mem, uint32_t _flags)
{
s_renderCtx.m_textures[_handle.idx].create(_mem, _flags);
s_renderCtx->m_textures[_handle.idx].create(_mem, _flags);
}
void Context::rendererUpdateTextureBegin(TextureHandle /*_handle*/, uint8_t /*_side*/, uint8_t /*_mip*/)
@@ -2656,7 +2663,7 @@ namespace bgfx
void Context::rendererUpdateTexture(TextureHandle _handle, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, const Memory* _mem)
{
s_renderCtx.m_textures[_handle.idx].update(_side, _mip, _rect, _z, _depth, _mem);
s_renderCtx->m_textures[_handle.idx].update(_side, _mip, _rect, _z, _depth, _mem);
}
void Context::rendererUpdateTextureEnd()
@@ -2665,17 +2672,17 @@ namespace bgfx
void Context::rendererDestroyTexture(TextureHandle _handle)
{
s_renderCtx.m_textures[_handle.idx].destroy();
s_renderCtx->m_textures[_handle.idx].destroy();
}
void Context::rendererCreateRenderTarget(RenderTargetHandle _handle, uint16_t _width, uint16_t _height, uint32_t _flags, uint32_t _textureFlags)
{
s_renderCtx.m_renderTargets[_handle.idx].create(_width, _height, _flags, _textureFlags);
s_renderCtx->m_renderTargets[_handle.idx].create(_width, _height, _flags, _textureFlags);
}
void Context::rendererDestroyRenderTarget(RenderTargetHandle _handle)
{
s_renderCtx.m_renderTargets[_handle.idx].destroy();
s_renderCtx->m_renderTargets[_handle.idx].destroy();
}
void Context::rendererCreateUniform(UniformHandle _handle, UniformType::Enum _type, uint16_t _num, const char* _name)
@@ -2683,18 +2690,18 @@ namespace bgfx
uint32_t size = g_uniformTypeSize[_type]*_num;
void* data = BX_ALLOC(g_allocator, size);
memset(data, 0, size);
s_renderCtx.m_uniforms[_handle.idx] = data;
s_renderCtx.m_uniformReg.add(_name, s_renderCtx.m_uniforms[_handle.idx]);
s_renderCtx->m_uniforms[_handle.idx] = data;
s_renderCtx->m_uniformReg.add(_name, s_renderCtx->m_uniforms[_handle.idx]);
}
void Context::rendererDestroyUniform(UniformHandle _handle)
{
BX_FREE(g_allocator, s_renderCtx.m_uniforms[_handle.idx]);
BX_FREE(g_allocator, s_renderCtx->m_uniforms[_handle.idx]);
}
void Context::rendererSaveScreenShot(const char* _filePath)
{
s_renderCtx.saveScreenShot(_filePath);
s_renderCtx->saveScreenShot(_filePath);
}
void Context::rendererUpdateViewName(uint8_t _id, const char* _name)
@@ -2704,7 +2711,7 @@ namespace bgfx
void Context::rendererUpdateUniform(uint16_t _loc, const void* _data, uint32_t _size)
{
memcpy(s_renderCtx.m_uniforms[_loc], _data, _size);
memcpy(s_renderCtx->m_uniforms[_loc], _data, _size);
}
void Context::rendererSetMarker(const char* _marker, uint32_t /*_size*/)
@@ -2714,15 +2721,15 @@ namespace bgfx
void Context::rendererSubmit()
{
const GLuint defaultVao = s_renderCtx.m_vao;
const GLuint defaultVao = s_renderCtx->m_vao;
if (0 != defaultVao)
{
GL_CHECK(glBindVertexArray(defaultVao) );
}
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx.m_backBufferFbo) );
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx->m_backBufferFbo) );
s_renderCtx.updateResolution(m_render->m_resolution);
s_renderCtx->updateResolution(m_render->m_resolution);
int64_t elapsed = -bx::getHPCounter();
int64_t captureElapsed = 0;
@@ -2730,20 +2737,20 @@ namespace bgfx
#if BGFX_CONFIG_RENDERER_OPENGL
if (m_render->m_debug & (BGFX_DEBUG_IFH|BGFX_DEBUG_STATS) )
{
s_renderCtx.m_queries.begin(0, GL_TIME_ELAPSED);
s_renderCtx->m_queries.begin(0, GL_TIME_ELAPSED);
}
#endif // BGFX_CONFIG_RENDERER_OPENGL
if (0 < m_render->m_iboffset)
{
TransientIndexBuffer* ib = m_render->m_transientIb;
s_renderCtx.m_indexBuffers[ib->handle.idx].update(0, m_render->m_iboffset, ib->data);
s_renderCtx->m_indexBuffers[ib->handle.idx].update(0, m_render->m_iboffset, ib->data);
}
if (0 < m_render->m_vboffset)
{
TransientVertexBuffer* vb = m_render->m_transientVb;
s_renderCtx.m_vertexBuffers[vb->handle.idx].update(0, m_render->m_vboffset, vb->data);
s_renderCtx->m_vertexBuffers[vb->handle.idx].update(0, m_render->m_vboffset, vb->data);
}
m_render->sort();
@@ -2781,7 +2788,7 @@ namespace bgfx
if (0 == (m_render->m_debug&BGFX_DEBUG_IFH) )
{
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx.m_msaaBackBufferFbo) );
GL_CHECK(glBindFramebuffer(GL_FRAMEBUFFER, s_renderCtx->m_msaaBackBufferFbo) );
for (uint32_t item = 0, numItems = m_render->m_num; item < numItems; ++item)
{
@@ -2813,7 +2820,7 @@ namespace bgfx
if (m_render->m_rt[view].idx != rt.idx)
{
rt = m_render->m_rt[view];
height = s_renderCtx.setRenderTarget(rt, m_render->m_resolution.m_height);
height = s_renderCtx->setRenderTarget(rt, m_render->m_resolution.m_height);
}
const Rect& rect = m_render->m_rect[view];
@@ -3037,7 +3044,7 @@ namespace bgfx
if (key.m_program != programIdx)
{
programIdx = key.m_program;
GLuint id = invalidHandle == programIdx ? 0 : s_renderCtx.m_program[programIdx].m_id;
GLuint id = invalidHandle == programIdx ? 0 : s_renderCtx->m_program[programIdx].m_id;
GL_CHECK(glUseProgram(id) );
programChanged =
constantsChanged =
@@ -3046,7 +3053,7 @@ namespace bgfx
if (invalidHandle != programIdx)
{
Program& program = s_renderCtx.m_program[programIdx];
Program& program = s_renderCtx->m_program[programIdx];
if (constantsChanged)
{
@@ -3222,21 +3229,21 @@ namespace bgfx
{
case BGFX_SAMPLER_TEXTURE:
{
Texture& texture = s_renderCtx.m_textures[sampler.m_idx];
Texture& texture = s_renderCtx->m_textures[sampler.m_idx];
texture.commit(stage, sampler.m_flags);
}
break;
case BGFX_SAMPLER_RENDERTARGET_COLOR:
{
RenderTarget& rt = s_renderCtx.m_renderTargets[sampler.m_idx];
RenderTarget& rt = s_renderCtx->m_renderTargets[sampler.m_idx];
rt.m_color.commit(stage, sampler.m_flags);
}
break;
case BGFX_SAMPLER_RENDERTARGET_DEPTH:
{
RenderTarget& rt = s_renderCtx.m_renderTargets[sampler.m_idx];
RenderTarget& rt = s_renderCtx->m_renderTargets[sampler.m_idx];
rt.m_depth.commit(stage, sampler.m_flags);
}
break;
@@ -3276,7 +3283,7 @@ namespace bgfx
currentState.m_instanceDataStride = state.m_instanceDataStride;
baseVertex = state.m_startVertex;
GLuint id = s_renderCtx.m_vaoStateCache.find(hash);
GLuint id = s_renderCtx->m_vaoStateCache.find(hash);
if (UINT32_MAX != id)
{
currentVao = id;
@@ -3284,25 +3291,25 @@ namespace bgfx
}
else
{
id = s_renderCtx.m_vaoStateCache.add(hash);
id = s_renderCtx->m_vaoStateCache.add(hash);
currentVao = id;
GL_CHECK(glBindVertexArray(id) );
Program& program = s_renderCtx.m_program[programIdx];
Program& program = s_renderCtx->m_program[programIdx];
program.add(hash);
if (invalidHandle != state.m_vertexBuffer.idx)
{
VertexBuffer& vb = s_renderCtx.m_vertexBuffers[state.m_vertexBuffer.idx];
VertexBuffer& vb = s_renderCtx->m_vertexBuffers[state.m_vertexBuffer.idx];
vb.add(hash);
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, vb.m_id) );
uint16_t decl = vb.m_decl.idx == invalidHandle ? state.m_vertexDecl.idx : vb.m_decl.idx;
program.bindAttributes(s_renderCtx.m_vertexDecls[decl], state.m_startVertex);
program.bindAttributes(s_renderCtx->m_vertexDecls[decl], state.m_startVertex);
if (invalidHandle != state.m_instanceDataBuffer.idx)
{
VertexBuffer& instanceVb = s_renderCtx.m_vertexBuffers[state.m_instanceDataBuffer.idx];
VertexBuffer& instanceVb = s_renderCtx->m_vertexBuffers[state.m_instanceDataBuffer.idx];
instanceVb.add(hash);
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, instanceVb.m_id) );
program.bindInstanceData(state.m_instanceDataStride, state.m_instanceDataOffset);
@@ -3315,7 +3322,7 @@ namespace bgfx
if (invalidHandle != state.m_indexBuffer.idx)
{
IndexBuffer& ib = s_renderCtx.m_indexBuffers[state.m_indexBuffer.idx];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[state.m_indexBuffer.idx];
ib.add(hash);
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib.m_id) );
}
@@ -3352,7 +3359,7 @@ namespace bgfx
uint16_t handle = state.m_vertexBuffer.idx;
if (invalidHandle != handle)
{
VertexBuffer& vb = s_renderCtx.m_vertexBuffers[handle];
VertexBuffer& vb = s_renderCtx->m_vertexBuffers[handle];
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, vb.m_id) );
bindAttribs = true;
}
@@ -3369,7 +3376,7 @@ namespace bgfx
uint16_t handle = state.m_indexBuffer.idx;
if (invalidHandle != handle)
{
IndexBuffer& ib = s_renderCtx.m_indexBuffers[handle];
IndexBuffer& ib = s_renderCtx->m_indexBuffers[handle];
GL_CHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ib.m_id) );
}
else
@@ -3384,14 +3391,14 @@ namespace bgfx
|| bindAttribs)
{
baseVertex = state.m_startVertex;
const VertexBuffer& vb = s_renderCtx.m_vertexBuffers[state.m_vertexBuffer.idx];
const VertexBuffer& vb = s_renderCtx->m_vertexBuffers[state.m_vertexBuffer.idx];
uint16_t decl = vb.m_decl.idx == invalidHandle ? state.m_vertexDecl.idx : vb.m_decl.idx;
const Program& program = s_renderCtx.m_program[programIdx];
program.bindAttributes(s_renderCtx.m_vertexDecls[decl], state.m_startVertex);
const Program& program = s_renderCtx->m_program[programIdx];
program.bindAttributes(s_renderCtx->m_vertexDecls[decl], state.m_startVertex);
if (invalidHandle != state.m_instanceDataBuffer.idx)
{
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, s_renderCtx.m_vertexBuffers[state.m_instanceDataBuffer.idx].m_id) );
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, s_renderCtx->m_vertexBuffers[state.m_instanceDataBuffer.idx].m_id) );
program.bindInstanceData(state.m_instanceDataStride, state.m_instanceDataOffset);
}
}
@@ -3403,9 +3410,9 @@ namespace bgfx
uint32_t numVertices = state.m_numVertices;
if (UINT32_C(0xffffffff) == numVertices)
{
const VertexBuffer& vb = s_renderCtx.m_vertexBuffers[currentState.m_vertexBuffer.idx];
const VertexBuffer& vb = s_renderCtx->m_vertexBuffers[currentState.m_vertexBuffer.idx];
uint16_t decl = vb.m_decl.idx == invalidHandle ? state.m_vertexDecl.idx : vb.m_decl.idx;
const VertexDecl& vertexDecl = s_renderCtx.m_vertexDecls[decl];
const VertexDecl& vertexDecl = s_renderCtx->m_vertexDecls[decl];
numVertices = vb.m_size/vertexDecl.m_stride;
}
@@ -3418,7 +3425,7 @@ namespace bgfx
{
if (UINT32_MAX == state.m_numIndices)
{
numIndices = s_renderCtx.m_indexBuffers[state.m_indexBuffer.idx].m_size/2;
numIndices = s_renderCtx->m_indexBuffers[state.m_indexBuffer.idx].m_size/2;
numPrimsSubmitted = numIndices/primNumVerts;
numInstances = state.m_numInstances;
numPrimsRendered = numPrimsSubmitted*state.m_numInstances;
@@ -3466,12 +3473,12 @@ namespace bgfx
}
}
s_renderCtx.blitMsaaFbo();
s_renderCtx->blitMsaaFbo();
if (0 < m_render->m_num)
{
captureElapsed = -bx::getHPCounter();
s_renderCtx.capture();
s_renderCtx->capture();
captureElapsed += bx::getHPCounter();
}
}
@@ -3492,12 +3499,12 @@ namespace bgfx
{
double elapsedGpuMs = 0.0;
#if BGFX_CONFIG_RENDERER_OPENGL
s_renderCtx.m_queries.end(GL_TIME_ELAPSED);
uint64_t elapsedGl = s_renderCtx.m_queries.getResult(0);
s_renderCtx->m_queries.end(GL_TIME_ELAPSED);
uint64_t elapsedGl = s_renderCtx->m_queries.getResult(0);
elapsedGpuMs = double(elapsedGl)/1e6;
#endif // BGFX_CONFIG_RENDERER_OPENGL
TextVideoMem& tvm = s_renderCtx.m_textVideoMem;
TextVideoMem& tvm = s_renderCtx->m_textVideoMem;
static int64_t next = now;
@@ -3510,10 +3517,10 @@ namespace bgfx
tvm.clear();
uint16_t pos = 0;
tvm.printf(0, pos++, BGFX_CONFIG_DEBUG ? 0x89 : 0x8f, " " BGFX_RENDERER_NAME " ");
tvm.printf(0, pos++, 0x0f, " Vendor: %s", s_renderCtx.m_vendor);
tvm.printf(0, pos++, 0x0f, " Renderer: %s", s_renderCtx.m_renderer);
tvm.printf(0, pos++, 0x0f, " Version: %s", s_renderCtx.m_version);
tvm.printf(0, pos++, 0x0f, "GLSL version: %s", s_renderCtx.m_glslVersion);
tvm.printf(0, pos++, 0x0f, " Vendor: %s", s_renderCtx->m_vendor);
tvm.printf(0, pos++, 0x0f, " Renderer: %s", s_renderCtx->m_renderer);
tvm.printf(0, pos++, 0x0f, " Version: %s", s_renderCtx->m_version);
tvm.printf(0, pos++, 0x0f, "GLSL version: %s", s_renderCtx->m_glslVersion);
pos = 10;
tvm.printf(10, pos++, 0x8e, " Frame CPU: %7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] / % 6.2f FPS%s"