Simplified API, removed difference between vertex and fragment shaders.

examples/01-cubes/cubes.cpp

@@ -155,11 +155,11 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 
 	// Load vertex shader.
 	mem = loadShader("vs_cubes");
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader("fs_cubes");
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -168,8 +168,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	float at[3] = { 0.0f, 0.0f, 0.0f };
 	float eye[3] = { 0.0f, 0.0f, -35.0f };

examples/02-metaballs/metaballs.cpp

@@ -504,8 +504,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 		break;
 	}
 
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(vs_metaballs);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(fs_metaballs);
+	bgfx::ShaderHandle vsh = bgfx::createShader(vs_metaballs);
+	bgfx::ShaderHandle fsh = bgfx::createShader(fs_metaballs);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -514,8 +514,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 #define DIMS 32
 

examples/03-raymarch/raymarch.cpp

@@ -74,11 +74,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 
 	// Load vertex shader.
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -87,8 +87,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/04-mesh/mesh.cpp

@@ -66,11 +66,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 
 	// Load vertex shader.
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -79,8 +79,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/05-instancing/instancing.cpp

@@ -157,11 +157,11 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 
 	// Load vertex shader.
 	mem = loadShader("vs_instancing");
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader("fs_instancing");
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -170,8 +170,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	int64_t timeOffset = bx::getHPCounter();
 

examples/06-bump/bump.cpp

@@ -326,11 +326,11 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 
 	// Load vertex shader.
 	mem = loadShader(instancingSupported ? "vs_bump_instanced" : "vs_bump");
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader("fs_bump");
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -339,8 +339,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	// Load diffuse texture.
 	mem = loadTexture("fieldstone-rgba.dds");

examples/07-callback/callback.cpp

@@ -437,11 +437,11 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 
 	// Load vertex shader.
 	mem = loadShader("vs_callback");
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader("fs_callback");
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -450,8 +450,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	float time = 0.0f;
 

examples/08-update/update.cpp

@@ -128,10 +128,10 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam
 	const bgfx::Memory* mem;
 
 	mem = loadShader(_vshName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	mem = loadShader(_fshName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -140,8 +140,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/09-hdr/hdr.cpp

@@ -63,12 +63,12 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam
 	const bgfx::Memory* mem;
 
 	mem = loadShader(_vshName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 	mem = loadShader(_fshName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/12-lod/lod.cpp

@@ -88,11 +88,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 
 	// Load vertex shader.
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -101,8 +101,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/13-stencil/stencil.cpp

@@ -196,11 +196,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 
 	// Load vertex shader.
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -209,8 +209,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/14-shadowvolumes/shadowvolumes.cpp

@@ -166,11 +166,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 
 	// Load vertex shader.
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -179,8 +179,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/15-shadowmaps-simple/shadowmaps_simple.cpp

@@ -123,11 +123,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 
 	// Load vertex shader.
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -136,8 +136,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/16-shadowmaps/shadowmaps.cpp

@@ -313,11 +313,11 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 
 	// Load vertex shader.
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	// Load fragment shader.
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	// Create program from shaders.
 	bgfx::ProgramHandle program = bgfx::createProgram(vsh, fsh);
@@ -326,8 +326,8 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	return program;
 }

examples/17-drawstress/drawstress.cpp

@@ -290,8 +290,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 			break;
 	}
 
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(vs_drawstress);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(fs_drawstress);
+	bgfx::ShaderHandle vsh = bgfx::createShader(vs_drawstress);
+	bgfx::ShaderHandle fsh = bgfx::createShader(fs_drawstress);
 
 	// Create program from shaders.
 	program = bgfx::createProgram(vsh, fsh);
@@ -310,8 +310,8 @@ int _main_(int /*_argc*/, char** /*_argv*/)
 	// their reference is kept inside bgfx after calling createProgram.
 	// Vertex and fragment shader will be destroyed once program is
 	// destroyed.
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	imguiCreate(s_droidSansTtf, sizeof(s_droidSansTtf) );
 

examples/18-ibl/ibl.cpp

@@ -67,12 +67,12 @@ static bgfx::ProgramHandle loadProgram(const char* _vsName, const char* _fsName)
 	const bgfx::Memory* mem;
 
 	mem = loadShader(_vsName);
-	bgfx::VertexShaderHandle vs = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vs = bgfx::createShader(mem);
 	mem = loadShader(_fsName);
-	bgfx::FragmentShaderHandle fs = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fs = bgfx::createShader(mem);
 	bgfx::ProgramHandle program = bgfx::createProgram(vs, fs);
-	bgfx::destroyVertexShader(vs);
-	bgfx::destroyFragmentShader(fs);
+	bgfx::destroyShader(vs);
+	bgfx::destroyShader(fs);
 
 	return program;
 }

examples/19-oit/oit.cpp

@@ -131,10 +131,10 @@ static bgfx::ProgramHandle loadProgram(const char* _vshName, const char* _fshNam
 	const bgfx::Memory* mem;
 
 	mem = loadShader(_vshName);
-	bgfx::VertexShaderHandle vsh = bgfx::createVertexShader(mem);
+	bgfx::ShaderHandle vsh = bgfx::createShader(mem);
 
 	mem = loadShader(_fshName);
-	bgfx::FragmentShaderHandle fsh = bgfx::createFragmentShader(mem);
+	bgfx::ShaderHandle fsh = bgfx::createShader(mem);
 
 	return bgfx::createProgram(vsh, fsh, true);
 }

examples/common/font/text_buffer_manager.cpp

@@ -587,26 +587,26 @@ TextBufferManager::TextBufferManager(FontManager* _fontManager)
 		break;
 	}
 
-	bgfx::VertexShaderHandle vsh;
-	bgfx::FragmentShaderHandle fsh;
+	bgfx::ShaderHandle vsh;
+	bgfx::ShaderHandle fsh;
 
