nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2024-11-25 21:31:37 +00:00
Code Issues Projects Releases Packages Wiki Activity
fteqw/engine/d3d/d3d11_shader.c
Spoike 811bce25f1 Too many changes, sorry. 
Change revision displays, use the SVN commit date instead of using __DATE__ (when there's no local changes). This should allow reproducible builds.
Added s_al_disable cvar, to block openal and all the various problems people have had with it, without having to name an explicit fallback (which would vary by system).
Add mastervolume cvar (for ss).
Add r_shadows 2 (aka fake shadows - for ss).
Add scr_loadingscreen_aspect -1 setting, to disable levelshots entirely, also disables the progress bar (for ss).
Better support for some effectinfo hacks (for ss).
Added dpcompat_nocsqcwarnings (because of lazy+buggy mods like ss).
Rework the dpcsqc versions of project+unproject builtins for better compat (for ss).
Added dpcompat_csqcinputeventtypes to block unexpected csqc input events (for ss).
Better compat with DP's loadfont console command (for ss).
Added dpcompat_smallerfonts cvar to replicate a DP bug (for ss).
Detect dp's m_draw extension, to work around it (for ss).
Cvar dpcompat_ignoremodificationtimes added. A value of 0 favour the most recently modified file, 1 will use DP-like alphabetically sorted preferences (for ss).
loadfont builtin can now accept outline=1 in the sizes arg for slightly more readable fonts.
Fix bbox calcs for rotated entities, fix needed for r_ignorenetpvs 0.
Hackily parse emoji.json to provide 💩 etc suggestions.
Skip prediction entirely when there's no local entity info. This fixes stair-smoothing in xonotic.
screenshot_cubemap will now capture half-float images when saving to ktx or dds files.
Fix support for xcf files larger than 4gb, mostly to avoid compiler warnings.
Fixed size of gfx/loading.lmp when replacement textures are used.
Added mipmap support for rg8 and l8a8 textures.
r_hdr_framebuffer cvar updated to support format names instead of random negative numbers. Description updated to name some interesting ones.
Perform autoupdate _checks_ ONLY with explicit user confirmation (actual updating already needed user confirmation, but this extra step should reduce the chances of us getting wrongly accused of exfiltrating user data if we're run in a sandbox - we ONLY ever included the updating engine's version in the checks, though there's nothing we can do to avoid sending the user's router's IP).
Removed the 'summon satan all over your harddrive' quit message, in case paranoid security researchers are idiots and don't bother doing actual research.
Removed the triptohell.info and fte.triptohell.info certificates, they really need to stop being self-signed. The updates domain is still self-signed for autoupdates.
Video drivers are now able to report supported video resolutions, visible to menuqc. Currently only works with SDL2 builds.
Added setmousepos builtin. Should work with glx+win32 build.
VF_SKYROOM_CAMERA can now accept an extra two args, setviewprop(VF_SKYROOM_CAMERA, org, axis, degrees).
Removed v_skyroom_origin+v_skyroom_orientation cvars in favour just v_skyroom, which should make it behave more like the 'fog' command (used when csqc isn't overriding).
Added R_EndPolygonRibbon builtin to make it faster+easier to generate textured ribbon/cable/etc wide lines (for TW).
sdl: Fix up sys_sdl.c's file enumeration to support wildcards in directories.
edit command now displays end1.bin/end2.bin correctly, because we can.
Finally add support for f_modified - though ruleset_allow_larger_models and ruleset_allow_overlong_sounds generally make it redundant.
Fix threading race condition in sha1 lookups.
Updated f_ruleset to include the same extra flags reported by ezquake.
A mod's default.fmf file can now contain an eg 'mainconfig config.cfg' line (to explicitly set the main config saved with cfg_save_auto 1 etc).
fmf: basegame steam:GameName/GameDir can be used to try to load a mod directory from an installed steam game. The resulting gamedir will be read-only.
HOMEDIR CHANGE: use homedirs only if the basedir cannot be written or a homedir already exists, which should further reduce the probability of microsoft randomly uploading our data to their cloud (but mostly because its annoying to never know where your data is written).
Fixed buf_cvarlist, should work in xonotic now, and without segfaults.
Added an extra arg to URI_Get_Callback calls - the response size, also changed the tempstring to contain all bytes of the response, you need to be careful about nulls though.
Try to work around nvidia's forced-panning bug on x11 when changing video modes. This might screw with other programs.
sdl: support custom icons.
sdl: support choosing a specific display.
Added some documentation to menuqc builtins.
menusys: use outlines for slightly more readable fonts.
menusys: switch vid_width and vid_height combos into a single video mode combo to set both according to reported video modes.



git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5581 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-11-20 03:09:50 +00:00

769 lines
22 KiB
C
Raw Blame History

#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}};
//const GUID IID_ID3D11ShaderReflection = {0x0a233719, 0x3960, 0x4578, {0x9d, 0x7c, 0x20, 0x3b, 0x8b, 0x1d, 0x9c, 0xc1}};
#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
);
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") || !strcmp(pFileName, "sys/defs.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"
"float4 e_uppercolour;\n"
"float4 e_lowercolour;\n"
"float4 e_colourmod;\n"
"float4 e_glowmod;\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;
}
//fog
}
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, l;
struct programpermu_s *pp;
for (permu = countof(prog->permu); permu-- > 0; )
{
pp = prog->permu[permu];
if (!pp)
continue;
prog->permu[permu] = NULL;
if (pp == prog->permu[0] && permu)
continue; //entry 0 (only) can get copied to avoid constant recompile failures (0 is always precompiled)
vert = pp->h.hlsl.vert;
frag = pp->h.hlsl.frag;
if (vert)
ID3D11VertexShader_Release(vert);
if (frag)
ID3D11PixelShader_Release(frag);
for (l = 0; l < countof(pp->h.hlsl.layouts); l++)
{
layout = pp->h.hlsl.layouts[l];
if (layout)
ID3D11InputLayout_Release(layout);
}
Z_Free(pp);
}
}
//create a program from two blobs.
static qboolean D3D11Shader_CreateShaders(program_t *prog, const char *name, struct programpermu_s *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)
{
int l;
qboolean success = true;
if (FAILED(ID3D11Device_CreateVertexShader(pD3DDev11, vblob, vsize, NULL, (ID3D11VertexShader**)&permu->h.hlsl.vert)))
success = false;
if (hblob || dblob)
{
permu->h.hlsl.topology = D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST;
if (FAILED(ID3D11Device_CreateHullShader(pD3DDev11, hblob, hsize, NULL, (ID3D11HullShader**)&permu->h.hlsl.hull)))
success = false;
if (FAILED(ID3D11Device_CreateDomainShader(pD3DDev11, dblob, dsize, NULL, (ID3D11DomainShader**)&permu->h.hlsl.domain)))
success = false;
}
else
permu->h.hlsl.topology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
if (gblob && FAILED(ID3D11Device_CreateGeometryShader(pD3DDev11, gblob, gsize, NULL, (ID3D11GeometryShader**)&permu->h.hlsl.geom)))
success = false;
if (FAILED(ID3D11Device_CreatePixelShader(pD3DDev11, fblob, fsize, NULL, (ID3D11PixelShader**)&permu->h.hlsl.frag)))
success = false;
for (l = 0; l < 2 && success; l++)
{
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 = l?DXGI_FORMAT_R32G32B32A32_FLOAT: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**)&permu->h.hlsl.layouts[l])))
{
Con_Printf("HLSL Shader %s requires unsupported inputs\n", name);
success = false;
}
}
return success;
}
static qboolean D3D11Shader_LoadBlob(program_t *prog, 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, prog->name, prog->permu[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, struct programpermu_s *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)
{
char *vsformat;
char *hsformat = NULL;
char *dsformat = NULL;
char *fsformat;
char *gsformat = NULL;
char *tmp;
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";
}
permu->h.hlsl.vert = NULL;
permu->h.hlsl.frag = NULL;
permu->h.hlsl.hull = NULL;
permu->h.hlsl.domain = NULL;
permu->h.hlsl.geom = NULL;
memset(permu->h.hlsl.layouts, 0, sizeof(permu->h.hlsl.layouts));
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;
#ifdef SVNREVISION
defines[consts].Definition = STRINGIFY(SVNREVISION);
#else
defines[consts].Definition = "0";
#endif
consts++;
tmp = Z_Malloc(64);
Q_snprintfz(tmp, 64, "0x%x", d3dfeaturelevel);
defines[consts].Name = Z_StrDup("LEVEL");
defines[consts].Definition = tmp;
consts++;
for (; *precompilerconstants; precompilerconstants++)
{
const char *t, *nl;
char *v;
for (t = *precompilerconstants; *t; t++)
{
t = COM_Parse(t);
t = COM_Parse(t);
defines[consts].Name = Z_StrDup(com_token);
while (*t == ' ' || *t == '\t')
t++;
nl = strchr(t, '\n');
if (!nl)
nl = t+strlen(t);
if (nl && nl != t)
{
v = BZ_Malloc(nl-t+1);
memcpy(v, t, nl-t);
v[nl-t] = 0;
defines[consts].Definition = v;
}
else
defines[consts].Definition = t?Z_StrDup(t):NULL;
consts++;
t = nl;
}
}
defines[consts].Name = NULL;
defines[consts].Definition = NULL;
success = true;
defines[0].Name = "VERTEX_SHADER";
if (FAILED(pD3DCompile(vert, strlen(vert), prog->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", prog->name, messages);
ID3DBlob_Release(errors);
}
if (hull)
{
if (!hsformat)
success = false;
else
{
defines[0].Name = "HULL_SHADER";
if (FAILED(pD3DCompile(hull, strlen(hull), prog->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", prog->name, messages);
ID3DBlob_Release(errors);
}
}
}
if (domain)
{
if (!dsformat)
success = false;
else
{
defines[0].Name = "DOMAIN_SHADER";
if (FAILED(pD3DCompile(domain, strlen(domain), prog->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", prog->name, messages);
ID3DBlob_Release(errors);
}
}
}
if (geom)
{
if (!dsformat)
success = false;
else
{
defines[0].Name = "GEOMETRY_SHADER";
if (FAILED(pD3DCompile(domain, strlen(domain), prog->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", prog->name, messages);
ID3DBlob_Release(errors);
}
}
}
defines[0].Name = "FRAGMENT_SHADER";
if (FAILED(pD3DCompile(frag, strlen(frag), prog->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", prog->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, 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; sh_defaultsamplers[i]; i++)
{
// if (prog->defaulttextures & (1u<<i))
// continue;
if (SUCCEEDED(freflect->lpVtbl->GetResourceBindingDescByName(freflect, va("t%s", sh_defaultsamplers[i]+1), &bdesc)))
prog->defaulttextures |= (1u<<i);
if (!(prog->defaulttextures & (1u<<i)))
continue;
tmu++;
}
ID3D11ShaderReflection_Release(freflect);
}
else
Con_Printf("%s: D3DReflect failed, unable to get reflection info\n", name);
}
*/
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"},
{NULL,NULL}
};
dllfunction_t funcsnew[] =
{
{(void**)&pD3DCompile, "D3DCompile"},
{NULL,NULL}
};
//FIXME: wine's d3dcompiler dlls don't work properly right now, and winetricks installs ms' only up to 43 (which works, but we loaded 47 instead)
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.can_mipcap = true; //at creation time
sh_config.havecubemaps = true;
// sh_config.tex_env_combine = 1;
// sh_config.nv_tex_env_combine4 = 1;
// sh_config.env_add = 1;
d3dfeaturelevel = flevel;
return true;
}
#endif
Reference in a new issue View git blame Copy permalink