Removed context static inialization.

examples/07-callback/callback.cpp

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

examples/common/font/font_manager.cpp

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

examples/common/font/font_manager.h

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

examples/common/font/text_buffer_manager.cpp

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

examples/common/font/text_buffer_manager.h

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

src/bgfx.cpp

@@ -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 != _allocator)
+		{
+			g_allocator = _allocator;
+		}
+		else
+		{
+			bx::CrtAllocator allocator;
+			g_allocator =
+			s_allocatorStub = BX_NEW(&allocator, AllocatorStub);
+		}
+
 		if (NULL != _callback)
 		{
 			g_callback = _callback;
 		}
-
-		if (NULL != _allocator)
+		else
 		{
-			g_allocator = _allocator;
+			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);
 	}
 }

src/bgfx_p.h

@@ -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::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_DYNAMIC_VERTEX_BUFFERS> m_dynamicVertexBufferHandle;
+
+		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
 		{

src/renderer_d3d.h

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

src/renderer_d3d11.cpp

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

src/renderer_d3d11.h

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

src/renderer_d3d9.cpp

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

src/renderer_d3d9.h

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

src/renderer_gl.cpp

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