-	vsh = bgfx::createVertexShader(vs_font_basic);
-	fsh = bgfx::createFragmentShader(fs_font_basic);
+	vsh = bgfx::createShader(vs_font_basic);
+	fsh = bgfx::createShader(fs_font_basic);
 	m_basicProgram = bgfx::createProgram(vsh, fsh);
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
-	vsh = bgfx::createVertexShader(vs_font_distance_field);
-	fsh = bgfx::createFragmentShader(fs_font_distance_field);
+	vsh = bgfx::createShader(vs_font_distance_field);
+	fsh = bgfx::createShader(fs_font_distance_field);
 	m_distanceProgram = bgfx::createProgram(vsh, fsh);
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
-	vsh = bgfx::createVertexShader(vs_font_distance_field_subpixel);
-	fsh = bgfx::createFragmentShader(fs_font_distance_field_subpixel);
+	vsh = bgfx::createShader(vs_font_distance_field_subpixel);
+	fsh = bgfx::createShader(fs_font_distance_field_subpixel);
 	m_distanceSubpixelProgram = bgfx::createProgram(vsh, fsh);
-	bgfx::destroyVertexShader(vsh);
-	bgfx::destroyFragmentShader(fsh);
+	bgfx::destroyShader(vsh);
+	bgfx::destroyShader(fsh);
 
 	m_vertexDecl.begin();
 	m_vertexDecl.add(bgfx::Attrib::Position, 2, bgfx::AttribType::Float);

examples/common/imgui/imgui.cpp

@@ -204,20 +204,20 @@ struct Imgui
 			break;
 		}
 
-		bgfx::VertexShaderHandle vsh;
-		bgfx::FragmentShaderHandle fsh;
+		bgfx::ShaderHandle vsh;
+		bgfx::ShaderHandle fsh;
 
-		vsh = bgfx::createVertexShader(vs_imgui_color);
-		fsh = bgfx::createFragmentShader(fs_imgui_color);
+		vsh = bgfx::createShader(vs_imgui_color);
+		fsh = bgfx::createShader(fs_imgui_color);
 		m_colorProgram = bgfx::createProgram(vsh, fsh);
-		bgfx::destroyVertexShader(vsh);
-		bgfx::destroyFragmentShader(fsh);
+		bgfx::destroyShader(vsh);
+		bgfx::destroyShader(fsh);
 
-		vsh = bgfx::createVertexShader(vs_imgui_texture);
-		fsh = bgfx::createFragmentShader(fs_imgui_texture);
+		vsh = bgfx::createShader(vs_imgui_texture);
+		fsh = bgfx::createShader(fs_imgui_texture);
 		m_textureProgram = bgfx::createProgram(vsh, fsh);
-		bgfx::destroyVertexShader(vsh);
-		bgfx::destroyFragmentShader(fsh);
+		bgfx::destroyShader(vsh);
+		bgfx::destroyShader(fsh);
 
 		const bgfx::Memory* mem = bgfx::alloc(m_textureWidth * m_textureHeight);
 		stbtt_BakeFontBitmap( (uint8_t*)_data, 0, 15.0f, mem->data, m_textureWidth, m_textureHeight, 32, 96, m_cdata);

include/bgfx.h

@@ -448,15 +448,14 @@ namespace bgfx
 
 	BGFX_HANDLE(DynamicIndexBufferHandle);
 	BGFX_HANDLE(DynamicVertexBufferHandle);
-	BGFX_HANDLE(FragmentShaderHandle);
+	BGFX_HANDLE(FrameBufferHandle);
 	BGFX_HANDLE(IndexBufferHandle);
 	BGFX_HANDLE(ProgramHandle);
-	BGFX_HANDLE(FrameBufferHandle);
+	BGFX_HANDLE(ShaderHandle);
 	BGFX_HANDLE(TextureHandle);
 	BGFX_HANDLE(UniformHandle);
 	BGFX_HANDLE(VertexBufferHandle);
 	BGFX_HANDLE(VertexDeclHandle);
-	BGFX_HANDLE(VertexShaderHandle);
 
 	/// Callback interface to implement application specific behavior.
 	/// Cached items are currently used only for OpenGL binary shaders.
@@ -861,19 +860,12 @@ namespace bgfx
 	///
 	const InstanceDataBuffer* allocInstanceDataBuffer(uint32_t _num, uint16_t _stride);
 
-	/// Create vertex shader from memory buffer.
-	VertexShaderHandle createVertexShader(const Memory* _mem);
-
-	/// Destroy vertex shader. Once program is created with vertex shader
-	/// it is safe to destroy vertex shader.
-	void destroyVertexShader(VertexShaderHandle _handle);
-
-	/// Create fragment shader from memory buffer.
-	FragmentShaderHandle createFragmentShader(const Memory* _mem);
+	/// Create shader from memory buffer.
+	ShaderHandle createShader(const Memory* _mem);
 
-	/// Destroy fragment shader. Once program is created with fragment shader
-	/// it is safe to destroy fragment shader.
-	void destroyFragmentShader(FragmentShaderHandle _handle);
+	/// Destroy shader. Once program is created with shader it is safe to
+	/// destroy shader.
+	void destroyShader(ShaderHandle _handle);
 
 	/// Create program with vertex and fragment shaders.
 	///
@@ -884,7 +876,7 @@ namespace bgfx
 	/// @returns Program handle if vertex shader output and fragment shader
 	///   input are matching, otherwise returns invalid program handle.
 	///
-	ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh, bool _destroyShaders = false);
+	ProgramHandle createProgram(ShaderHandle _vsh, ShaderHandle _fsh, bool _destroyShaders = false);
 
 	/// Destroy program.
 	void destroyProgram(ProgramHandle _handle);

src/bgfx.cpp

@@ -323,7 +323,7 @@ namespace bgfx
 #else
 		mem = makeRef(vs_debugfont_glsl, sizeof(vs_debugfont_glsl) );
 #endif // BGFX_CONFIG_RENDERER_
-		VertexShaderHandle vsh = createVertexShader(mem);
+		ShaderHandle vsh = createShader(mem);
 
 #if BGFX_CONFIG_RENDERER_DIRECT3D9
 		mem = makeRef(fs_debugfont_dx9, sizeof(fs_debugfont_dx9) );
@@ -332,11 +332,9 @@ namespace bgfx
 #else
 		mem = makeRef(fs_debugfont_glsl, sizeof(fs_debugfont_glsl) );
 #endif // BGFX_CONFIG_RENDERER_
-		FragmentShaderHandle fsh = createFragmentShader(mem);
+		ShaderHandle fsh = createShader(mem);
 
-		m_program = createProgram(vsh, fsh);
-		destroyVertexShader(vsh);
-		destroyFragmentShader(fsh);
+		m_program = createProgram(vsh, fsh, true);
 
 		m_vb = s_ctx->createTransientVertexBuffer(numBatchVertices*m_decl.m_stride, &m_decl);
 		m_ib = s_ctx->createTransientIndexBuffer(numBatchIndices*2);
