diff --git a/patches/d3dx9_36-D3DXDisassembleShader/0004-d3dx9_36-Implement-D3DXDisassembleShader.patch b/patches/d3dx9_36-D3DXDisassembleShader/0004-d3dx9_36-Implement-D3DXDisassembleShader.patch deleted file mode 100644 index 32a96821..00000000 --- a/patches/d3dx9_36-D3DXDisassembleShader/0004-d3dx9_36-Implement-D3DXDisassembleShader.patch +++ /dev/null @@ -1,375 +0,0 @@ -From 0ba05ea85f8f2de3c802083340eb3a9ee8df209e Mon Sep 17 00:00:00 2001 -From: Christian Costa -Date: Sat, 13 Feb 2016 15:29:37 +0100 -Subject: [PATCH] d3dx9_36: Implement D3DXDisassembleShader. (v2) - -Changes in v2 (by Christian Costa): - * More generic code for D3DXDisassembleShader. ---- - dlls/d3dx9_36/shader.c | 335 ++++++++++++++++++++++++++++++++++++++++- - 1 file changed, 329 insertions(+), 6 deletions(-) - -diff --git a/dlls/d3dx9_36/shader.c b/dlls/d3dx9_36/shader.c -index 1aa75d64dc5..d98345e2288 100644 ---- a/dlls/d3dx9_36/shader.c -+++ b/dlls/d3dx9_36/shader.c -@@ -1,6 +1,7 @@ - /* - * Copyright 2008 Luis Busquets - * Copyright 2009 Matteo Bruni -+ * Copyright 2010, 2013, 2016 Christian Costa - * Copyright 2011 Travis Athougies - * - * This library is free software; you can redistribute it and/or -@@ -19,6 +20,7 @@ - */ - - #include -+#include - - #include "d3dx9_private.h" - #include "d3dcommon.h" -@@ -2347,13 +2349,334 @@ HRESULT WINAPI D3DXGetShaderSamplers(const DWORD *byte_code, const char **sample - return D3D_OK; - } - --HRESULT WINAPI D3DXDisassembleShader(const DWORD *shader, BOOL colorcode, const char *comments, -- ID3DXBuffer **buffer) --{ -- TRACE("shader %p, colorcode %d, comments %s, buffer %p.\n", shader, colorcode, debugstr_a(comments), buffer); -+static const char *decl_usage[] = { "position", "blendweight", "blendindices", "normal", "psize", "texcoord", -+ "tangent", "binormal", "tessfactor", "positiont", "color" }; - -- return D3DDisassemble(shader, D3DXGetShaderSize(shader), colorcode ? D3D_DISASM_ENABLE_COLOR_CODE : 0, -- comments, (ID3DBlob **)buffer); -+static const char *tex_type[] = { "", "1d", "2d", "cube", "volume" }; -+ -+static int add_modifier(char *buffer, DWORD param) -+{ -+ char *buf = buffer; -+ DWORD dst_mod = param & D3DSP_DSTMOD_MASK; -+ -+ if (dst_mod & D3DSPDM_SATURATE) -+ buf += sprintf(buf, "_sat"); -+ if (dst_mod & D3DSPDM_PARTIALPRECISION) -+ buf += sprintf(buf, "_pp"); -+ if (dst_mod & D3DSPDM_MSAMPCENTROID) -+ buf += sprintf(buf, "_centroid"); -+ -+ return buf - buffer; -+} -+ -+static int add_register(char *buffer, DWORD param, BOOL dst, BOOL ps) -+{ -+ char *buf = buffer; -+ DWORD reg_type = ((param & D3DSP_REGTYPE_MASK2) >> D3DSP_REGTYPE_SHIFT2) -+ | ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT); -+ DWORD reg_num = param & D3DSP_REGNUM_MASK; -+ -+ if (reg_type == D3DSPR_INPUT) -+ buf += sprintf(buf, "v%d", reg_num); -+ else if (reg_type == D3DSPR_CONST) -+ buf += sprintf(buf, "c%d", reg_num); -+ else if (reg_type == D3DSPR_TEMP) -+ buf += sprintf(buf, "r%d", reg_num); -+ else if (reg_type == D3DSPR_ADDR) -+ buf += sprintf(buf, "%s%d", ps ? "t" : "a", reg_num); -+ else if (reg_type == D3DSPR_SAMPLER) -+ buf += sprintf(buf, "s%d", reg_num); -+ else if (reg_type == D3DSPR_RASTOUT) -+ buf += sprintf(buf, "oPos"); -+ else if (reg_type == D3DSPR_COLOROUT) -+ buf += sprintf(buf, "oC%d", reg_num); -+ else if (reg_type == D3DSPR_TEXCRDOUT) -+ buf += sprintf(buf, "oT%d", reg_num); -+ else if (reg_type == D3DSPR_ATTROUT) -+ buf += sprintf(buf, "oD%d", reg_num); -+ else -+ buf += sprintf(buf, "? (%d)", reg_type); -+ -+ if (dst) -+ { -+ if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) -+ { -+ buf += sprintf(buf, ".%s%s%s%s", param & D3DSP_WRITEMASK_0 ? "x" : "", -+ param & D3DSP_WRITEMASK_1 ? "y" : "", -+ param & D3DSP_WRITEMASK_2 ? "z" : "", -+ param & D3DSP_WRITEMASK_3 ? "w" : ""); -+ } -+ } -+ else -+ { -+ if ((param & D3DVS_SWIZZLE_MASK) != D3DVS_NOSWIZZLE) -+ { -+ if ( ((param & D3DSP_SWIZZLE_MASK) == (D3DVS_X_X | D3DVS_Y_X | D3DVS_Z_X | D3DVS_W_X)) || -+ ((param & D3DSP_SWIZZLE_MASK) == (D3DVS_X_Y | D3DVS_Y_Y | D3DVS_Z_Y | D3DVS_W_Y)) || -+ ((param & D3DSP_SWIZZLE_MASK) == (D3DVS_X_Z | D3DVS_Y_Z | D3DVS_Z_Z | D3DVS_W_Z)) || -+ ((param & D3DSP_SWIZZLE_MASK) == (D3DVS_X_W | D3DVS_Y_W | D3DVS_Z_W | D3DVS_W_W)) ) -+ buf += sprintf(buf, ".%c", 'w' + (((param >> D3DVS_SWIZZLE_SHIFT) + 1) & 0x3)); -+ else -+ buf += sprintf(buf, ".%c%c%c%c", 'w' + (((param >> (D3DVS_SWIZZLE_SHIFT+0)) + 1) & 0x3), -+ 'w' + (((param >> (D3DVS_SWIZZLE_SHIFT+2)) + 1) & 0x3), -+ 'w' + (((param >> (D3DVS_SWIZZLE_SHIFT+4)) + 1) & 0x3), -+ 'w' + (((param >> (D3DVS_SWIZZLE_SHIFT+6)) + 1) & 0x3)); -+ } -+ } -+ -+ return buf - buffer; -+} -+ -+struct instr_info -+{ -+ DWORD opcode; -+ const char *name; -+ int length; -+ int (*function)(const struct instr_info *info, DWORD **ptr, char *buffer, BOOL ps); -+ WORD min_version; -+ WORD max_version; -+}; -+ -+static int instr_comment(const struct instr_info *info, DWORD **ptr, char *buffer, BOOL ps) -+{ -+ *ptr += 1 + ((**ptr & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT); -+ return 0; -+} -+ -+static int instr_def(const struct instr_info *info, DWORD **ptr, char *buffer, BOOL ps) -+{ -+ int len = sprintf(buffer, " def c%d, %g, %g, %g, %g\n", *(*ptr+1) & D3DSP_REGNUM_MASK, -+ (double)*(float*)(*ptr+2), (double)*(float*)(*ptr+3), -+ (double)*(float*)(*ptr+4), (double)*(float*)(*ptr+5)); -+ *ptr += 6; -+ return len; -+} -+ -+static int instr_dcl(const struct instr_info *info, DWORD **ptr, char *buffer, BOOL ps) -+{ -+ DWORD param1 = *++*ptr; -+ DWORD param2 = *++*ptr; -+ DWORD usage = (param1 & D3DSP_DCL_USAGE_MASK) >> D3DSP_DCL_USAGE_SHIFT; -+ DWORD usage_index = (param1 & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT; -+ char *buf = buffer; -+ -+ buf += sprintf(buf, " dcl"); -+ if (ps) -+ { -+ if (param1 & D3DSP_TEXTURETYPE_MASK) -+ buf += sprintf(buf, "_%s", (usage <= D3DSTT_VOLUME) ? -+ tex_type[(param1 & D3DSP_TEXTURETYPE_MASK) >> D3DSP_TEXTURETYPE_SHIFT] : "???"); -+ } -+ else -+ { -+ buf += sprintf(buf, "_%s", (usage <= D3DDECLUSAGE_COLOR) ? decl_usage[usage] : "???"); -+ if (usage_index) -+ buf += sprintf(buf, "%d", usage_index); -+ } -+ -+ buf += add_modifier(buf, param2); -+ buf += sprintf(buf, " "); -+ buf += add_register(buf, param2, TRUE, TRUE); -+ buf += sprintf(buf, "\n"); -+ (*ptr)++; -+ return buf - buffer; -+} -+ -+static int instr_generic(const struct instr_info *info, DWORD **ptr, char *buffer, BOOL ps) -+{ -+ char *buf = buffer; -+ int j; -+ -+ buf += sprintf(buf, " %s", info->name); -+ (*ptr)++; -+ -+ if (info->length) -+ { -+ buf += add_modifier(buf, **ptr); -+ -+ for (j = 0; j < info->length; j++) -+ { -+ buf += sprintf(buf, "%s ", j ? "," : ""); -+ -+ if ((j != 0) && ((**ptr & D3DSP_SRCMOD_MASK) != D3DSPSM_NONE)) -+ { -+ if ((**ptr & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) -+ buf += sprintf(buf, "-"); -+ else -+ buf += sprintf(buf, "*"); -+ } -+ -+ buf += add_register(buf, **ptr, j == 0, ps); -+ -+ if (*(*ptr)++ & D3DVS_ADDRESSMODE_MASK) -+ { -+ buf += sprintf(buf, "["); -+ buf += add_register(buf, **ptr, FALSE, FALSE); -+ buf += sprintf(buf, "]"); -+ (*ptr)++; -+ } -+ } -+ } -+ buf += sprintf(buf, "\n"); -+ return buf - buffer; -+} -+ -+const struct instr_info instructions[] = -+{ -+ { D3DSIO_NOP, "nop", 0, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_MOV, "mov", 2, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_ADD, "add", 3, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_SUB, "sub", 3, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_MAD, "mad", 4, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_MUL, "mul", 3, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_RCP, "rcp", 2, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_RSQ, "rsq", 2, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_DP3, "dp3", 3, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_DP4, "dp4", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 1.2 for PS */ -+ { D3DSIO_MIN, "min", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_MAX, "max", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_SLT, "slt", 3, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_SGE, "sge", 3, instr_generic, 0x0100, 0xFFFF }, /* VS only */ -+ { D3DSIO_EXP, "exp", 2, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_LOG, "log", 2, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_LIT, "lit", 2, instr_generic, 0x0100, 0xFFFF }, /* VS only */ -+ { D3DSIO_DST, "dst", 3, instr_generic, 0x0100, 0xFFFF }, /* VS only */ -+ { D3DSIO_LRP, "lrp", 4, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for VS */ -+ { D3DSIO_FRC, "frc", 2, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_M4x4, "m4x4", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_M4x3, "m4x3", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_M3x4, "m3x4", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_M3x3, "m3x3", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_M3x2, "m3x2", 3, instr_generic, 0x0100, 0xFFFF }, /* >= 2.0 for PS */ -+ { D3DSIO_CALL, "call", 1, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_CALLNZ, "callnz", 2, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_LOOP, "loop", 2, instr_generic, 0x0200, 0xFFFF }, /* >= 3.0 for PS */ -+ { D3DSIO_RET, "ret", 0, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_ENDLOOP, "endloop", 1, instr_generic, 0x0200, 0xFFFF }, /* >= 3.0 for PS */ -+ { D3DSIO_LABEL, "label", 1, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_DCL, "dcl", 1, instr_dcl, 0x0100, 0xFFFF }, -+ { D3DSIO_POW, "pow", 3, instr_generic, 0x0200, 0xFFFF }, -+ { D3DSIO_CRS, "crs", 3, instr_generic, 0x0200, 0xFFFF }, -+ { D3DSIO_SGN, "sgn", 4, instr_generic, 0x0200, 0xFFFF }, /* VS only */ -+ { D3DSIO_ABS, "abs", 2, instr_generic, 0x0200, 0xFFFF }, -+ { D3DSIO_NRM, "nrm", 2, instr_generic, 0x0200, 0xFFFF }, -+ { D3DSIO_SINCOS, "sincos", 4, instr_generic, 0x0200, 0x02FF }, -+ { D3DSIO_SINCOS, "sincos", 2, instr_generic, 0x0300, 0xFFFF }, -+ { D3DSIO_REP, "rep", 1, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_ENDREP, "endrep", 0, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_IF, "if", 1, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_IFC, "if_comp", 2, instr_generic, 0x0200, 0xFFFF }, -+ { D3DSIO_ELSE, "else", 0, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_ENDIF, "endif", 0, instr_generic, 0x0200, 0xFFFF }, /* >= 2.a for PS */ -+ { D3DSIO_BREAK, "break", 0, instr_generic, 0x0201, 0xFFFF }, -+ { D3DSIO_BREAKC, "break_comp", 2, instr_generic, 0x0201, 0xFFFF }, -+ { D3DSIO_MOVA, "mova", 2, instr_generic, 0x0200, 0xFFFF }, /* VS only */ -+ { D3DSIO_DEFB, "defb", 2, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_DEFI, "defi", 2, instr_generic, 0x0100, 0xFFFF }, -+ { D3DSIO_TEXCOORD, "texcoord", 1, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXCOORD, "texcrd", 2, instr_generic, 0x0104, 0x0104 }, /* PS only */ -+ { D3DSIO_TEXKILL, "texkill", 1, instr_generic, 0x0100, 0xFFFF }, /* PS only */ -+ { D3DSIO_TEX, "tex", 1, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEX, "texld", 2, instr_generic, 0x0104, 0x0104 }, /* PS only */ -+ { D3DSIO_TEX, "texld", 3, instr_generic, 0x0200, 0xFFFF }, /* PS only */ -+ { D3DSIO_TEXBEM, "texbem", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXBEML, "texbeml", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXREG2AR, "texreg2ar", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXREG2GB, "texreg2gb", 2, instr_generic, 0x0102, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x2PAD, "texm3x2pad", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x2TEX, "texm3x2tex", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x3PAD, "texm3x3pad", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x3TEX, "texm3x3tex", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x3DIFF, "texm3x3diff", 2, instr_generic, 0x0100, 0xFFFF }, /* PS only - Not documented */ -+ { D3DSIO_TEXM3x3SPEC, "texm3x3spec", 3, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x3VSPEC, "texm3x3vspec", 2, instr_generic, 0x0100, 0x0103 }, /* PS only */ -+ { D3DSIO_EXPP, "expp", 2, instr_generic, 0x0100, 0xFFFF }, /* VS only */ -+ { D3DSIO_LOGP, "logp", 2, instr_generic, 0x0100, 0xFFFF }, /* VS only */ -+ { D3DSIO_CND, "cnd", 4, instr_generic, 0x0100, 0x0104 }, /* PS only */ -+ { D3DSIO_DEF, "def", 5, instr_def, 0x0100, 0xFFFF }, -+ { D3DSIO_TEXREG2RGB, "texreg2rgb", 2, instr_generic, 0x0102, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXDP3TEX, "texdp3tex", 2, instr_generic, 0x0102, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x2DEPTH, "texm3x2depth", 2, instr_generic, 0x0103, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXDP3, "texdp3", 2, instr_generic, 0x0102, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXM3x3, "texm3x3", 2, instr_generic, 0x0102, 0x0103 }, /* PS only */ -+ { D3DSIO_TEXDEPTH, "texdepth", 1, instr_generic, 0x0104, 0x0104 }, /* PS only */ -+ { D3DSIO_CMP, "cmp", 4, instr_generic, 0x0102, 0xFFFF }, /* PS only */ -+ { D3DSIO_BEM, "bem", 3, instr_generic, 0x0104, 0x0104 }, /* PS only */ -+ { D3DSIO_DP2ADD, "dp2add", 4, instr_generic, 0x0200, 0xFFFF }, /* PS only */ -+ { D3DSIO_DSX, "dsx", 2, instr_generic, 0x0201, 0xFFFF }, /* PS only */ -+ { D3DSIO_DSY, "dsy", 2, instr_generic, 0x0201, 0xFFFF }, /* PS only */ -+ { D3DSIO_TEXLDD, "texldd", 5, instr_generic, 0x0201, 0xFFFF }, /* PS only - not existing for 2.b */ -+ { D3DSIO_SETP, "setp_comp", 3, instr_generic, 0x0201, 0xFFFF }, -+ { D3DSIO_TEXLDL, "texldl", 3, instr_generic, 0x0300, 0xFFFF }, -+ { D3DSIO_BREAKP, "breakp", 1, instr_generic, 0x0201, 0xFFFF }, -+ { D3DSIO_PHASE, "phase", 0, instr_generic, 0x0104, 0x0104 }, /* PS only */ -+ { D3DSIO_COMMENT, "", 0, instr_comment, 0x0100, 0xFFFF } -+}; -+ -+HRESULT WINAPI D3DXDisassembleShader(const DWORD *shader, BOOL colorcode, const char *comments, -+ ID3DXBuffer **disassembly) -+{ -+ DWORD *ptr = (DWORD *)shader; -+ char *buffer, *buf; -+ UINT capacity = 4096; -+ BOOL ps; -+ WORD version; -+ HRESULT hr; -+ -+ TRACE("%p %d %s %p\n", shader, colorcode, debugstr_a(comments), disassembly); -+ -+ if (!shader || !disassembly) -+ return D3DERR_INVALIDCALL; -+ -+ buf = buffer = HeapAlloc(GetProcessHeap(), 0, capacity); -+ if (!buffer) -+ return E_OUTOFMEMORY; -+ -+ ps = (*ptr >> 16) & 1; -+ version = *ptr & 0xFFFF; -+ buf += sprintf(buf, " %s_%d_%d\n", ps ? "ps" : "vs", D3DSHADER_VERSION_MAJOR(*ptr), D3DSHADER_VERSION_MINOR(*ptr)); -+ ptr++; -+ -+ while (*ptr != D3DSIO_END) -+ { -+ DWORD index; -+ -+ if ((buf - buffer + 128) > capacity) -+ { -+ UINT count = buf - buffer; -+ char *new_buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, capacity * 2); -+ if (!new_buffer) -+ { -+ HeapFree(GetProcessHeap(), 0, buffer); -+ return E_OUTOFMEMORY; -+ } -+ capacity *= 2; -+ buffer = new_buffer; -+ buf = buffer + count; -+ } -+ -+ for (index = 0; index < sizeof(instructions)/sizeof(instructions[0]); index++) -+ if (((*ptr & D3DSI_OPCODE_MASK) == instructions[index].opcode) && -+ (version >= instructions[index].min_version) && (version <= instructions[index].max_version)) -+ break; -+ -+ if (index != sizeof(instructions)/sizeof(instructions[0])) -+ { -+ buf += instructions[index].function(&(instructions[index]), &ptr, buf, ps); -+ } -+ else -+ { -+ buf += sprintf(buf, " ??? (Unknown opcode %x)\n", *ptr); -+ while (*++ptr & (1u << 31)); -+ } -+ } -+ -+ hr = D3DXCreateBuffer(buf - buffer + 1 , disassembly); -+ if (SUCCEEDED(hr)) -+ strcpy(ID3DXBuffer_GetBufferPointer(*disassembly), buffer); -+ HeapFree(GetProcessHeap(), 0, buffer); -+ -+ return hr; - } - - struct d3dx9_texture_shader --- -2.39.0 - diff --git a/patches/d3dx9_36-D3DXDisassembleShader/0005-d3dx9_36-tests-Add-initial-tests-for-D3DXDisassemble.patch b/patches/d3dx9_36-D3DXDisassembleShader/0005-d3dx9_36-tests-Add-initial-tests-for-D3DXDisassemble.patch deleted file mode 100644 index 76ac03d4..00000000 --- a/patches/d3dx9_36-D3DXDisassembleShader/0005-d3dx9_36-tests-Add-initial-tests-for-D3DXDisassemble.patch +++ /dev/null @@ -1,74 +0,0 @@ -From 63a4b93d73acaa55a2246a1b0d825e7950af042b Mon Sep 17 00:00:00 2001 -From: Sebastian Lackner -Date: Mon, 15 Feb 2016 08:25:58 +0100 -Subject: [PATCH] d3dx9_36/tests: Add initial tests for D3DXDisassembleShader. - ---- - dlls/d3dx9_36/tests/shader.c | 46 ++++++++++++++++++++++++++++++++++++ - 1 file changed, 46 insertions(+) - -diff --git a/dlls/d3dx9_36/tests/shader.c b/dlls/d3dx9_36/tests/shader.c -index e2925faad6..5edac61ae8 100644 ---- a/dlls/d3dx9_36/tests/shader.c -+++ b/dlls/d3dx9_36/tests/shader.c -@@ -6623,6 +6623,51 @@ static void test_fragment_linker(void) - DestroyWindow(window); - } - -+static void test_disassemble_shader(void) -+{ -+ static const char disasm_vs[] = " vs_1_1\n" -+ " dcl_position v0\n" -+ " dp4 oPos.x, v0, c0\n" -+ " dp4 oPos.y, v0, c1\n" -+ " dp4 oPos.z, v0, c2\n" -+ " dp4 oPos.w, v0, c3\n"; -+ static const char disasm_ps[] = " ps_1_1\n" -+ " def c1, 1, 0, 0, 0\n" -+ " tex t0\n" -+ " dp3 r0, c1, c0\n" -+ " mul r0, v0, r0\n" -+ " mul r0, t0, r0\n"; -+ ID3DXBuffer *disassembly; -+ HRESULT ret; -+ char *ptr; -+ -+ /* Check wrong parameters */ -+ ret = D3DXDisassembleShader(NULL, FALSE, NULL, NULL); -+ ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL); -+ ret = D3DXDisassembleShader(NULL, FALSE, NULL, &disassembly); -+ ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL); -+ ret = D3DXDisassembleShader(simple_vs, FALSE, NULL, NULL); -+ ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL); -+ -+ /* Test with vertex shader */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(simple_vs, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_vs, sizeof(disasm_vs) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_vs); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test with pixel shader */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(simple_ps, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps, sizeof(disasm_ps) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps); -+ ID3DXBuffer_Release(disassembly); -+} -+ - START_TEST(shader) - { - test_get_shader_size(); -@@ -6638,4 +6683,5 @@ START_TEST(shader) - test_registerset_defaults(); - test_shader_semantics(); - test_fragment_linker(); -+ test_disassemble_shader(); - } --- -2.23.0 - diff --git a/patches/d3dx9_36-D3DXDisassembleShader/0006-d3dx9_36-tests-Add-additional-tests-for-special-case.patch b/patches/d3dx9_36-D3DXDisassembleShader/0006-d3dx9_36-tests-Add-additional-tests-for-special-case.patch deleted file mode 100644 index c2ce9548..00000000 --- a/patches/d3dx9_36-D3DXDisassembleShader/0006-d3dx9_36-tests-Add-additional-tests-for-special-case.patch +++ /dev/null @@ -1,200 +0,0 @@ -From ce7f2989a9fc4d4d6a307131f08f6ed5570de680 Mon Sep 17 00:00:00 2001 -From: Christian Costa -Date: Tue, 16 Feb 2016 12:11:45 +0100 -Subject: [PATCH] d3dx9_36/tests: Add additional tests for special cases. - ---- - dlls/d3dx9_36/tests/shader.c | 163 +++++++++++++++++++++++++++++++++++ - 1 file changed, 163 insertions(+) - -diff --git a/dlls/d3dx9_36/tests/shader.c b/dlls/d3dx9_36/tests/shader.c -index 5edac61ae8..0ae8f27b03 100644 ---- a/dlls/d3dx9_36/tests/shader.c -+++ b/dlls/d3dx9_36/tests/shader.c -@@ -6623,6 +6623,60 @@ static void test_fragment_linker(void) - DestroyWindow(window); - } - -+static const DWORD ps_tex[] = { -+ 0xffff0103, /* ps_1_3 */ -+ 0x00000042, 0xb00f0000, /* tex t0 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD ps_texld_1_4[] = { -+ 0xffff0104, /* ps_1_4 */ -+ 0x00000042, 0xb00f0000, 0xa0e40000, /* texld t0, c0 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD ps_texld_2_0[] = { -+ 0xffff0200, /* ps_2_0 */ -+ 0x00000042, 0xb00f0000, 0xa0e40000, 0xa0e40001, /* texld t0, c0, c1 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD ps_texcoord[] = { -+ 0xffff0103, /* ps_1_4 */ -+ 0x00000040, 0xb00f0000, /* texcoord t0 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD ps_texcrd[] = { -+ 0xffff0104, /* ps_2_0 */ -+ 0x00000040, 0xb00f0000, 0xa0e40000, /* texcrd t0, c0 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD ps_sincos_2_0[] = { -+ 0xffff0200, /* ps_2_0 */ -+ 0x00000025, 0xb00f0000, 0xa0e40000, 0xa0e40001, 0xa0e40002, /* sincos t0, c0, c1, c2 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD ps_sincos_3_0[] = { -+ 0xffff0300, /* ps_3_0 */ -+ 0x00000025, 0xb00f0000, 0xa0e40000, /* sincos t0, c0 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD vs_sincos_2_0[] = { -+ 0xfffe0200, /* vs_2_0 */ -+ 0x00000025, 0xb00f0000, 0xa0e40000, 0xa0e40001, 0xa0e40002, /* sincos a0, c0, c1, c2 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ -+static const DWORD vs_sincos_3_0[] = { -+ 0xfffe0300, /* vs_3_0 */ -+ 0x00000025, 0xb00f0000, 0xa0e40000, /* sincos a0, c0 */ -+ 0x00000000, /* nop */ -+ 0x0000ffff}; -+ - static void test_disassemble_shader(void) - { - static const char disasm_vs[] = " vs_1_1\n" -@@ -6637,6 +6691,33 @@ static void test_disassemble_shader(void) - " dp3 r0, c1, c0\n" - " mul r0, v0, r0\n" - " mul r0, t0, r0\n"; -+ static const char disasm_ps_tex[] = " ps_1_3\n" -+ " tex t0\n" -+ " nop\n"; -+ static const char disasm_ps_texld_1_4[] = " ps_1_4\n" -+ " texld t0, c0\n" -+ " nop\n"; -+ static const char disasm_ps_texld_2_0[] = " ps_2_0\n" -+ " texld t0, c0, c1\n" -+ " nop\n"; -+ static const char disasm_ps_texcoord[] = " ps_1_3\n" -+ " texcoord t0\n" -+ " nop\n"; -+ static const char disasm_ps_texcrd[] = " ps_1_4\n" -+ " texcrd t0, c0\n" -+ " nop\n"; -+ static const char disasm_ps_sincos_2_0[] = " ps_2_0\n" -+ " sincos t0, c0, c1, c2\n" -+ " nop\n"; -+ static const char disasm_ps_sincos_3_0[] = " ps_3_0\n" -+ " sincos t0, c0\n" -+ " nop\n"; -+ static const char disasm_vs_sincos_2_0[] = " vs_2_0\n" -+ " sincos a0, c0, c1, c2\n" -+ " nop\n"; -+ static const char disasm_vs_sincos_3_0[] = " vs_3_0\n" -+ " sincos a0, c0\n" -+ " nop\n"; - ID3DXBuffer *disassembly; - HRESULT ret; - char *ptr; -@@ -6666,6 +6747,88 @@ static void test_disassemble_shader(void) - ok(!memcmp(ptr, disasm_ps, sizeof(disasm_ps) - 1), /* compare beginning */ - "Returned '%s', expected '%s'\n", ptr, disasm_ps); - ID3DXBuffer_Release(disassembly); -+ -+ /* Test tex instruction with pixel shader 1.3 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(ps_tex, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps_tex, sizeof(disasm_ps_tex) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps_tex); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test texld instruction with pixel shader 1.4 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(ps_texld_1_4, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps_texld_1_4, sizeof(disasm_ps_texld_1_4) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps_texld_1_4); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test texld instruction with pixel shader 2.0 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(ps_texld_2_0, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps_texld_2_0, sizeof(disasm_ps_texld_2_0) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps_texld_2_0); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test texcoord instruction with pixel shader 1.3 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(ps_texcoord, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps_texcoord, sizeof(disasm_ps_texcoord) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps_texcoord); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test texcrd instruction with pixel shader 1.4 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(ps_texcrd, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps_texcrd, sizeof(disasm_ps_texcrd) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps_texcrd); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test sincos instruction pixel shader 2.0 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(ps_sincos_2_0, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps_sincos_2_0, sizeof(disasm_ps_sincos_2_0) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps_sincos_2_0); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test sincos instruction with pixel shader 3.0 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(ps_sincos_3_0, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_ps_sincos_3_0, sizeof(disasm_ps_sincos_3_0) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_ps_sincos_3_0); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test sincos instruction with pixel shader 2.0 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(vs_sincos_2_0, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_vs_sincos_2_0, sizeof(disasm_vs_sincos_2_0) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_vs_sincos_2_0); -+ ID3DXBuffer_Release(disassembly); -+ -+ /* Test sincos instruction with pixel shader 3.0 */ -+ disassembly = (void *)0xdeadbeef; -+ ret = D3DXDisassembleShader(vs_sincos_3_0, FALSE, NULL, &disassembly); -+ ok(ret == D3D_OK, "Failed with %#x\n", ret); -+ ptr = ID3DXBuffer_GetBufferPointer(disassembly); -+ ok(!memcmp(ptr, disasm_vs_sincos_3_0, sizeof(disasm_vs_sincos_3_0) - 1), /* compare beginning */ -+ "Returned '%s', expected '%s'\n", ptr, disasm_vs_sincos_3_0); -+ ID3DXBuffer_Release(disassembly); -+ - } - - START_TEST(shader) --- -2.23.0 - diff --git a/patches/d3dx9_36-D3DXDisassembleShader/definition b/patches/d3dx9_36-D3DXDisassembleShader/definition deleted file mode 100644 index ba2687e3..00000000 --- a/patches/d3dx9_36-D3DXDisassembleShader/definition +++ /dev/null @@ -1 +0,0 @@ -Fixes: [46649] Multiple applications need D3DXDisassembleShader() implementation (Tom Clancy's Rainbow Six: Vegas 2, The Void)