fteqw/engine/d3d/d3d11_shader.c

#include "quakedef.h"

#ifdef D3D11QUAKE
#include "shader.h"
#include "winquake.h"
#define COBJMACROS
#include <d3d11.h>
extern ID3D11Device *pD3DDev11;

//#include <D3D11Shader.h>	//apparently requires win8 sdk, despite being a win7 thing.

#ifndef IID_ID3DBlob
	//microsoft can be such a pain sometimes.
	typedef struct _D3D_SHADER_MACRO
	{
		LPCSTR Name;
		LPCSTR Definition;

	} D3D_SHADER_MACRO, *LPD3D_SHADER_MACRO;

	typedef enum _D3D_INCLUDE_TYPE { 
	  D3D_INCLUDE_LOCAL         = 0,
	  D3D_INCLUDE_SYSTEM        = ( D3D_INCLUDE_LOCAL + 1 ),
	  D3D_INCLUDE_FORCE_DWORD   = 0x7fffffff 
	} D3D_INCLUDE_TYPE;

	#undef INTERFACE
	#define INTERFACE ID3DInclude
	DECLARE_INTERFACE_(INTERFACE, IUnknown)
	{
		STDMETHOD(Open)(THIS_ D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) PURE;
		STDMETHOD(Close)(THIS_ LPCVOID pData) PURE;
	};

	#undef INTERFACE
	#define INTERFACE ID3DBlob
	DECLARE_INTERFACE_(INTERFACE, IUnknown)
	{
		STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
		STDMETHOD_(ULONG, AddRef)(THIS) PURE;
		STDMETHOD_(ULONG, Release)(THIS) PURE;
		STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;
		STDMETHOD_(SIZE_T, GetBufferSize)(THIS) PURE;
	};
	#undef INTERFACE

	#define D3D11_SHADER_VARIABLE_DESC void
	typedef unsigned int D3D_SHADER_INPUT_TYPE;
	typedef unsigned int D3D_RESOURCE_RETURN_TYPE;
	typedef unsigned int D3D_SRV_DIMENSION;
	typedef struct D3D11_SHADER_INPUT_BIND_DESC {
		LPCSTR						Name;
		D3D_SHADER_INPUT_TYPE		Type;
		UINT						BindPoint;
		UINT						BindCount;
		UINT						uFlags;
		D3D_RESOURCE_RETURN_TYPE	ReturnType;
		D3D_SRV_DIMENSION			Dimension;
		UINT						NumSamples;
	} D3D11_SHADER_INPUT_BIND_DESC;
	#define ID3D11ShaderReflectionConstantBuffer void
	#define ID3D11ShaderReflectionType void
	#define INTERFACE ID3D11ShaderReflectionVariable
	DECLARE_INTERFACE(ID3D11ShaderReflectionVariable)
	{
		STDMETHOD(GetDesc)(THIS_ D3D11_SHADER_VARIABLE_DESC *pDesc) PURE;

		STDMETHOD_(ID3D11ShaderReflectionType*, GetType)(THIS) PURE;
		STDMETHOD_(ID3D11ShaderReflectionConstantBuffer*, GetBuffer)(THIS) PURE;

		STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ UINT uArrayIndex) PURE;
	};
	#undef INTERFACE
	#define D3D11_SHADER_DESC void
	#define D3D11_SIGNATURE_PARAMETER_DESC void
	#define INTERFACE ID3D11ShaderReflection
	DECLARE_INTERFACE_(INTERFACE, IUnknown)
	{
		STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
		STDMETHOD_(ULONG, AddRef)(THIS) PURE;
		STDMETHOD_(ULONG, Release)(THIS) PURE;

		STDMETHOD(GetDesc)(THIS_ D3D11_SHADER_DESC *pDesc) PURE;

		STDMETHOD_(ID3D11ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ UINT Index) PURE;
		STDMETHOD_(ID3D11ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ LPCSTR Name) PURE;

		STDMETHOD(GetResourceBindingDesc)(THIS_ UINT ResourceIndex,
										  D3D11_SHADER_INPUT_BIND_DESC *pDesc) PURE;

		STDMETHOD(GetInputParameterDesc)(THIS_ UINT ParameterIndex,
										 D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
		STDMETHOD(GetOutputParameterDesc)(THIS_ UINT ParameterIndex,
										  D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
		STDMETHOD(GetPatchConstantParameterDesc)(THIS_ UINT ParameterIndex,
												 D3D11_SIGNATURE_PARAMETER_DESC *pDesc) PURE;

		STDMETHOD_(ID3D11ShaderReflectionVariable*, GetVariableByName)(THIS_ LPCSTR Name) PURE;
		STDMETHOD(GetResourceBindingDescByName)(THIS_ LPCSTR Name, D3D11_SHADER_INPUT_BIND_DESC *pDesc) PURE;
		//more stuff
	};
	#define ID3D11ShaderReflection_GetVariableByName(r,v) r->lpVtbl->GetVariableByName(r,v)
	#undef INTERFACE
#else
#include <d3d11shader.h>
#endif

const GUID IID_ID3D11ShaderReflection = {0x8d536ca1, 0x0cca, 0x4956, {0xa8, 0x37, 0x78, 0x69, 0x63, 0x75, 0x55, 0x84}};
#define ID3DBlob_GetBufferPointer(b) b->lpVtbl->GetBufferPointer(b)
#define ID3DBlob_Release(b) b->lpVtbl->Release(b)
#define ID3DBlob_GetBufferSize(b) b->lpVtbl->GetBufferSize(b)
#define ID3D11ShaderReflection_Release IUnknown_Release

HRESULT (WINAPI *pD3DCompile) (
	LPCVOID pSrcData,
	SIZE_T SrcDataSize,
	LPCSTR pSourceName,
	const D3D_SHADER_MACRO *pDefines,
	ID3DInclude *pInclude,
	LPCSTR pEntrypoint,
	LPCSTR pTarget,
	UINT Flags1,
	UINT Flags2,
	ID3DBlob **ppCode,
	ID3DBlob **ppErrorMsgs
);

HRESULT (WINAPI *pD3DReflect)(
	LPCVOID pSrcData,
	SIZE_T SrcDataSize,
	REFIID pInterface,
	void **ppReflector
);

static dllhandle_t *shaderlib;


D3D_FEATURE_LEVEL d3dfeaturelevel;


HRESULT STDMETHODCALLTYPE d3dinclude_Close(ID3DInclude *this, LPCVOID pData)
{
	free((void*)pData);
	return S_OK;
}
HRESULT STDMETHODCALLTYPE d3dinclude_Open(ID3DInclude *this, D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes)
{
	if (IncludeType == D3D_INCLUDE_SYSTEM)
	{
		if (!strcmp(pFileName, "ftedefs.h"))
		{
			static const char *defstruct =
				"cbuffer ftemodeldefs : register(b0)\n"
				"{\n"
					"matrix m_model;\n"
					"float3 e_eyepos; float e_time;\n"
					"float3 e_light_ambient; float pad1;\n"
					"float3 e_light_dir; float pad2;\n"
					"float3 e_light_mul; float pad3;\n"
					"float4 e_lmscale[4];\n"
				"};\n"
				"cbuffer fteviewdefs : register(b1)\n"
				"{\n"
					"matrix m_view;\n"
					"matrix m_projection;\n"
					"float3 v_eyepos; float v_time;\n"
				"};\n"
				"cbuffer ftelightdefs : register(b2)\n"
				"{\n"
					"matrix l_cubematrix;\n"
					"float3 l_lightposition; float padl1;\n"
					"float3 l_colour; float padl2;\n"
					"float3 l_lightcolourscale;float l_lightradius;\n"
					"float4 l_shadowmapproj;\n"
					"float2 l_shadowmapscale; float2 padl3;\n"
				"};\n"
				;
			*ppData = strdup(defstruct);
			*pBytes = strlen(*ppData);
			return S_OK;
		}
		if (!strcmp(pFileName, "sys/skeletal.h"))
		{
			static const char *defstruct =
				""
				;
			*ppData = strdup(defstruct);
			*pBytes = strlen(*ppData);
			return S_OK;
		}
	}
	else
	{
		
	}
	return E_FAIL;
}
ID3DIncludeVtbl myd3dincludetab =
{
	d3dinclude_Open,
	d3dinclude_Close
};
ID3DInclude myd3dinclude =
{
	&myd3dincludetab
};

void D3D11Shader_DeleteProg(program_t *prog)
{
	ID3D11InputLayout *layout;
	ID3D11PixelShader *frag;
	ID3D11VertexShader *vert;
	unsigned int permu;
	for (permu = 0; permu < countof(prog->permu); permu++)
	{
		vert = prog->permu[permu].h.hlsl.vert;
		frag = prog->permu[permu].h.hlsl.frag;
		layout = prog->permu[permu].h.hlsl.layout;
		if (vert)
			ID3D11VertexShader_Release(vert);
		if (frag)
			ID3D11PixelShader_Release(frag);
		if (layout)
			ID3D11InputLayout_Release(layout);
	}
}

//create a program from two blobs.
static qboolean D3D11Shader_CreateShaders(program_t *prog, const char *name, int permu, 
										  void *vblob, size_t vsize,
										  void *hblob, size_t hsize,
										  void *dblob, size_t dsize,
										  void *gblob, size_t gsize,
										  void *fblob, size_t fsize)
{
	qboolean success = true;

	if (FAILED(ID3D11Device_CreateVertexShader(pD3DDev11, vblob, vsize, NULL, (ID3D11VertexShader**)&prog->permu[permu].h.hlsl.vert)))
		success = false;

	if (hblob || dblob)
	{
		prog->permu[permu].h.hlsl.topology = D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST;
		if (FAILED(ID3D11Device_CreateHullShader(pD3DDev11, hblob, hsize, NULL, (ID3D11HullShader**)&prog->permu[permu].h.hlsl.hull)))
			success = false;

		if (FAILED(ID3D11Device_CreateDomainShader(pD3DDev11, dblob, dsize, NULL, (ID3D11DomainShader**)&prog->permu[permu].h.hlsl.domain)))
			success = false;
	}
	else
		prog->permu[permu].h.hlsl.topology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;

	if (gblob && FAILED(ID3D11Device_CreateGeometryShader(pD3DDev11, gblob, gsize, NULL, (ID3D11GeometryShader**)&prog->permu[permu].h.hlsl.geom)))
		success = false;

	if (FAILED(ID3D11Device_CreatePixelShader(pD3DDev11, fblob, fsize, NULL, (ID3D11PixelShader**)&prog->permu[permu].h.hlsl.frag)))
		success = false;

	if (success)
	{
		D3D11_INPUT_ELEMENT_DESC decl[13];
		int elements = 0;

		decl[elements].SemanticName = "POSITION";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R32G32B32_FLOAT;
		decl[elements].InputSlot = D3D11_BUFF_POS;
		decl[elements].AlignedByteOffset = 0;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

		decl[elements].SemanticName = "TEXCOORD";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R32G32_FLOAT;
		decl[elements].InputSlot = D3D11_BUFF_TC;
		decl[elements].AlignedByteOffset = 0;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

		decl[elements].SemanticName = "TEXCOORD";
		decl[elements].SemanticIndex = 1;
		decl[elements].Format = DXGI_FORMAT_R32G32_FLOAT;
		decl[elements].InputSlot = D3D11_BUFF_LMTC;
		decl[elements].AlignedByteOffset = 0;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

		decl[elements].SemanticName = "COLOR";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R8G8B8A8_UNORM;
		decl[elements].InputSlot = D3D11_BUFF_COL;
		decl[elements].AlignedByteOffset = 0;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

		decl[elements].SemanticName = "NORMAL";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R32G32B32_FLOAT;
		decl[elements].InputSlot = D3D11_BUFF_NORM;
		decl[elements].AlignedByteOffset = sizeof(vec3_t)*0;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

		decl[elements].SemanticName = "TANGENT";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R32G32B32_FLOAT;
		decl[elements].InputSlot = D3D11_BUFF_NORM;
		decl[elements].AlignedByteOffset = sizeof(vec3_t)*1;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

		decl[elements].SemanticName = "BINORMAL";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R32G32B32_FLOAT;
		decl[elements].InputSlot = D3D11_BUFF_NORM;
		decl[elements].AlignedByteOffset = sizeof(vec3_t)*2;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

/*
		decl[elements].SemanticName = "BLENDWEIGHT";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
		decl[elements].InputSlot = D3D11_BUFF_SKEL;
		decl[elements].AlignedByteOffset = 0;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;

		decl[elements].SemanticName = "BLENDINDICIES";
		decl[elements].SemanticIndex = 0;
		decl[elements].Format = DXGI_FORMAT_R8G8B8A8_UINT;
		decl[elements].InputSlot = D3D11_BUFF_SKEL;
		decl[elements].AlignedByteOffset = 0;
		decl[elements].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
		decl[elements].InstanceDataStepRate = 0;
		elements++;
*/
		if (FAILED(ID3D11Device_CreateInputLayout(pD3DDev11, decl, elements, vblob, vsize, (ID3D11InputLayout**)&prog->permu[permu].h.hlsl.layout)))
		{
			Con_Printf("HLSL Shader %s requires unsupported inputs\n", name);
			success = false;
		}
	}
	return success;
}

static qboolean D3D11Shader_LoadBlob(program_t *prog, const char *name, unsigned int permu, vfsfile_t *blobfile)
{
	qboolean success;
	char *vblob, *hblob, *dblob, *gblob, *fblob;
	unsigned int vsz, hsz, dsz, gsz, fsz;

	VFS_READ(blobfile, &vsz, sizeof(vsz));
	vblob = Z_Malloc(vsz);
	VFS_READ(blobfile, vblob, vsz);

	VFS_READ(blobfile, &hsz, sizeof(hsz));
	if (hsz != ~0u)
	{
		hblob = Z_Malloc(hsz);
		VFS_READ(blobfile, hblob, hsz);
	}
	else
		hblob = NULL;

	VFS_READ(blobfile, &dsz, sizeof(dsz));
	if (dsz != ~0u)
	{
		dblob = Z_Malloc(dsz);
		VFS_READ(blobfile, dblob, dsz);
	}
	else
		dblob = NULL;

	VFS_READ(blobfile, &gsz, sizeof(gsz));
	if (dsz != ~0u)
	{
		gblob = Z_Malloc(gsz);
		VFS_READ(blobfile, gblob, gsz);
	}
	else
		gblob = NULL;

	VFS_READ(blobfile, &fsz, sizeof(fsz));
	fblob = Z_Malloc(fsz);
	VFS_READ(blobfile, fblob, fsz);


	success = D3D11Shader_CreateShaders(prog, name, permu, vblob, vsz, hblob, hsz, dblob, dsz, gblob, gsz, fblob, fsz);
	Z_Free(vblob);
	Z_Free(hblob);
	Z_Free(dblob);
	Z_Free(gblob);
	Z_Free(fblob);
	return success;
}

qboolean D3D11Shader_CreateProgram (program_t *prog, const char *name, unsigned int permu, int ver, const char **precompilerconstants, const char *vert, const char *hull, const char *domain, const char *geom, const char *frag, qboolean silenterrors, vfsfile_t *blobfile)
{
	static const char *defaultsamplers[] =
	{
		"s_shadowmap",
		"s_projectionmap",
		"s_diffuse",
		"s_normalmap",
		"s_specular",
		"s_upper",
		"s_lower",
		"s_fullbright",
		"s_paletted",
		"s_reflectcube",
		"s_reflectmask",
		"s_lightmap",
		"s_deluxmap"
#if MAXRLIGHTMAPS > 1
		,"s_lightmap1"
		,"s_lightmap2"
		,"s_lightmap3"
		,"s_deluxmap1"
		,"s_deluxmap2"
		,"s_deluxmap3"
#endif
	};

	char *vsformat;
	char *hsformat = NULL;
	char *dsformat = NULL;
	char *fsformat;
	char *gsformat = NULL;
	D3D_SHADER_MACRO defines[64];
	ID3DBlob *vcode = NULL, *hcode = NULL, *dcode = NULL, *gcode = NULL, *fcode = NULL, *errors = NULL;
	qboolean success = false;
	ID3D11ShaderReflection *freflect;
	int i;

	if (d3dfeaturelevel >= D3D_FEATURE_LEVEL_11_0)	//and 11.1
	{
		vsformat = "vs_5_0";
		hsformat = "hs_5_0";
		dsformat = "ds_5_0";
		gsformat = "gs_5_0";
		fsformat = "ps_5_0";
	}
	else if (d3dfeaturelevel >= D3D_FEATURE_LEVEL_10_1)
	{
		vsformat = "vs_4_1";
		gsformat = "gs_4_1";
		fsformat = "ps_4_1";
	}
	else if (d3dfeaturelevel >= D3D_FEATURE_LEVEL_10_0)
	{
		vsformat = "vs_4_0";
		gsformat = "gs_4_0";
		fsformat = "ps_4_0";
	}
	else if (d3dfeaturelevel >= D3D_FEATURE_LEVEL_9_3)
	{	//dx10-compatible output for 9.3 hardware
		vsformat = "vs_4_0_level_9_3";
		fsformat = "ps_4_0_level_9_3";
	}
	else
	{	//dx10-compatible output for 9.1|9.2 hardware
		vsformat = "vs_4_0_level_9_1";
		fsformat = "ps_4_0_level_9_1";
	}

	prog->permu[permu].h.hlsl.vert = NULL;
	prog->permu[permu].h.hlsl.frag = NULL;
	prog->permu[permu].h.hlsl.hull = NULL;
	prog->permu[permu].h.hlsl.domain = NULL;
	prog->permu[permu].h.hlsl.geom = NULL;
	prog->permu[permu].h.hlsl.layout = NULL;

	if (pD3DCompile)
	{
		int consts;
		for (consts = 0; precompilerconstants[consts]; consts++)
			;
		if (consts+3 >= sizeof(defines) / sizeof(defines[0]))
			return success;

		consts = 0;
		defines[consts].Name = NULL; /*shader type*/
		defines[consts].Definition = "1";
		consts++;

		defines[consts].Name = "ENGINE_"DISTRIBUTION;
		defines[consts].Definition = __DATE__;
		consts++;

		defines[consts].Name = Z_StrDup("LEVEL");
		defines[consts].Definition = Z_StrDup(va("0x%x", d3dfeaturelevel));
		consts++;

		for (; *precompilerconstants; precompilerconstants++)
		{
			const char *t = *precompilerconstants;
			t = COM_Parse(t);
			t = COM_Parse(t);
			defines[consts].Name = Z_StrDup(com_token);
			defines[consts].Definition = t?Z_StrDup(t):NULL;
			consts++;
		}

		defines[consts].Name = NULL;
		defines[consts].Definition = NULL;

		success = true;

		defines[0].Name = "VERTEX_SHADER";
		if (FAILED(pD3DCompile(vert, strlen(vert), name, defines, &myd3dinclude, "main", vsformat, 0, 0, &vcode, &errors)))
			success = false;
		if (errors && !silenterrors)
		{
			char *messages = ID3DBlob_GetBufferPointer(errors);
			Con_Printf("vertex shader %s:\n%s", name, messages);
			ID3DBlob_Release(errors);
		}

		if (hull)
		{
			if (!hsformat)
				success = false;
			else
			{
				defines[0].Name = "HULL_SHADER";
				if (FAILED(pD3DCompile(hull, strlen(hull), name, defines, &myd3dinclude, "main", hsformat, 0, 0, &hcode, &errors)))
					success = false;
				if (errors && !silenterrors)
				{
					char *messages = ID3DBlob_GetBufferPointer(errors);
					Con_Printf("hull shader %s:\n%s", name, messages);
					ID3DBlob_Release(errors);
				}
			}
		}

		if (domain)
		{
			if (!dsformat)
				success = false;
			else
			{
				defines[0].Name = "DOMAIN_SHADER";
				if (FAILED(pD3DCompile(domain, strlen(domain), name, defines, &myd3dinclude, "main", dsformat, 0, 0, &dcode, &errors)))
					success = false;
				if (errors && !silenterrors)
				{
					char *messages = ID3DBlob_GetBufferPointer(errors);
					Con_Printf("domain shader %s:\n%s", name, messages);
					ID3DBlob_Release(errors);
				}
			}
		}

		if (geom)
		{
			if (!dsformat)
				success = false;
			else
			{
				defines[0].Name = "GEOMETRY_SHADER";
				if (FAILED(pD3DCompile(domain, strlen(domain), name, defines, &myd3dinclude, "main", gsformat, 0, 0, &gcode, &errors)))
					success = false;
				if (errors && !silenterrors)
				{
					char *messages = ID3DBlob_GetBufferPointer(errors);
					Con_Printf("geometry shader %s:\n%s", name, messages);
					ID3DBlob_Release(errors);
				}
			}
		}

		defines[0].Name = "FRAGMENT_SHADER";
		if (FAILED(pD3DCompile(frag, strlen(frag), name, defines, &myd3dinclude, "main", fsformat, 0, 0, &fcode, &errors)))
			success = false;
		if (errors && !silenterrors)
		{
			char *messages = ID3DBlob_GetBufferPointer(errors);
			Con_Printf("fragment shader %s:\n%s", name, messages);
			ID3DBlob_Release(errors);
		}

		while(consts-->2)
		{
			Z_Free((void*)defines[consts].Name);
			Z_Free((void*)defines[consts].Definition);
		}

		if (success)
			success = D3D11Shader_CreateShaders(prog, name, permu, 
				ID3DBlob_GetBufferPointer(vcode), ID3DBlob_GetBufferSize(vcode),
				hcode?ID3DBlob_GetBufferPointer(hcode):NULL, hcode?ID3DBlob_GetBufferSize(hcode):0,
				dcode?ID3DBlob_GetBufferPointer(dcode):NULL, dcode?ID3DBlob_GetBufferSize(dcode):0,
				gcode?ID3DBlob_GetBufferPointer(gcode):NULL, gcode?ID3DBlob_GetBufferSize(gcode):0,
				ID3DBlob_GetBufferPointer(fcode), ID3DBlob_GetBufferSize(fcode));

		if (success && blobfile)
		{
			unsigned int sz;
			sz = ID3DBlob_GetBufferSize(vcode);
			VFS_WRITE(blobfile, &sz, sizeof(sz));
			VFS_WRITE(blobfile, ID3DBlob_GetBufferPointer(vcode), sz);

			if (!hcode)
			{
				sz = ~0u;
				VFS_WRITE(blobfile, &sz, sizeof(sz));
			}
			else
			{
				sz = ID3DBlob_GetBufferSize(hcode);
				VFS_WRITE(blobfile, &sz, sizeof(sz));
				VFS_WRITE(blobfile, ID3DBlob_GetBufferPointer(hcode), sz);
			}

			if (!dcode)
			{
				sz = ~0u;
				VFS_WRITE(blobfile, &sz, sizeof(sz));
			}
			else
			{
				sz = ID3DBlob_GetBufferSize(dcode);
				VFS_WRITE(blobfile, &sz, sizeof(sz));
				VFS_WRITE(blobfile, ID3DBlob_GetBufferPointer(dcode), sz);
			}

			if (!gcode)
			{
				sz = ~0u;
				VFS_WRITE(blobfile, &sz, sizeof(sz));
			}
			else
			{
				sz = ID3DBlob_GetBufferSize(gcode);
				VFS_WRITE(blobfile, &sz, sizeof(sz));
				VFS_WRITE(blobfile, ID3DBlob_GetBufferPointer(gcode), sz);
			}

			sz = ID3DBlob_GetBufferSize(fcode);
			VFS_WRITE(blobfile, &sz, sizeof(sz));
			VFS_WRITE(blobfile, ID3DBlob_GetBufferPointer(fcode), sz);
		}


		if (fcode)
		{
			pD3DReflect(ID3DBlob_GetBufferPointer(fcode), ID3DBlob_GetBufferSize(fcode), &IID_ID3D11ShaderReflection, (void**)&freflect);
			if (freflect)
			{
				int tmu;
				D3D11_SHADER_INPUT_BIND_DESC bdesc = {0};
				for (i = prog->numsamplers; i < 16; i++)
				{
					if (SUCCEEDED(freflect->lpVtbl->GetResourceBindingDescByName(freflect, va("t_t%i", i), &bdesc)))
						prog->numsamplers = i+1;
				}

				tmu = prog->numsamplers;
				for (i = 0; i < sizeof(defaultsamplers)/sizeof(defaultsamplers[0]); i++)
				{
//					if (prog->defaulttextures & (1u<<i))
//						continue;
					if (SUCCEEDED(freflect->lpVtbl->GetResourceBindingDescByName(freflect, va("t%s", defaultsamplers[i]+1), &bdesc)))
						prog->defaulttextures |= (1u<<i);
					if (!(prog->defaulttextures & (1u<<i)))
						continue;
					tmu++;
				}
				ID3D11ShaderReflection_Release(freflect);
			}
		}

		if (vcode)
			ID3DBlob_Release(vcode);
		if (hcode)
			ID3DBlob_Release(hcode);
		if (dcode)
			ID3DBlob_Release(dcode);
		if (gcode)
			ID3DBlob_Release(gcode);
		if (fcode)
			ID3DBlob_Release(fcode);
	}
	return success;
}

qboolean D3D11Shader_Init(unsigned int flevel)
{
	//FIXME: if the feature level is below 10, make sure the compiler supports all the right targets etc
	int ver;
	dllfunction_t funcsold[] =
	{
		{(void**)&pD3DCompile, "D3DCompileFromMemory"},
		{(void**)&pD3DReflect, "D3DReflect"},
		{NULL,NULL}
	};
	dllfunction_t funcsnew[] =
	{
		{(void**)&pD3DCompile, "D3DCompile"},
		{(void**)&pD3DReflect, "D3DReflect"},
		{NULL,NULL}
	};

	for (ver = 47; ver >= 33; ver--)
	{
		shaderlib = Sys_LoadLibrary(va("D3dcompiler_%i.dll", ver), (ver>=40)?funcsnew:funcsold);
		if (shaderlib)
			break;
	}

	if (!shaderlib)
	{
		//no shader library available. at least make sure that there's a 2d blob that we can use.
		if (!COM_FCheckExists("hlsl11/default2d.blob"))
			return false;
	}

	sh_config.minver = 11;
	sh_config.maxver = 11;
	sh_config.blobpath = "hlsl11/%s.blob";
	sh_config.progpath = shaderlib?"hlsl11/%s.hlsl":NULL;
	sh_config.shadernamefmt = "%s_hlsl11";

	sh_config.progs_supported	= true;
	sh_config.progs_required	= true;

	sh_config.pDeleteProg		= D3D11Shader_DeleteProg;
	sh_config.pLoadBlob			= D3D11Shader_LoadBlob;
	sh_config.pCreateProgram	= D3D11Shader_CreateProgram;
	sh_config.pProgAutoFields	= NULL;

//	sh_config.tex_env_combine		= 1;
//	sh_config.nv_tex_env_combine4	= 1;
//	sh_config.env_add				= 1;

	d3dfeaturelevel = flevel;
	return true;
}

#endif