@@ -472,7 +470,7 @@ namespace bgfx
 		m_decl.add(Attrib::Color0, 4, AttribType::Uint8, true);
 		m_decl.end();
 
-		VertexShaderHandle vsh = createVertexShader(
+		ShaderHandle vsh = createShader(
 #	if BGFX_CONFIG_RENDERER_DIRECT3D11
 			makeRef(vs_clear_dx11, sizeof(vs_clear_dx11) )
 #	elif BGFX_CONFIG_RENDERER_OPENGL
@@ -495,12 +493,12 @@ namespace bgfx
 
 		for (uint32_t ii = 0; ii < BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS; ++ii)
 		{
-			FragmentShaderHandle fsh = createFragmentShader(fragMem[ii]);
+			ShaderHandle fsh = createShader(fragMem[ii]);
 			m_program[ii] = createProgram(vsh, fsh);
-			destroyFragmentShader(fsh);
+			destroyShader(fsh);
 		}
 
-		destroyVertexShader(vsh);
+		destroyShader(vsh);
 
 		m_vb = s_ctx->createTransientVertexBuffer(4*m_decl.m_stride, &m_decl);
 
@@ -1008,8 +1006,7 @@ namespace bgfx
 		CHECK_HANDLE_LEAK(m_indexBufferHandle);
 		CHECK_HANDLE_LEAK(m_vertexDeclHandle);
 		CHECK_HANDLE_LEAK(m_vertexBufferHandle);
-		CHECK_HANDLE_LEAK(m_vertexShaderHandle);
-		CHECK_HANDLE_LEAK(m_fragmentShaderHandle);
+		CHECK_HANDLE_LEAK(m_shaderHandle);
 		CHECK_HANDLE_LEAK(m_programHandle);
 		CHECK_HANDLE_LEAK(m_textureHandle);
 		CHECK_HANDLE_LEAK(m_frameBufferHandle);
@@ -1051,14 +1048,9 @@ namespace bgfx
 			destroyVertexBufferInternal(_frame->m_freeVertexBufferHandle[ii]);
 		}
 
-		for (uint16_t ii = 0, num = _frame->m_numFreeVertexShaderHandles; ii < num; ++ii)
+		for (uint16_t ii = 0, num = _frame->m_numFreeShaderHandles; ii < num; ++ii)
 		{
-			m_vertexShaderHandle.free(_frame->m_freeVertexShaderHandle[ii].idx);
-		}
-
-		for (uint16_t ii = 0, num = _frame->m_numFreeFragmentShaderHandles; ii < num; ++ii)
-		{
-			m_fragmentShaderHandle.free(_frame->m_freeFragmentShaderHandle[ii].idx);
+			m_shaderHandle.free(_frame->m_freeShaderHandle[ii].idx);
 		}
 
 		for (uint16_t ii = 0, num = _frame->m_numFreeProgramHandles; ii < num; ++ii)
@@ -1433,49 +1425,26 @@ namespace bgfx
 				}
 				break;
 
-			case CommandBuffer::CreateVertexShader:
+			case CommandBuffer::CreateShader:
 				{
-					VertexShaderHandle handle;
+					ShaderHandle handle;
 					_cmdbuf.read(handle);
 
 					Memory* mem;
 					_cmdbuf.read(mem);
 
-					rendererCreateVertexShader(handle, mem);
+					rendererCreateShader(handle, mem);
 
 					release(mem);
 				}
 				break;
 
-			case CommandBuffer::DestroyVertexShader:
+			case CommandBuffer::DestroyShader:
 				{
-					VertexShaderHandle handle;
+					ShaderHandle handle;
 					_cmdbuf.read(handle);
 
-					rendererDestroyVertexShader(handle);
-				}
-				break;
-
-			case CommandBuffer::CreateFragmentShader:
-				{
-					FragmentShaderHandle handle;
-					_cmdbuf.read(handle);
-
-					Memory* mem;
-					_cmdbuf.read(mem);
-
-					rendererCreateFragmentShader(handle, mem);
-
-					release(mem);
-				}
-				break;
-
-			case CommandBuffer::DestroyFragmentShader:
-				{
-					FragmentShaderHandle handle;
-					_cmdbuf.read(handle);
-
-					rendererDestroyFragmentShader(handle);
+					rendererDestroyShader(handle);
 				}
 				break;
 
@@ -1484,10 +1453,10 @@ namespace bgfx
 					ProgramHandle handle;
 					_cmdbuf.read(handle);
 
-					VertexShaderHandle vsh;
+					ShaderHandle vsh;
 					_cmdbuf.read(vsh);
 
-					FragmentShaderHandle fsh;
+					ShaderHandle fsh;
 					_cmdbuf.read(fsh);
 
 					rendererCreateProgram(handle, vsh, fsh);
@@ -1853,41 +1822,28 @@ namespace bgfx
 		return s_ctx->allocInstanceDataBuffer(_num, _stride);
 	}
 
-	VertexShaderHandle createVertexShader(const Memory* _mem)
-	{
-		BGFX_CHECK_MAIN_THREAD();
-		BX_CHECK(NULL != _mem, "_mem can't be NULL");
-		return s_ctx->createVertexShader(_mem);
-	}
-
-	void destroyVertexShader(VertexShaderHandle _handle)
-	{
-		BGFX_CHECK_MAIN_THREAD();
-		s_ctx->destroyVertexShader(_handle);
-	}
-
-	FragmentShaderHandle createFragmentShader(const Memory* _mem)
+	ShaderHandle createShader(const Memory* _mem)
 	{
 		BGFX_CHECK_MAIN_THREAD();
 		BX_CHECK(NULL != _mem, "_mem can't be NULL");
-		return s_ctx->createFragmentShader(_mem);
+		return s_ctx->createShader(_mem);
 	}
 
-	void destroyFragmentShader(FragmentShaderHandle _handle)
+	void destroyShader(ShaderHandle _handle)
 	{
 		BGFX_CHECK_MAIN_THREAD();
-		s_ctx->destroyFragmentShader(_handle);
+		s_ctx->destroyShader(_handle);
 	}
 
-	ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh, bool _destroyShaders)
+	ProgramHandle createProgram(ShaderHandle _vsh, ShaderHandle _fsh, bool _destroyShaders)
 	{
 		BGFX_CHECK_MAIN_THREAD();
 		ProgramHandle handle = s_ctx->createProgram(_vsh, _fsh);
 
 		if (_destroyShaders)
 		{
-			destroyVertexShader(_vsh);
-			destroyFragmentShader(_fsh);
+			destroyShader(_vsh);
+			destroyShader(_fsh);
 		}
 
 		return handle;

src/bgfx_p.h

@@ -505,8 +505,7 @@ namespace bgfx
 			UpdateDynamicIndexBuffer,
 			CreateDynamicVertexBuffer,
 			UpdateDynamicVertexBuffer,
-			CreateVertexShader,
-			CreateFragmentShader,
+			CreateShader,
 			CreateProgram,
 			CreateTexture,
 			UpdateTexture,
@@ -520,8 +519,7 @@ namespace bgfx
 			DestroyVertexBuffer,
 			DestroyDynamicIndexBuffer,
 			DestroyDynamicVertexBuffer,
-			DestroyVertexShader,
-			DestroyFragmentShader,
+			DestroyShader,
 			DestroyProgram,
 			DestroyTexture,
 			DestroyFrameBuffer,
@@ -1257,16 +1255,10 @@ namespace bgfx
 			++m_numFreeVertexBufferHandles;
 		}
 
-		void free(VertexShaderHandle _handle)
+		void free(ShaderHandle _handle)
 		{
-			m_freeVertexShaderHandle[m_numFreeVertexShaderHandles] = _handle;
-			++m_numFreeVertexShaderHandles;
-		}
-
-		void free(FragmentShaderHandle _handle)
-		{
-			m_freeFragmentShaderHandle[m_numFreeFragmentShaderHandles] = _handle;
-			++m_numFreeFragmentShaderHandles;
+			m_freeShaderHandle[m_numFreeShaderHandles] = _handle;
+			++m_numFreeShaderHandles;
 		}
 
 		void free(ProgramHandle _handle)
@@ -1299,8 +1291,7 @@ namespace bgfx
 			m_numFreeVertexDeclHandles = 0;
 			m_numFreeVertexBufferHandles = 0;
 			m_numFreeVertexShaderHandles = 0;
-			m_numFreeFragmentShaderHandles = 0;
-			m_numFreeFragmentShaderHandles = 0;
+			m_numFreeShaderHandles = 0;
 			m_numFreeProgramHandles = 0;
 			m_numFreeTextureHandles = 0;
 			m_numFreeFrameBufferHandles = 0;
@@ -1347,7 +1338,7 @@ namespace bgfx
 		uint16_t m_numFreeVertexDeclHandles;
 		uint16_t m_numFreeVertexBufferHandles;
 		uint16_t m_numFreeVertexShaderHandles;
-		uint16_t m_numFreeFragmentShaderHandles;
+		uint16_t m_numFreeShaderHandles;
 		uint16_t m_numFreeProgramHandles;
 		uint16_t m_numFreeTextureHandles;
 		uint16_t m_numFreeFrameBufferHandles;
@@ -1356,8 +1347,7 @@ namespace bgfx
 		IndexBufferHandle m_freeIndexBufferHandle[BGFX_CONFIG_MAX_INDEX_BUFFERS];
 		VertexDeclHandle m_freeVertexDeclHandle[BGFX_CONFIG_MAX_VERTEX_DECLS];
 		VertexBufferHandle m_freeVertexBufferHandle[BGFX_CONFIG_MAX_VERTEX_BUFFERS];
-		VertexShaderHandle m_freeVertexShaderHandle[BGFX_CONFIG_MAX_VERTEX_SHADERS];
-		FragmentShaderHandle m_freeFragmentShaderHandle[BGFX_CONFIG_MAX_FRAGMENT_SHADERS];
+		ShaderHandle m_freeShaderHandle[BGFX_CONFIG_MAX_SHADERS];
 		ProgramHandle m_freeProgramHandle[BGFX_CONFIG_MAX_PROGRAMS];
 		TextureHandle m_freeTextureHandle[BGFX_CONFIG_MAX_TEXTURES];
 		FrameBufferHandle m_freeFrameBufferHandle[BGFX_CONFIG_MAX_FRAME_BUFFERS];
@@ -1979,90 +1969,31 @@ namespace bgfx
 			return idb;
 		}
 
-		BGFX_API_FUNC(VertexShaderHandle createVertexShader(const Memory* _mem) )
+		BGFX_API_FUNC(ShaderHandle createShader(const Memory* _mem) )
 		{
 			bx::MemoryReader reader(_mem->data, _mem->size);
 
 			uint32_t magic;
 			bx::read(&reader, magic);
 
-			if (BGFX_CHUNK_MAGIC_VSH != magic)
+			if (BGFX_CHUNK_MAGIC_VSH != magic
+			&&  BGFX_CHUNK_MAGIC_FSH != magic)
 			{
-				BX_WARN(false, "Invalid vertex shader signature! 0x%08x", magic);
-				VertexShaderHandle invalid = BGFX_INVALID_HANDLE;
+				BX_WARN(false, "Invalid shader signature! 0x%08x", magic);
+				ShaderHandle invalid = BGFX_INVALID_HANDLE;
 				return invalid;
 			}
 
-			VertexShaderHandle handle = { m_vertexShaderHandle.alloc() };
+			ShaderHandle handle = { m_shaderHandle.alloc() };
 
-			BX_WARN(isValid(handle), "Failed to allocate vertex shader handle.");
+			BX_WARN(isValid(handle), "Failed to allocate shader handle.");
 			if (isValid(handle) )
 			{
-				VertexShaderRef& vsr = m_vertexShaderRef[handle.idx];
-				vsr.m_refCount = 1;
-				bx::read(&reader, vsr.m_outputHash);
-
-				CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateVertexShader);
-				cmdbuf.write(handle);
-				cmdbuf.write(_mem);
-			}
-
-			return handle;
-		}
-
-		BGFX_API_FUNC(void destroyVertexShader(VertexShaderHandle _handle) )
-		{
-			if (!isValid(_handle) )
-			{
-				BX_WARN(false, "Passing invalid vertex shader handle to bgfx::destroyVertexShader");
-				return;
-			}
-
-			vertexShaderDecRef(_handle);
-		}
-
-		void vertexShaderIncRef(VertexShaderHandle _handle)
-		{
-			VertexShaderRef& vsr = m_vertexShaderRef[_handle.idx];
-			++vsr.m_refCount;
-		}
-
-		void vertexShaderDecRef(VertexShaderHandle _handle)
-		{
-			VertexShaderRef& vsr = m_vertexShaderRef[_handle.idx];
-			int32_t refs = --vsr.m_refCount;
-			if (0 == refs)
-			{
-				CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::DestroyVertexShader);
-				cmdbuf.write(_handle);
-				m_submit->free(_handle);
-			}
-		}
-
-		BGFX_API_FUNC(FragmentShaderHandle createFragmentShader(const Memory* _mem) )
-		{
-			bx::MemoryReader reader(_mem->data, _mem->size);
-
-			uint32_t magic;
-			bx::read(&reader, magic);
-
-			if (BGFX_CHUNK_MAGIC_FSH != magic)
-			{
-				BX_WARN(false, "Invalid fragment shader signature! 0x%08x", magic);
-				FragmentShaderHandle invalid = BGFX_INVALID_HANDLE;
-				return invalid;
-			}
-
-			FragmentShaderHandle handle = { m_fragmentShaderHandle.alloc() };
-
-			BX_WARN(isValid(handle), "Failed to allocate fragment shader handle.");
-			if (isValid(handle) )
-			{
-				FragmentShaderRef& fsr = m_fragmentShaderRef[handle.idx];
+				ShaderRef& fsr = m_shaderRef[handle.idx];
 				fsr.m_refCount = 1;
-				bx::read(&reader, fsr.m_inputHash);
+				bx::read(&reader, fsr.m_hash);
 
-				CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateFragmentShader);
+				CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateShader);
 				cmdbuf.write(handle);
 				cmdbuf.write(_mem);
 			}
@@ -2070,36 +2001,36 @@ namespace bgfx
 			return handle;
 		}
 
-		BGFX_API_FUNC(void destroyFragmentShader(FragmentShaderHandle _handle) )
+		BGFX_API_FUNC(void destroyShader(ShaderHandle _handle) )
 		{
 			if (!isValid(_handle) )
 			{
-				BX_WARN(false, "Passing invalid fragment shader handle to bgfx::destroyFragmentShader");
+				BX_WARN(false, "Passing invalid shader handle to bgfx::destroyShader");
 				return;
 			}
 
-			fragmentShaderDecRef(_handle);
+			shaderDecRef(_handle);
 		}
 
-		void fragmentShaderIncRef(FragmentShaderHandle _handle)
+		void shaderIncRef(ShaderHandle _handle)
 		{
-			FragmentShaderRef& fsr = m_fragmentShaderRef[_handle.idx];
-			++fsr.m_refCount;
+			ShaderRef& sr = m_shaderRef[_handle.idx];
+			++sr.m_refCount;
 		}
 
-		void fragmentShaderDecRef(FragmentShaderHandle _handle)
+		void shaderDecRef(ShaderHandle _handle)
 		{
-			FragmentShaderRef& fsr = m_fragmentShaderRef[_handle.idx];
-			int32_t refs = --fsr.m_refCount;
+			ShaderRef& sr = m_shaderRef[_handle.idx];
+			int32_t refs = --sr.m_refCount;
 			if (0 == refs)
 			{
-				CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::DestroyFragmentShader);
+				CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::DestroyShader);
 				cmdbuf.write(_handle);
 				m_submit->free(_handle);
 			}
 		}
 
-		BGFX_API_FUNC(ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh) )
+		BGFX_API_FUNC(ProgramHandle createProgram(ShaderHandle _vsh, ShaderHandle _fsh) )
 		{
 			if (!isValid(_vsh)
 			||  !isValid(_fsh) )
@@ -2109,11 +2040,11 @@ namespace bgfx
 				return invalid;
 			}
 
-			const VertexShaderRef& vsr = m_vertexShaderRef[_vsh.idx];
-			const FragmentShaderRef& fsr = m_fragmentShaderRef[_fsh.idx];
-			if (vsr.m_outputHash != fsr.m_inputHash)
+			const ShaderRef& vsr = m_shaderRef[_vsh.idx];
+			const ShaderRef& fsr = m_shaderRef[_fsh.idx];
+			if (vsr.m_hash != fsr.m_hash)
 			{
-				BX_WARN(vsr.m_outputHash == fsr.m_inputHash, "Vertex shader output doesn't match fragment shader input.");
+				BX_WARN(vsr.m_hash == fsr.m_hash, "Vertex shader output doesn't match fragment shader input.");
 				ProgramHandle invalid = BGFX_INVALID_HANDLE;
 				return invalid;
 			}
@@ -2124,8 +2055,8 @@ namespace bgfx
 			BX_WARN(isValid(handle), "Failed to allocate program handle.");
 			if (isValid(handle) )
 			{
-				vertexShaderIncRef(_vsh);
-				fragmentShaderIncRef(_fsh);
+				shaderIncRef(_vsh);
+				shaderIncRef(_fsh);
 				m_programRef[handle.idx].m_vsh = _vsh;
 				m_programRef[handle.idx].m_fsh = _fsh;
 
@@ -2144,8 +2075,8 @@ namespace bgfx
 			cmdbuf.write(_handle);
 			m_submit->free(_handle);
 
-			vertexShaderDecRef(m_programRef[_handle.idx].m_vsh);
-			fragmentShaderDecRef(m_programRef[_handle.idx].m_fsh);
+			shaderDecRef(m_programRef[_handle.idx].m_vsh);
+			shaderDecRef(m_programRef[_handle.idx].m_fsh);
 		}
 
 		BGFX_API_FUNC(TextureHandle createTexture(const Memory* _mem, uint32_t _flags, uint8_t _skip, TextureInfo* _info) )
@@ -2632,11 +2563,9 @@ namespace bgfx
 		void rendererDestroyDynamicVertexBuffer(VertexBufferHandle _handle);
 		void rendererCreateVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl);
 		void rendererDestroyVertexDecl(VertexDeclHandle _handle);
-		void rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem);
-		void rendererDestroyVertexShader(VertexShaderHandle _handle);
-		void rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem);
-		void rendererDestroyFragmentShader(FragmentShaderHandle _handle);
-		void rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh);
+		void rendererCreateShader(ShaderHandle _handle, Memory* _mem);
+		void rendererDestroyShader(ShaderHandle _handle);
+		void rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh);
 		void rendererDestroyProgram(ProgramHandle _handle);
 		void rendererCreateTexture(TextureHandle _handle, Memory* _mem, uint32_t _flags, uint8_t _skip);
 		void rendererUpdateTextureBegin(TextureHandle _handle, uint8_t _side, uint8_t _mip);
@@ -2728,29 +2657,22 @@ namespace bgfx
 		bx::HandleAllocT<BGFX_CONFIG_MAX_VERTEX_DECLS > m_vertexDeclHandle;
 
 		bx::HandleAllocT<BGFX_CONFIG_MAX_VERTEX_BUFFERS> m_vertexBufferHandle;
-		bx::HandleAllocT<BGFX_CONFIG_MAX_VERTEX_SHADERS> m_vertexShaderHandle;
-		bx::HandleAllocT<BGFX_CONFIG_MAX_FRAGMENT_SHADERS> m_fragmentShaderHandle;
+		bx::HandleAllocT<BGFX_CONFIG_MAX_SHADERS> m_shaderHandle;
 		bx::HandleAllocT<BGFX_CONFIG_MAX_PROGRAMS> m_programHandle;
 		bx::HandleAllocT<BGFX_CONFIG_MAX_TEXTURES> m_textureHandle;
 		bx::HandleAllocT<BGFX_CONFIG_MAX_FRAME_BUFFERS> m_frameBufferHandle;
 		bx::HandleAllocT<BGFX_CONFIG_MAX_UNIFORMS> m_uniformHandle;
 
-		struct FragmentShaderRef
+		struct ShaderRef
 		{
-			uint32_t m_inputHash;
+			uint32_t m_hash;
 			int16_t m_refCount;
 		};
 		
-		struct VertexShaderRef
-		{
-			uint32_t m_outputHash;
-			int16_t m_refCount;
-		};
-
 		struct ProgramRef
 		{
-			VertexShaderHandle m_vsh;
-			FragmentShaderHandle m_fsh;
+			ShaderHandle m_vsh;
+			ShaderHandle m_fsh;
 		};
 
 		struct UniformRef
@@ -2773,8 +2695,7 @@ namespace bgfx
 		typedef stl::unordered_map<stl::string, UniformHandle> UniformHashMap;
 		UniformHashMap m_uniformHashMap;
 		UniformRef m_uniformRef[BGFX_CONFIG_MAX_UNIFORMS];
-		VertexShaderRef m_vertexShaderRef[BGFX_CONFIG_MAX_VERTEX_SHADERS];
-		FragmentShaderRef m_fragmentShaderRef[BGFX_CONFIG_MAX_FRAGMENT_SHADERS];
+		ShaderRef m_shaderRef[BGFX_CONFIG_MAX_SHADERS];
 		ProgramRef m_programRef[BGFX_CONFIG_MAX_PROGRAMS];
 		TextureRef m_textureRef[BGFX_CONFIG_MAX_TEXTURES];
 		FrameBufferRef m_frameBufferRef[BGFX_CONFIG_MAX_FRAME_BUFFERS];

src/config.h

@@ -167,12 +167,8 @@
 #	define BGFX_CONFIG_DYNAMIC_VERTEX_BUFFER_SIZE (3<<20)
 #endif // BGFX_CONFIG_DYNAMIC_VERTEX_BUFFER_SIZE
 
-#ifndef BGFX_CONFIG_MAX_VERTEX_SHADERS
-#	define BGFX_CONFIG_MAX_VERTEX_SHADERS 256
-#endif // BGFX_CONFIG_MAX_VERTEX_SHADERS
-
-#ifndef BGFX_CONFIG_MAX_FRAGMENT_SHADERS
-#	define BGFX_CONFIG_MAX_FRAGMENT_SHADERS 256
+#ifndef BGFX_CONFIG_MAX_SHADERS
+#	define BGFX_CONFIG_MAX_SHADERS 512
 #endif // BGFX_CONFIG_MAX_FRAGMENT_SHADERS
 
 #ifndef BGFX_CONFIG_MAX_PROGRAMS

src/renderer_d3d11.cpp

@@ -541,14 +541,9 @@ namespace bgfx
 				m_vertexBuffers[ii].destroy();
 			}
 
-			for (uint32_t ii = 0; ii < BX_COUNTOF(m_vertexShaders); ++ii)
+			for (uint32_t ii = 0; ii < BX_COUNTOF(m_shaders); ++ii)
 			{
-				m_vertexShaders[ii].destroy();
-			}
-
-			for (uint32_t ii = 0; ii < BX_COUNTOF(m_fragmentShaders); ++ii)
-			{
-				m_fragmentShaders[ii].destroy();
+				m_shaders[ii].destroy();
 			}
 
 			for (uint32_t ii = 0; ii < BX_COUNTOF(m_textures); ++ii)
@@ -1275,8 +1270,7 @@ namespace bgfx
 
 		IndexBuffer m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];
 		VertexBuffer m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS];
-		Shader m_vertexShaders[BGFX_CONFIG_MAX_VERTEX_SHADERS];
-		Shader m_fragmentShaders[BGFX_CONFIG_MAX_FRAGMENT_SHADERS];
+		Shader m_shaders[BGFX_CONFIG_MAX_SHADERS];
 		Program m_program[BGFX_CONFIG_MAX_PROGRAMS];
 		Texture m_textures[BGFX_CONFIG_MAX_TEXTURES];
 		VertexDecl m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS];
@@ -1653,13 +1647,26 @@ namespace bgfx
 		}
 	}
 
-	void Shader::create(bool _fragment, const Memory* _mem)
+	void Shader::create(const Memory* _mem)
 	{
 		bx::MemoryReader reader(_mem->data, _mem->size);
 
 		uint32_t magic;
 		bx::read(&reader, magic);
 
+		switch (magic)
+		{
+		case BGFX_CHUNK_MAGIC_FSH:
+		case BGFX_CHUNK_MAGIC_VSH:
+			break;
+
+		default:
+			BGFX_FATAL(false, Fatal::InvalidShader, "Unknown shader format %x.", magic);
+			break;
+		}
+
+		bool fragment = BGFX_CHUNK_MAGIC_FSH == magic;
+
 		uint32_t iohash;
 		bx::read(&reader, iohash);
 
@@ -1688,7 +1695,7 @@ namespace bgfx
 
 		BX_TRACE("Shader consts %d", count);
 
-		uint8_t fragmentBit = _fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0;
+		uint8_t fragmentBit = fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0;
 
 		if (0 < count)
 		{
@@ -1759,7 +1766,7 @@ namespace bgfx
 		const DWORD* code = (const DWORD*)reader.getDataPtr();
 		bx::skip(&reader, shaderSize);
 
-		if (_fragment)
+		if (fragment)
 		{
 			DX_CHECK(s_renderCtx->m_device->CreatePixelShader(code, shaderSize, NULL, (ID3D11PixelShader**)&m_ptr) );
 			BGFX_FATAL(NULL != m_ptr, bgfx::Fatal::InvalidShader, "Failed to create fragment shader.");
@@ -2223,29 +2230,19 @@ namespace bgfx
 		s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
 	}
 
-	void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem)
-	{
-		s_renderCtx->m_vertexShaders[_handle.idx].create(false, _mem);
-	}
-
-	void Context::rendererDestroyVertexShader(VertexShaderHandle _handle)
-	{
-		s_renderCtx->m_vertexShaders[_handle.idx].destroy();
-	}
-
-	void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem)
+	void Context::rendererCreateShader(ShaderHandle _handle, Memory* _mem)
 	{
-		s_renderCtx->m_fragmentShaders[_handle.idx].create(true, _mem);
+		s_renderCtx->m_shaders[_handle.idx].create(_mem);
 	}
 
-	void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle)
+	void Context::rendererDestroyShader(ShaderHandle _handle)
 	{
-		s_renderCtx->m_fragmentShaders[_handle.idx].destroy();
+		s_renderCtx->m_shaders[_handle.idx].destroy();
 	}
 
-	void Context::rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh)
+	void Context::rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh)
 	{
-		s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_vertexShaders[_vsh.idx], s_renderCtx->m_fragmentShaders[_fsh.idx]);
+		s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_shaders[_vsh.idx], s_renderCtx->m_shaders[_fsh.idx]);
 	}
 
 	void Context::rendererDestroyProgram(ProgramHandle _handle)

src/renderer_d3d11.h

@@ -149,7 +149,7 @@ namespace bgfx
 		{
 		}
 
-		void create(bool _fragment, const Memory* _mem);
+		void create(const Memory* _mem);
 		DWORD* getShaderCode(uint8_t _fragmentBit, const Memory* _mem);
 
 		void destroy()

src/renderer_d3d9.cpp

@@ -523,14 +523,9 @@ namespace bgfx
 				m_vertexBuffers[ii].destroy();
 			}
 
-			for (uint32_t ii = 0; ii < BX_COUNTOF(m_vertexShaders); ++ii)
+			for (uint32_t ii = 0; ii < BX_COUNTOF(m_shaders); ++ii)
 			{
-				m_vertexShaders[ii].destroy();
-			}
-
-			for (uint32_t ii = 0; ii < BX_COUNTOF(m_fragmentShaders); ++ii)
-			{
-				m_fragmentShaders[ii].destroy();
+				m_shaders[ii].destroy();
 			}
 
 			for (uint32_t ii = 0; ii < BX_COUNTOF(m_textures); ++ii)
@@ -1031,8 +1026,7 @@ namespace bgfx
 
 		IndexBuffer m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];
 		VertexBuffer m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS];
-		Shader m_vertexShaders[BGFX_CONFIG_MAX_VERTEX_SHADERS];
-		Shader m_fragmentShaders[BGFX_CONFIG_MAX_FRAGMENT_SHADERS];
+		Shader m_shaders[BGFX_CONFIG_MAX_SHADERS];
 		Program m_program[BGFX_CONFIG_MAX_PROGRAMS];
 		Texture m_textures[BGFX_CONFIG_MAX_TEXTURES];
 		VertexDeclaration m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS];
@@ -1259,13 +1253,26 @@ namespace bgfx
 		m_ptr = createVertexDecl(_decl, 0);
 	}
 
-	void Shader::create(bool _fragment, const Memory* _mem)
+	void Shader::create(const Memory* _mem)
 	{
 		bx::MemoryReader reader(_mem->data, _mem->size);
 
 		uint32_t magic;
 		bx::read(&reader, magic);
 
+		switch (magic)
+		{
+		case BGFX_CHUNK_MAGIC_FSH:
+		case BGFX_CHUNK_MAGIC_VSH:
+			break;
+
+		default:
+			BGFX_FATAL(false, Fatal::InvalidShader, "Unknown shader format %x.", magic);
+			break;
+		}
+
+		bool fragment = BGFX_CHUNK_MAGIC_FSH == magic;
+
 		uint32_t iohash;
 		bx::read(&reader, iohash);
 
@@ -1276,7 +1283,7 @@ namespace bgfx
 
 		BX_TRACE("Shader consts %d", count);
 
-		uint8_t fragmentBit = _fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0;
+		uint8_t fragmentBit = fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0;
 
 		if (0 < count)
 		{
@@ -1346,7 +1353,7 @@ namespace bgfx
 
 		const DWORD* code = (const DWORD*)reader.getDataPtr();
 
-		if (_fragment)
+		if (fragment)
 		{
 			DX_CHECK(s_renderCtx->m_device->CreatePixelShader(code, (IDirect3DPixelShader9**)&m_ptr) );
 			BGFX_FATAL(NULL != m_ptr, bgfx::Fatal::InvalidShader, "Failed to create fragment shader.");
@@ -2241,29 +2248,19 @@ namespace bgfx
 		s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
 	}
 
-	void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem)
-	{
-		s_renderCtx->m_vertexShaders[_handle.idx].create(false, _mem);
-	}
-
-	void Context::rendererDestroyVertexShader(VertexShaderHandle _handle)
-	{
-		s_renderCtx->m_vertexShaders[_handle.idx].destroy();
-	}
-
-	void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem)
+	void Context::rendererCreateShader(ShaderHandle _handle, Memory* _mem)
 	{
-		s_renderCtx->m_fragmentShaders[_handle.idx].create(true, _mem);
+		s_renderCtx->m_shaders[_handle.idx].create(_mem);
 	}
 
-	void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle)
+	void Context::rendererDestroyShader(ShaderHandle _handle)
 	{
-		s_renderCtx->m_fragmentShaders[_handle.idx].destroy();
+		s_renderCtx->m_shaders[_handle.idx].destroy();
 	}
 
-	void Context::rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh)
+	void Context::rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh)
 	{
-		s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_vertexShaders[_vsh.idx], s_renderCtx->m_fragmentShaders[_fsh.idx]);
+		s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_shaders[_vsh.idx], s_renderCtx->m_shaders[_fsh.idx]);
 	}
 
 	void Context::rendererDestroyProgram(ProgramHandle _handle)

src/renderer_d3d9.h

@@ -224,7 +224,7 @@ namespace bgfx
 		{
 		}
 
-		void create(bool _fragment, const Memory* _mem);
+		void create(const Memory* _mem);
 		DWORD* getShaderCode(uint8_t _fragmentBit, const Memory* _mem);
 
 		void destroy()

src/renderer_gl.cpp

@@ -1444,8 +1444,7 @@ namespace bgfx
 
 		IndexBuffer m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];
 		VertexBuffer m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS];
-		Shader m_vertexShaders[BGFX_CONFIG_MAX_VERTEX_SHADERS];
-		Shader m_fragmentShaders[BGFX_CONFIG_MAX_FRAGMENT_SHADERS];
+		Shader m_shaders[BGFX_CONFIG_MAX_SHADERS];
 		Program m_program[BGFX_CONFIG_MAX_PROGRAMS];
 		Texture m_textures[BGFX_CONFIG_MAX_TEXTURES];
 		VertexDecl m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS];
@@ -2427,20 +2426,34 @@ namespace bgfx
 		memcpy(_str, _insert, len);
 	}
 
-	void Shader::create(GLenum _type, Memory* _mem)
+	void Shader::create(Memory* _mem)
 	{
-		m_id = glCreateShader(_type);
-		m_type = _type;
-
 		bx::MemoryReader reader(_mem->data, _mem->size);
 		m_hash = bx::hashMurmur2A(_mem->data, _mem->size);
 
 		uint32_t magic;
 		bx::read(&reader, magic);
 
+		switch (magic)
+		{
+		case BGFX_CHUNK_MAGIC_FSH:
+			m_type = GL_FRAGMENT_SHADER;
+			break;
+
+		case BGFX_CHUNK_MAGIC_VSH:
+			m_type = GL_VERTEX_SHADER;
+			break;
+
+		default:
+			BGFX_FATAL(false, Fatal::InvalidShader, "Unknown shader format %x.", magic);
+			break;
+		}
+
 		uint32_t iohash;
 		bx::read(&reader, iohash);
 
+		m_id = glCreateShader(m_type);
+
 		const char* code = (const char*)reader.getDataPtr();
 
 		if (0 != m_id)
@@ -2580,7 +2593,7 @@ namespace bgfx
 				if (usesTextureLod)
 				{
 					writeString(&writer, "#version 120\n");
-					if (_type == GL_FRAGMENT_SHADER)
+					if (m_type == GL_FRAGMENT_SHADER)
 					{
 						writeString(&writer, "#extension GL_ARB_shader_texture_lod : enable\n");
 					}
@@ -2610,7 +2623,7 @@ namespace bgfx
 					writeString(&writer, "#version 140\n");
 				}
 
-				if (_type == GL_FRAGMENT_SHADER)
+				if (m_type == GL_FRAGMENT_SHADER)
 				{
 					writeString(&writer, "#define varying in\n");
 					writeString(&writer, "#define texture2D texture\n");
@@ -3208,30 +3221,20 @@ namespace bgfx
 		s_renderCtx->m_vertexBuffers[_handle.idx].destroy();
 	}
 
-	void Context::rendererCreateVertexShader(VertexShaderHandle _handle, Memory* _mem)
-	{
-		s_renderCtx->m_vertexShaders[_handle.idx].create(GL_VERTEX_SHADER, _mem);
-	}
-
-	void Context::rendererDestroyVertexShader(VertexShaderHandle _handle)
-	{
-		s_renderCtx->m_vertexShaders[_handle.idx].destroy();
-	}
-
-	void Context::rendererCreateFragmentShader(FragmentShaderHandle _handle, Memory* _mem)
+	void Context::rendererCreateShader(ShaderHandle _handle, Memory* _mem)
 	{
-		s_renderCtx->m_fragmentShaders[_handle.idx].create(GL_FRAGMENT_SHADER, _mem);
+		s_renderCtx->m_shaders[_handle.idx].create(_mem);
 	}
 
-	void Context::rendererDestroyFragmentShader(FragmentShaderHandle _handle)
+	void Context::rendererDestroyShader(ShaderHandle _handle)
 	{
-		s_renderCtx->m_fragmentShaders[_handle.idx].destroy();
+		s_renderCtx->m_shaders[_handle.idx].destroy();
 	}
 
-	void Context::rendererCreateProgram(ProgramHandle _handle, VertexShaderHandle _vsh, FragmentShaderHandle _fsh)
+	void Context::rendererCreateProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh)
 	{
 		Shader dummyFragmentShader;
-		s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_vertexShaders[_vsh.idx], isValid(_fsh) ? s_renderCtx->m_fragmentShaders[_fsh.idx] : dummyFragmentShader);
+		s_renderCtx->m_program[_handle.idx].create(s_renderCtx->m_shaders[_vsh.idx], isValid(_fsh) ? s_renderCtx->m_shaders[_fsh.idx] : dummyFragmentShader);
 	}
 
 	void Context::rendererDestroyProgram(ProgramHandle _handle)

src/renderer_gl.h

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

src/renderer_null.cpp

@@ -81,23 +81,15 @@ namespace bgfx
 	{
 	}
 
-	void Context::rendererCreateVertexShader(VertexShaderHandle /*_handle*/, Memory* /*_mem*/)
+	void Context::rendererCreateShader(ShaderHandle /*_handle*/, Memory* /*_mem*/)
 	{
 	}
 
-	void Context::rendererDestroyVertexShader(VertexShaderHandle /*_handle*/)
+	void Context::rendererDestroyShader(ShaderHandle /*_handle*/)
 	{
 	}
 
-	void Context::rendererCreateFragmentShader(FragmentShaderHandle /*_handle*/, Memory* /*_mem*/)
-	{
-	}
-
-	void Context::rendererDestroyFragmentShader(FragmentShaderHandle /*_handle*/)
-	{
-	}
-
-	void Context::rendererCreateProgram(ProgramHandle /*_handle*/, VertexShaderHandle /*_vsh*/, FragmentShaderHandle /*_fsh*/)
+	void Context::rendererCreateProgram(ProgramHandle /*_handle*/, ShaderHandle /*_vsh*/, ShaderHandle /*_fsh*/)
 	{
 	}