reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-26 05:00:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
7259b9d8b6
wine/dlls/wined3d/baseshader.c

980 lines
35 KiB
C
Raw Normal View History

wined3d: Addline cleanup.
2006-05-08 19:44:25 +00:00
/*
* shaders implementation
*
* Copyright 2002-2003 Jason Edmeades
* Copyright 2002-2003 Raphael Junqueira
wined3d: Readd missing copyright to shaders files.
2006-07-17 18:35:14 +00:00
* Copyright 2004 Christian Costa
wined3d: Addline cleanup.
2006-05-08 19:44:25 +00:00
* Copyright 2005 Oliver Stieber
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
* Copyright 2006 Ivan Gyurdiev
wined3d: Addline cleanup.
2006-05-08 19:44:25 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
Update the address of the Free Software Foundation.
2006-05-18 12:49:52 +00:00
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
wined3d: Addline cleanup.
2006-05-08 19:44:25 +00:00
*/
#include "config.h"
#include <string.h>
#include <stdio.h>
#include "wined3d_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
#define GLNAME_REQUIRE_GLSL ((const char *)1)
wined3d: Clean up register use maps.
2006-05-21 21:16:17 +00:00
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
inline static BOOL shader_is_version_token(DWORD token) {
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
return shader_is_pshader_version(token) ||
shader_is_vshader_version(token);
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
}
wined3d: Addline cleanup.
2006-05-08 19:44:25 +00:00
int shader_addline(
SHADER_BUFFER* buffer,
const char *format, ...) {
char* base = buffer->buffer + buffer->bsize;
int rc;
va_list args;
va_start(args, format);
rc = vsnprintf(base, SHADER_PGMSIZE - 1 - buffer->bsize, format, args);
va_end(args);
if (rc < 0 || /* C89 */
rc > SHADER_PGMSIZE - 1 - buffer->bsize) { /* C99 */
ERR("The buffer allocated for the shader program string "
"is too small at %d bytes.\n", SHADER_PGMSIZE);
buffer->bsize = SHADER_PGMSIZE - 1;
return -1;
}
buffer->bsize += rc;
buffer->lineNo++;
TRACE("GL HW (%u, %u) : %s", buffer->lineNo, buffer->bsize, base);
return 0;
}
wined3d: Share get_opcode.
2006-05-09 11:57:36 +00:00
const SHADER_OPCODE* shader_get_opcode(
IWineD3DBaseShader *iface, const DWORD code) {
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl*) iface;
DWORD i = 0;
DWORD hex_version = This->baseShader.hex_version;
const SHADER_OPCODE *shader_ins = This->baseShader.shader_ins;
/** TODO: use dichotomic search */
while (NULL != shader_ins[i].name) {
if (((code & D3DSI_OPCODE_MASK) == shader_ins[i].opcode) &&
(((hex_version >= shader_ins[i].min_version) && (hex_version <= shader_ins[i].max_version)) ||
((shader_ins[i].min_version == 0) && (shader_ins[i].max_version == 0)))) {
return &shader_ins[i];
}
++i;
}
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
code, code, code & D3DSI_OPCODE_MASK, hex_version);
wined3d: Share get_opcode.
2006-05-09 11:57:36 +00:00
return NULL;
}
wined3d: Add shader_get_param() fn, which processes address tokens. Add a new function to process parameters. On shaders 1.0, processing parameters amounts to *pToken++. On shaders 2.0+, we have a relative addressing token to account for. This function should be used, instead of relying on num_params everywhere.
2006-05-17 06:02:36 +00:00
/* Read a parameter opcode from the input stream,
* and possibly a relative addressing token.
* Return the number of tokens read */
int shader_get_param(
IWineD3DBaseShader* iface,
const DWORD* pToken,
DWORD* param,
DWORD* addr_token) {
/* PS >= 3.0 have relative addressing (with token)
* VS >= 2.0 have relative addressing (with token)
* VS >= 1.0 < 2.0 have relative addressing (without token)
* The version check below should work in general */
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
char rel_token = D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2 &&
((*pToken & D3DSHADER_ADDRESSMODE_MASK) == D3DSHADER_ADDRMODE_RELATIVE);
*param = *pToken;
*addr_token = rel_token? *(pToken + 1): 0;
return rel_token? 2:1;
}
wined3d: Do not rely on num_params to skip unhandled tokens in shaders 2.0.
2006-05-17 06:00:47 +00:00
/* Return the number of parameters to skip for an opcode */
static inline int shader_skip_opcode(
IWineD3DBaseShaderImpl* This,
const SHADER_OPCODE* curOpcode,
DWORD opcode_token) {
/* Shaders >= 2.0 may contain address tokens, but fortunately they
* have a useful legnth mask - use it here. Shaders 1.0 contain no such tokens */
return (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2)?
((opcode_token & D3DSI_INSTLENGTH_MASK) >> D3DSI_INSTLENGTH_SHIFT):
curOpcode->num_params;
}
wined3d: Add shader_get_param() fn, which processes address tokens. Add a new function to process parameters. On shaders 1.0, processing parameters amounts to *pToken++. On shaders 2.0+, we have a relative addressing token to account for. This function should be used, instead of relying on num_params everywhere.
2006-05-17 06:02:36 +00:00
/* Read the parameters of an unrecognized opcode from the input stream
* Return the number of tokens read.
*
* Note: This function assumes source or destination token format.
* It will not work with specially-formatted tokens like DEF or DCL,
* but hopefully those would be recognized */
int shader_skip_unrecognized(
IWineD3DBaseShader* iface,
const DWORD* pToken) {
int tokens_read = 0;
int i = 0;
/* TODO: Think of a good name for 0x80000000 and replace it with a constant */
while (*pToken & 0x80000000) {
DWORD param, addr_token;
tokens_read += shader_get_param(iface, pToken, &param, &addr_token);
pToken += tokens_read;
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
FIXME("Unrecognized opcode param: token=%08x "
"addr_token=%08x name=", param, addr_token);
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
shader_dump_param(iface, param, addr_token, i);
wined3d: Add shader_get_param() fn, which processes address tokens. Add a new function to process parameters. On shaders 1.0, processing parameters amounts to *pToken++. On shaders 2.0+, we have a relative addressing token to account for. This function should be used, instead of relying on num_params everywhere.
2006-05-17 06:02:36 +00:00
FIXME("\n");
++i;
}
return tokens_read;
}
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
/* Convert floating point offset relative
* to a register file to an absolute offset for float constants */
unsigned int shader_get_float_offset(const DWORD reg) {
unsigned int regnum = reg & D3DSP_REGNUM_MASK;
int regtype = shader_get_regtype(reg);
switch (regtype) {
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_CONST: return regnum;
case WINED3DSPR_CONST2: return 2048 + regnum;
case WINED3DSPR_CONST3: return 4096 + regnum;
case WINED3DSPR_CONST4: return 6144 + regnum;
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
default:
FIXME("Unsupported register type: %d\n", regtype);
return regnum;
}
}
wined3d: Clean up register use maps.
2006-05-21 21:16:17 +00:00
/* Note that this does not count the loop register
* as an address register. */
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
HRESULT shader_get_registers_used(
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
IWineD3DBaseShader *iface,
wined3d: Clean up register use maps.
2006-05-21 21:16:17 +00:00
shader_reg_maps* reg_maps,
wined3d: Reverse semantics maps for shaders.
2006-07-07 06:27:38 +00:00
semantic* semantics_in,
semantic* semantics_out,
wined3d: Find the correct sampler type for < 2.0 pshaders.
2006-08-27 17:16:01 +00:00
CONST DWORD* pToken,
IWineD3DStateBlockImpl *stateBlock) {
wined3d: Place # of textures, addresses, & temps used inside the baseShader struct to prepare for GenerateShader merge.
2006-05-10 02:31:09 +00:00
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
/* There are some minor differences between pixel and vertex shaders */
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
if (pToken == NULL)
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
return WINED3D_OK;
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
while (D3DVS_END() != *pToken) {
CONST SHADER_OPCODE* curOpcode;
wined3d: Take predication tokens into account. Each instruction can have a predication token. Account for it in the trace pass, register count pass, and store it in the SHADER_OPCODE_ARG structure for generation. MSDN claims the token is at the end of the instruction, but that's not true - testing a demo, which lets me manipulate the shader shows the predication token is the first source token immediately following the destination token.
2006-05-18 01:09:56 +00:00
DWORD opcode_token;
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
/* Skip version */
if (shader_is_version_token(*pToken)) {
++pToken;
continue;
/* Skip comments */
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
} else if (shader_is_comment(*pToken)) {
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
++pToken;
pToken += comment_len;
continue;
}
/* Fetch opcode */
wined3d: Take predication tokens into account. Each instruction can have a predication token. Account for it in the trace pass, register count pass, and store it in the SHADER_OPCODE_ARG structure for generation. MSDN claims the token is at the end of the instruction, but that's not true - testing a demo, which lets me manipulate the shader shows the predication token is the first source token immediately following the destination token.
2006-05-18 01:09:56 +00:00
opcode_token = *pToken++;
curOpcode = shader_get_opcode(iface, opcode_token);
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
/* Unhandled opcode, and its parameters */
if (NULL == curOpcode) {
while (*pToken & 0x80000000)
++pToken;
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
/* Handle declarations */
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (WINED3DSIO_DCL == curOpcode->opcode) {
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
DWORD usage = *pToken++;
DWORD param = *pToken++;
DWORD regtype = shader_get_regtype(param);
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
unsigned int regnum = param & D3DSP_REGNUM_MASK;
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
/* Vshader: mark attributes used
Pshader: mark 3.0 input registers used, save token */
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
if (WINED3DSPR_INPUT == regtype) {
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
if (!pshader)
reg_maps->attributes[regnum] = 1;
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 06:57:07 +00:00
else
reg_maps->packed_input[regnum] = 1;
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
wined3d: Reverse semantics maps for shaders.
2006-07-07 06:27:38 +00:00
semantics_in[regnum].usage = usage;
semantics_in[regnum].reg = param;
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
/* Vshader: mark 3.0 output registers used, save token */
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
} else if (WINED3DSPR_OUTPUT == regtype) {
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 06:57:07 +00:00
reg_maps->packed_output[regnum] = 1;
wined3d: Reverse semantics maps for shaders.
2006-07-07 06:27:38 +00:00
semantics_out[regnum].usage = usage;
semantics_out[regnum].reg = param;
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
/* Save sampler usage token */
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
} else if (WINED3DSPR_SAMPLER == regtype)
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
reg_maps->samplers[regnum] = usage;
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (WINED3DSIO_DEF == curOpcode->opcode) {
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
if (!lconst) return E_OUTOFMEMORY;
lconst->idx = *pToken & D3DSP_REGNUM_MASK;
memcpy(&lconst->value, pToken + 1, 4 * sizeof(DWORD));
list_add_head(&This->baseShader.constantsF, &lconst->entry);
pToken += curOpcode->num_params;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (WINED3DSIO_DEFI == curOpcode->opcode) {
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
if (!lconst) return E_OUTOFMEMORY;
lconst->idx = *pToken & D3DSP_REGNUM_MASK;
memcpy(&lconst->value, pToken + 1, 4 * sizeof(DWORD));
list_add_head(&This->baseShader.constantsI, &lconst->entry);
pToken += curOpcode->num_params;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (WINED3DSIO_DEFB == curOpcode->opcode) {
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
if (!lconst) return E_OUTOFMEMORY;
lconst->idx = *pToken & D3DSP_REGNUM_MASK;
memcpy(&lconst->value, pToken + 1, 1 * sizeof(DWORD));
list_add_head(&This->baseShader.constantsB, &lconst->entry);
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
pToken += curOpcode->num_params;
wined3d: Fix lookup for LOOP register.
2006-06-16 20:13:01 +00:00
/* If there's a loop in the shader */
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (WINED3DSIO_LOOP == curOpcode->opcode ||
WINED3DSIO_REP == curOpcode->opcode) {
wined3d: Fix lookup for LOOP register.
2006-06-16 20:13:01 +00:00
reg_maps->loop = 1;
pToken += curOpcode->num_params;
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 10:35:15 +00:00
/* For subroutine prototypes */
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (WINED3DSIO_LABEL == curOpcode->opcode) {
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 10:35:15 +00:00
DWORD snum = *pToken & D3DSP_REGNUM_MASK;
reg_maps->labels[snum] = 1;
pToken += curOpcode->num_params;
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
/* Set texture, address, temporary registers */
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
} else {
wined3d: Take predication tokens into account. Each instruction can have a predication token. Account for it in the trace pass, register count pass, and store it in the SHADER_OPCODE_ARG structure for generation. MSDN claims the token is at the end of the instruction, but that's not true - testing a demo, which lets me manipulate the shader shows the predication token is the first source token immediately following the destination token.
2006-05-18 01:09:56 +00:00
int i, limit;
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
/* Declare 1.X samplers implicitly, based on the destination reg. number */
if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
(WINED3DSIO_TEX == curOpcode->opcode ||
WINED3DSIO_TEXBEM == curOpcode->opcode ||
WINED3DSIO_TEXM3x2TEX == curOpcode->opcode ||
WINED3DSIO_TEXM3x3TEX == curOpcode->opcode)) {
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
/* Fake sampler usage, only set reserved bit and ttype */
DWORD sampler_code = *pToken & D3DSP_REGNUM_MASK;
wined3d: Find the correct sampler type for < 2.0 pshaders.
2006-08-27 17:16:01 +00:00
if(!stateBlock->textures[sampler_code]) {
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
ERR("No texture bound to sampler %d\n", sampler_code);
wined3d: Find the correct sampler type for < 2.0 pshaders.
2006-08-27 17:16:01 +00:00
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
} else {
int texType = IWineD3DBaseTexture_GetTextureDimensions(stateBlock->textures[sampler_code]);
switch(texType) {
case GL_TEXTURE_1D:
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_1D;
break;
case GL_TEXTURE_2D:
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
break;
case GL_TEXTURE_3D:
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_VOLUME;
break;
case GLTEXTURECUBEMAP:
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_CUBE;
break;
default:
ERR("Unexpected gl texture type found: %d\n", texType);
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_2D;
}
}
wined3d: Fix a few GLSL shader instruction translations. This fixes the translations for a few instructions in GLSL and allows Cubemap sampling in pixel shaders < 2.0. It makes some of the lighting on textures in Half Life 2 look better, including some of the water effects. It's not perfect yet, but much closer now.
2006-06-28 22:32:47 +00:00
} else if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
(WINED3DSIO_TEXM3x3SPEC == curOpcode->opcode ||
WINED3DSIO_TEXM3x3VSPEC == curOpcode->opcode)) {
wined3d: Fix a few GLSL shader instruction translations. This fixes the translations for a few instructions in GLSL and allows Cubemap sampling in pixel shaders < 2.0. It makes some of the lighting on textures in Half Life 2 look better, including some of the water effects. It's not perfect yet, but much closer now.
2006-06-28 22:32:47 +00:00
/* 3D sampler usage, only set reserved bit and ttype
* FIXME: This could be either Cube or Volume, but we wouldn't know unless
* we waited to generate the shader until the textures were all bound.
* For now, use Cube textures because they are more common. */
DWORD sampler_code = *pToken & D3DSP_REGNUM_MASK;
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 19:34:39 +00:00
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_CUBE;
} else if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
(WINED3DSIO_TEXDP3TEX == curOpcode->opcode)) {
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 19:34:39 +00:00
/* 1D Sampler usage */
DWORD sampler_code = *pToken & D3DSP_REGNUM_MASK;
reg_maps->samplers[sampler_code] = (0x1 << 31) | WINED3DSTT_1D;
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
}
wined3d: Take predication tokens into account. Each instruction can have a predication token. Account for it in the trace pass, register count pass, and store it in the SHADER_OPCODE_ARG structure for generation. MSDN claims the token is at the end of the instruction, but that's not true - testing a demo, which lets me manipulate the shader shows the predication token is the first source token immediately following the destination token.
2006-05-18 01:09:56 +00:00
/* This will loop over all the registers and try to
* make a bitmask of the ones we're interested in.
*
* Relative addressing tokens are ignored, but that's
* okay, since we'll catch any address registers when
* they are initialized (required by spec) */
limit = (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED)?
curOpcode->num_params + 1: curOpcode->num_params;
for (i = 0; i < limit; ++i) {
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
DWORD param, addr_token, reg, regtype;
pToken += shader_get_param(iface, pToken, &param, &addr_token);
wined3d: Use shader_get_regtype() in register counting pass.
2006-07-03 01:28:25 +00:00
regtype = shader_get_regtype(param);
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
reg = param & D3DSP_REGNUM_MASK;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
if (WINED3DSPR_TEXTURE == regtype) { /* vs: WINED3DSPR_ADDR */
wined3d: Clean up register use maps.
2006-05-21 21:16:17 +00:00
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
if (pshader)
reg_maps->texcoord[reg] = 1;
wined3d: Clean up register use maps.
2006-05-21 21:16:17 +00:00
else
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
reg_maps->address[reg] = 1;
wined3d: Clean up register use maps.
2006-05-21 21:16:17 +00:00
}
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
else if (WINED3DSPR_TEMP == regtype)
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
reg_maps->temporary[reg] = 1;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
else if (WINED3DSPR_INPUT == regtype && !pshader)
wined3d: Register map cleanups. Various cleanups: - do not use DWORD as a bitmask, that places artificial limit of 32 on registers - track attributes that are used and declare only those - move declarations function call in pshader/vshader to allow us to insert pixel or vertex specific code between the declarations and the rest of the code - remove redundant 0 intializers - remove useless continue statement
2006-06-12 06:55:30 +00:00
reg_maps->attributes[reg] = 1;
wined3d: Fix for vertex shaders.
2006-07-17 05:41:53 +00:00
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
else if (WINED3DSPR_RASTOUT == regtype && reg == 1)
wined3d: Fix for vertex shaders.
2006-07-17 05:41:53 +00:00
reg_maps->fog = 1;
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
}
}
}
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
return WINED3D_OK;
wined3d: Merge register counting pass.
2006-05-09 22:03:09 +00:00
}
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
static void shader_dump_decl_usage(
wined3d: Fix faulty DCL trace.
2006-07-03 06:03:47 +00:00
IWineD3DBaseShaderImpl* This,
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
DWORD decl,
DWORD param) {
DWORD regtype = shader_get_regtype(param);
wined3d: Fix faulty DCL trace.
2006-07-03 06:03:47 +00:00
TRACE("dcl");
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
if (regtype == WINED3DSPR_SAMPLER) {
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 19:34:39 +00:00
DWORD ttype = decl & WINED3DSP_TEXTURETYPE_MASK;
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
switch (ttype) {
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 19:34:39 +00:00
case WINED3DSTT_2D: TRACE("_2d"); break;
case WINED3DSTT_CUBE: TRACE("_cube"); break;
case WINED3DSTT_VOLUME: TRACE("_volume"); break;
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
default: TRACE("_unknown_ttype(%08x)", ttype);
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
}
} else {
DWORD usage = decl & D3DSP_DCL_USAGE_MASK;
DWORD idx = (decl & D3DSP_DCL_USAGEINDEX_MASK) >> D3DSP_DCL_USAGEINDEX_SHIFT;
wined3d: Fix faulty DCL trace.
2006-07-03 06:03:47 +00:00
/* Pixel shaders 3.0 don't have usage semantics */
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
if (pshader && This->baseShader.hex_version < D3DPS_VERSION(3,0))
return;
else
TRACE("_");
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
switch(usage) {
case D3DDECLUSAGE_POSITION:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("%s%d", "position", idx);
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
break;
case D3DDECLUSAGE_BLENDINDICES:
TRACE("%s", "blend");
break;
case D3DDECLUSAGE_BLENDWEIGHT:
TRACE("%s", "weight");
break;
case D3DDECLUSAGE_NORMAL:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("%s%d", "normal", idx);
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
break;
case D3DDECLUSAGE_PSIZE:
TRACE("%s", "psize");
break;
case D3DDECLUSAGE_COLOR:
if(idx == 0) {
TRACE("%s", "color");
} else {
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("%s%d", "specular", (idx - 1));
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
}
break;
case D3DDECLUSAGE_TEXCOORD:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("%s%d", "texture", idx);
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
break;
case D3DDECLUSAGE_TANGENT:
TRACE("%s", "tangent");
break;
case D3DDECLUSAGE_BINORMAL:
TRACE("%s", "binormal");
break;
case D3DDECLUSAGE_TESSFACTOR:
TRACE("%s", "tessfactor");
break;
case D3DDECLUSAGE_POSITIONT:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("%s%d", "positionT", idx);
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
break;
case D3DDECLUSAGE_FOG:
TRACE("%s", "fog");
break;
case D3DDECLUSAGE_DEPTH:
TRACE("%s", "depth");
break;
case D3DDECLUSAGE_SAMPLE:
TRACE("%s", "sample");
break;
default:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
FIXME("unknown_semantics(%08x)", usage);
wined3d: Move program_dump_decl_usage into baseshader.
2006-05-10 02:26:05 +00:00
}
}
}
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
static void shader_dump_arr_entry(
IWineD3DBaseShader *iface,
const DWORD param,
const DWORD addr_token,
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
unsigned int reg,
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
int input) {
char relative =
((param & D3DSHADER_ADDRESSMODE_MASK) == D3DSHADER_ADDRMODE_RELATIVE);
if (relative) {
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
TRACE("[");
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
if (addr_token)
shader_dump_param(iface, addr_token, 0, input);
else
TRACE("a0.x");
TRACE(" + ");
}
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
TRACE("%u", reg);
if (relative)
TRACE("]");
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
}
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
void shader_dump_param(
IWineD3DBaseShader *iface,
const DWORD param,
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
const DWORD addr_token,
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
int input) {
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
char swizzle_reg_chars[4];
DWORD reg = param & D3DSP_REGNUM_MASK;
DWORD regtype = shader_get_regtype(param);
wined3d: Trace ABS/ABSNEG modifiers.
2006-07-07 06:29:39 +00:00
DWORD modifier = param & D3DSP_SRCMOD_MASK;
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
/* There are some minor differences between pixel and vertex shaders */
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 06:59:16 +00:00
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
/* For one, we'd prefer color components to be shown for pshaders.
* FIXME: use the swizzle function for this */
swizzle_reg_chars[0] = pshader? 'r': 'x';
swizzle_reg_chars[1] = pshader? 'g': 'y';
swizzle_reg_chars[2] = pshader? 'b': 'z';
swizzle_reg_chars[3] = pshader? 'a': 'w';
if (input) {
wined3d: Trace ABS/ABSNEG modifiers.
2006-07-07 06:29:39 +00:00
if ( (modifier == D3DSPSM_NEG) ||
(modifier == D3DSPSM_BIASNEG) ||
(modifier == D3DSPSM_SIGNNEG) ||
(modifier == D3DSPSM_X2NEG) ||
(modifier == D3DSPSM_ABSNEG) )
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
TRACE("-");
wined3d: Trace ABS/ABSNEG modifiers.
2006-07-07 06:29:39 +00:00
else if (modifier == D3DSPSM_COMP)
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
TRACE("1-");
wined3d: Trace ABS/ABSNEG modifiers.
2006-07-07 06:29:39 +00:00
else if (modifier == D3DSPSM_NOT)
wined3d: Take predication tokens into account. Each instruction can have a predication token. Account for it in the trace pass, register count pass, and store it in the SHADER_OPCODE_ARG structure for generation. MSDN claims the token is at the end of the instruction, but that's not true - testing a demo, which lets me manipulate the shader shows the predication token is the first source token immediately following the destination token.
2006-05-18 01:09:56 +00:00
TRACE("!");
wined3d: Trace ABS/ABSNEG modifiers.
2006-07-07 06:29:39 +00:00
if (modifier == D3DSPSM_ABS || modifier == D3DSPSM_ABSNEG)
TRACE("abs(");
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
}
switch (regtype) {
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_TEMP:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("r%u", reg);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_INPUT:
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
TRACE("v");
shader_dump_arr_entry(iface, param, addr_token, reg, input);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_CONST:
case WINED3DSPR_CONST2:
case WINED3DSPR_CONST3:
case WINED3DSPR_CONST4:
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
TRACE("c");
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
shader_dump_arr_entry(iface, param, addr_token, shader_get_float_offset(param), input);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_TEXTURE: /* vs: case D3DSPR_ADDR */
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("%c%u", (pshader? 't':'a'), reg);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_RASTOUT:
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
TRACE("%s", rastout_reg_names[reg]);
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_COLOROUT:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("oC%u", reg);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_DEPTHOUT:
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
TRACE("oDepth");
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_ATTROUT:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("oD%u", reg);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_TEXCRDOUT:
wined3d: Parameter trace corrections.
2006-05-18 01:08:29 +00:00
/* Vertex shaders >= 3.0 use general purpose output registers
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
* (WINED3DSPR_OUTPUT), which can include an address token */
wined3d: Parameter trace corrections.
2006-05-18 01:08:29 +00:00
if (D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
TRACE("o");
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
shader_dump_arr_entry(iface, param, addr_token, reg, input);
wined3d: Parameter trace corrections.
2006-05-18 01:08:29 +00:00
}
else
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("oT%u", reg);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_CONSTINT:
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
TRACE("i");
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
shader_dump_arr_entry(iface, param, addr_token, reg, input);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_CONSTBOOL:
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
TRACE("b");
wined3d: Trace improvements.
2006-06-06 06:40:08 +00:00
shader_dump_arr_entry(iface, param, addr_token, reg, input);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_LABEL:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("l%u", reg);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_LOOP:
wined3d: Modify shader_dump_param() to take into account address token. Currently we hardcode a0.x, which I think is correct for shaders 1.0. However, for shaders 2.0, we must look into the address token, and print the register there. Handle both cases to correct the trace.
2006-05-17 06:05:49 +00:00
TRACE("aL");
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_SAMPLER:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("s%u", reg);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-09 23:45:55 +00:00
case WINED3DSPR_PREDICATE:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("p%u", reg);
wined3d: Parameter trace corrections.
2006-05-18 01:08:29 +00:00
break;
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
default:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("unhandled_rtype(%#x)", regtype);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
break;
}
if (!input) {
/* operand output (for modifiers and shift, see dump_ins_modifiers) */
if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
TRACE(".");
if (param & D3DSP_WRITEMASK_0) TRACE("%c", swizzle_reg_chars[0]);
if (param & D3DSP_WRITEMASK_1) TRACE("%c", swizzle_reg_chars[1]);
if (param & D3DSP_WRITEMASK_2) TRACE("%c", swizzle_reg_chars[2]);
if (param & D3DSP_WRITEMASK_3) TRACE("%c", swizzle_reg_chars[3]);
}
} else {
/** operand input */
DWORD swizzle = (param & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT;
DWORD swizzle_r = swizzle & 0x03;
DWORD swizzle_g = (swizzle >> 2) & 0x03;
DWORD swizzle_b = (swizzle >> 4) & 0x03;
DWORD swizzle_a = (swizzle >> 6) & 0x03;
wined3d: Trace ABS/ABSNEG modifiers.
2006-07-07 06:29:39 +00:00
if (0 != modifier) {
switch (modifier) {
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
case D3DSPSM_NONE: break;
case D3DSPSM_NEG: break;
wined3d: Take predication tokens into account. Each instruction can have a predication token. Account for it in the trace pass, register count pass, and store it in the SHADER_OPCODE_ARG structure for generation. MSDN claims the token is at the end of the instruction, but that's not true - testing a demo, which lets me manipulate the shader shows the predication token is the first source token immediately following the destination token.
2006-05-18 01:09:56 +00:00
case D3DSPSM_NOT: break;
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
case D3DSPSM_BIAS: TRACE("_bias"); break;
case D3DSPSM_BIASNEG: TRACE("_bias"); break;
case D3DSPSM_SIGN: TRACE("_bx2"); break;
case D3DSPSM_SIGNNEG: TRACE("_bx2"); break;
case D3DSPSM_COMP: break;
case D3DSPSM_X2: TRACE("_x2"); break;
case D3DSPSM_X2NEG: TRACE("_x2"); break;
case D3DSPSM_DZ: TRACE("_dz"); break;
case D3DSPSM_DW: TRACE("_dw"); break;
wined3d: Trace ABS/ABSNEG modifiers.
2006-07-07 06:29:39 +00:00
case D3DSPSM_ABSNEG: TRACE(")"); break;
case D3DSPSM_ABS: TRACE(")"); break;
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
default:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("_unknown_modifier(%#x)", modifier >> D3DSP_SRCMOD_SHIFT);
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
}
}
/**
* swizzle bits fields:
* RRGGBBAA
*/
if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
if (swizzle_r == swizzle_g &&
swizzle_r == swizzle_b &&
swizzle_r == swizzle_a) {
TRACE(".%c", swizzle_reg_chars[swizzle_r]);
} else {
TRACE(".%c%c%c%c",
swizzle_reg_chars[swizzle_r],
swizzle_reg_chars[swizzle_g],
swizzle_reg_chars[swizzle_b],
swizzle_reg_chars[swizzle_a]);
}
}
}
}
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
/** Shared code in order to generate the bulk of the shader string.
Use the shader_header_fct & shader_footer_fct to add strings
that are specific to pixel or vertex functions
NOTE: A description of how to parse tokens can be found at:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/graphics/hh/graphics/usermodedisplaydriver_shader_cc8e4e05-f5c3-4ec0-8853-8ce07c1551b2.xml.asp */
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
void shader_generate_main(
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
IWineD3DBaseShader *iface,
SHADER_BUFFER* buffer,
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
shader_reg_maps* reg_maps,
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
CONST DWORD* pFunction) {
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
const DWORD *pToken = pFunction;
const SHADER_OPCODE *curOpcode = NULL;
wined3d: Simplify generate_base_shader() when checking for USING_GLSL usage.
2006-05-18 17:43:32 +00:00
SHADER_HANDLER hw_fct = NULL;
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
DWORD i;
wined3d: Unified float constant register mapping between ARB pixel and vertex shaders. - Got rid of the separate constant maps. - Side effect of this is that the map is a bit larger for pixel shaders than it needs to be
2006-06-09 07:33:33 +00:00
SHADER_OPCODE_ARG hw_arg;
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
/* Initialize current parsing state */
wined3d: Fix NULL dereference in generator function.
2006-06-07 03:40:16 +00:00
hw_arg.shader = iface;
hw_arg.buffer = buffer;
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 06:53:32 +00:00
hw_arg.reg_maps = reg_maps;
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
This->baseShader.parse_state.current_row = 0;
/* Second pass, process opcodes */
if (NULL != pToken) {
while (D3DPS_END() != *pToken) {
/* Skip version token */
if (shader_is_version_token(*pToken)) {
++pToken;
continue;
}
/* Skip comment tokens */
wined3d: Shaders: share dump_param function, version functions.
2006-05-14 13:43:31 +00:00
if (shader_is_comment(*pToken)) {
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
++pToken;
TRACE("#%s\n", (char*)pToken);
pToken += comment_len;
continue;
}
/* Read opcode */
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
hw_arg.opcode_token = *pToken++;
curOpcode = shader_get_opcode(iface, hw_arg.opcode_token);
wined3d: Rework shader mode selection. - currently half the shader selection code (GLSL vs ARB) is in fillGLcaps. The parts that check for software shaders are in GetDeviceCaps. That placement, will work, but is definitely not optimal. FillGLcaps should detect support - it should not make decision as to what's used, because that's not what the purpose of the function is. GetDeviceCaps should report support as it has already been selected. Instead, select shader mode in its own function, called in the appropriate places. - unifying pixel and vertex shaders into a single selection is a mistake. A software vertex shader can be coupled with a hardware arb or glsl pixel shader, or no shader at all. Split them back into two and add a SHADER_NONE variant. - drawprim is doing support checks for ARB_PROGRAM, and making shader decisions based on that - that's wrong, support has already been checked, and decided upon, and shaders can be implemented via software, ARB_PROGRAm or GLSL, so that support check isn't valid. - Store the shader selected mode into the shader itself. Different types of shaders can be combined, so this is an improvement. In fact, storing the mode into the settings globally is a mistake as well - it should be done per device, since different cards have different capabilities.
2006-07-04 07:21:53 +00:00
/* Select handler */
if (curOpcode == NULL)
hw_fct = NULL;
else if (This->baseShader.shader_mode == SHADER_GLSL)
hw_fct = curOpcode->hw_glsl_fct;
else if (This->baseShader.shader_mode == SHADER_ARB)
hw_fct = curOpcode->hw_fct;
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
/* Unknown opcode and its parameters */
wined3d: Fix NULL dereference in generator function.
2006-06-07 03:40:16 +00:00
if (NULL == curOpcode) {
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
FIXME("Unrecognized opcode: token=%08x\n", hw_arg.opcode_token);
wined3d: Fix NULL dereference in generator function.
2006-06-07 03:40:16 +00:00
pToken += shader_skip_unrecognized(iface, pToken);
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
wined3d: The namedArrays code path is dead (always FALSE). Delete the entire namedArrays code path and all its dependencies (one of which is quite long - storeOrder in drawprim is always FALSE, for example). Delete declaredArrays, and make its code path the default.
2006-06-12 06:51:58 +00:00
/* Nothing to do */
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (WINED3DSIO_DCL == curOpcode->opcode ||
WINED3DSIO_NOP == curOpcode->opcode ||
WINED3DSIO_DEF == curOpcode->opcode ||
WINED3DSIO_DEFI == curOpcode->opcode ||
WINED3DSIO_DEFB == curOpcode->opcode ||
WINED3DSIO_PHASE == curOpcode->opcode ||
WINED3DSIO_RET == curOpcode->opcode) {
wined3d: The namedArrays code path is dead (always FALSE). Delete the entire namedArrays code path and all its dependencies (one of which is quite long - storeOrder in drawprim is always FALSE, for example). Delete declaredArrays, and make its code path the default.
2006-06-12 06:51:58 +00:00
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
wined3d: The namedArrays code path is dead (always FALSE). Delete the entire namedArrays code path and all its dependencies (one of which is quite long - storeOrder in drawprim is always FALSE, for example). Delete declaredArrays, and make its code path the default.
2006-06-12 06:51:58 +00:00
wined3d: Further split GLSL & ARB_v/f_program generation and allow GLSL functions to be called.
2006-05-10 02:47:35 +00:00
/* If a generator function is set for current shader target, use it */
wined3d: Simplify generate_base_shader() when checking for USING_GLSL usage.
2006-05-18 17:43:32 +00:00
} else if (hw_fct != NULL) {
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
hw_arg.opcode = curOpcode;
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
/* Destination token */
if (curOpcode->dst_token) {
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
DWORD param, addr_token = 0;
wined3d: The namedArrays code path is dead (always FALSE). Delete the entire namedArrays code path and all its dependencies (one of which is quite long - storeOrder in drawprim is always FALSE, for example). Delete declaredArrays, and make its code path the default.
2006-06-12 06:51:58 +00:00
pToken += shader_get_param(iface, pToken, &param, &addr_token);
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
hw_arg.dst = param;
hw_arg.dst_addr = addr_token;
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
}
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
/* Predication token */
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
if (hw_arg.opcode_token & D3DSHADER_INSTRUCTION_PREDICATED)
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
hw_arg.predicate = *pToken++;
wined3d: Take predication tokens into account. Each instruction can have a predication token. Account for it in the trace pass, register count pass, and store it in the SHADER_OPCODE_ARG structure for generation. MSDN claims the token is at the end of the instruction, but that's not true - testing a demo, which lets me manipulate the shader shows the predication token is the first source token immediately following the destination token.
2006-05-18 01:09:56 +00:00
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
/* Other source tokens */
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
for (i = 0; i < (curOpcode->num_params - curOpcode->dst_token); i++) {
wined3d: Use shader_get_param() in trace pass, reg. count pass, generation pass. Change the trace pass, the register counting pass, and the hw generator pass to take into account the new get_params() function. For hw generation, store the address tokens into the SHADER_OPCODE_ARG structure, so they're available to generator functions.
2006-05-17 06:04:30 +00:00
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
DWORD param, addr_token = 0;
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
pToken += shader_get_param(iface, pToken, &param, &addr_token);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
hw_arg.src[i] = param;
hw_arg.src_addr[i] = addr_token;
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
}
wined3d: Further split GLSL & ARB_v/f_program generation and allow GLSL functions to be called.
2006-05-10 02:47:35 +00:00
/* Call appropriate function for output target */
wined3d: Simplify generate_base_shader() when checking for USING_GLSL usage.
2006-05-18 17:43:32 +00:00
hw_fct(&hw_arg);
wined3d: Further split GLSL & ARB_v/f_program generation and allow GLSL functions to be called.
2006-05-10 02:47:35 +00:00
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 02:32:14 +00:00
/* Process instruction modifiers for GLSL apps ( _sat, etc. ) */
wined3d: Rework shader mode selection. - currently half the shader selection code (GLSL vs ARB) is in fillGLcaps. The parts that check for software shaders are in GetDeviceCaps. That placement, will work, but is definitely not optimal. FillGLcaps should detect support - it should not make decision as to what's used, because that's not what the purpose of the function is. GetDeviceCaps should report support as it has already been selected. Instead, select shader mode in its own function, called in the appropriate places. - unifying pixel and vertex shaders into a single selection is a mistake. A software vertex shader can be coupled with a hardware arb or glsl pixel shader, or no shader at all. Split them back into two and add a SHADER_NONE variant. - drawprim is doing support checks for ARB_PROGRAM, and making shader decisions based on that - that's wrong, support has already been checked, and decided upon, and shaders can be implemented via software, ARB_PROGRAm or GLSL, so that support check isn't valid. - Store the shader selected mode into the shader itself. Different types of shaders can be combined, so this is an improvement. In fact, storing the mode into the settings globally is a mistake as well - it should be done per device, since different cards have different capabilities.
2006-07-04 07:21:53 +00:00
if (This->baseShader.shader_mode == SHADER_GLSL)
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 02:32:14 +00:00
shader_glsl_add_instruction_modifiers(&hw_arg);
wined3d: The namedArrays code path is dead (always FALSE). Delete the entire namedArrays code path and all its dependencies (one of which is quite long - storeOrder in drawprim is always FALSE, for example). Delete declaredArrays, and make its code path the default.
2006-06-12 06:51:58 +00:00
/* Unhandled opcode */
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
} else {
wined3d: The namedArrays code path is dead (always FALSE). Delete the entire namedArrays code path and all its dependencies (one of which is quite long - storeOrder in drawprim is always FALSE, for example). Delete declaredArrays, and make its code path the default.
2006-06-12 06:51:58 +00:00
FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
pToken += shader_skip_opcode(This, curOpcode, hw_arg.opcode_token);
wined3d: Created generate_base_shader which will be shared by pixel & vertex shaders.
2006-05-10 02:32:34 +00:00
}
}
/* TODO: What about result.depth? */
}
}
wined3d: Share shader_dump_ins_modifiers(). Share shader_dump_ins_modifiers(), and make vertex shaders use it. The saturate modifer (_sat) is valid on vs_3_0+, and it isn't being shown in the trace.
2006-05-10 17:53:07 +00:00
void shader_dump_ins_modifiers(const DWORD output) {
DWORD shift = (output & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT;
DWORD mmask = output & D3DSP_DSTMOD_MASK;
switch (shift) {
case 0: break;
case 13: TRACE("_d8"); break;
case 14: TRACE("_d4"); break;
case 15: TRACE("_d2"); break;
case 1: TRACE("_x2"); break;
case 2: TRACE("_x4"); break;
case 3: TRACE("_x8"); break;
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
default: TRACE("_unhandled_shift(%d)", shift); break;
wined3d: Share shader_dump_ins_modifiers(). Share shader_dump_ins_modifiers(), and make vertex shaders use it. The saturate modifer (_sat) is valid on vs_3_0+, and it isn't being shown in the trace.
2006-05-10 17:53:07 +00:00
}
wined3d: Allow multiple output modifiers.
2006-05-17 05:58:19 +00:00
if (mmask & D3DSPDM_SATURATE) TRACE("_sat");
if (mmask & D3DSPDM_PARTIALPRECISION) TRACE("_pp");
if (mmask & D3DSPDM_MSAMPCENTROID) TRACE("_centroid");
mmask &= ~(D3DSPDM_SATURATE | D3DSPDM_PARTIALPRECISION | D3DSPDM_MSAMPCENTROID);
if (mmask)
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
FIXME("_unrecognized_modifier(%#x)", mmask >> D3DSP_DSTMOD_SHIFT);
wined3d: Share shader_dump_ins_modifiers(). Share shader_dump_ins_modifiers(), and make vertex shaders use it. The saturate modifer (_sat) is valid on vs_3_0+, and it isn't being shown in the trace.
2006-05-10 17:53:07 +00:00
}
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
/* First pass: trace shader, initialize length and version */
void shader_trace_init(
IWineD3DBaseShader *iface,
const DWORD* pFunction) {
IWineD3DBaseShaderImpl *This =(IWineD3DBaseShaderImpl *)iface;
const DWORD* pToken = pFunction;
const SHADER_OPCODE* curOpcode = NULL;
DWORD opcode_token;
unsigned int len = 0;
DWORD i;
TRACE("(%p) : Parsing programme\n", This);
if (NULL != pToken) {
while (D3DVS_END() != *pToken) {
if (shader_is_version_token(*pToken)) { /** version */
This->baseShader.hex_version = *pToken;
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("%s_%u_%u\n", shader_is_pshader_version(This->baseShader.hex_version)? "ps": "vs",
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
D3DSHADER_VERSION_MAJOR(This->baseShader.hex_version),
D3DSHADER_VERSION_MINOR(This->baseShader.hex_version));
++pToken;
++len;
continue;
}
if (shader_is_comment(*pToken)) { /** comment */
DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
++pToken;
TRACE("//%s\n", (char*)pToken);
pToken += comment_len;
len += comment_len + 1;
continue;
}
opcode_token = *pToken++;
curOpcode = shader_get_opcode(iface, opcode_token);
len++;
if (NULL == curOpcode) {
int tokens_read;
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
FIXME("Unrecognized opcode: token=%08x\n", opcode_token);
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
tokens_read = shader_skip_unrecognized(iface, pToken);
pToken += tokens_read;
len += tokens_read;
} else {
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
if (curOpcode->opcode == WINED3DSIO_DCL) {
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
DWORD usage = *pToken;
DWORD param = *(pToken + 1);
wined3d: Fix faulty DCL trace.
2006-07-03 06:03:47 +00:00
shader_dump_decl_usage(This, usage, param);
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
shader_dump_ins_modifiers(param);
TRACE(" ");
shader_dump_param(iface, param, 0, 0);
pToken += 2;
len += 2;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (curOpcode->opcode == WINED3DSIO_DEF) {
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
unsigned int offset = shader_get_float_offset(*pToken);
TRACE("def c%u = %f, %f, %f, %f", offset,
*(float *)(pToken + 1),
*(float *)(pToken + 2),
*(float *)(pToken + 3),
*(float *)(pToken + 4));
pToken += 5;
len += 5;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (curOpcode->opcode == WINED3DSIO_DEFI) {
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("defi i%u = %d, %d, %d, %d", *pToken & D3DSP_REGNUM_MASK,
*(pToken + 1),
*(pToken + 2),
*(pToken + 3),
*(pToken + 4));
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
pToken += 5;
len += 5;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
} else if (curOpcode->opcode == WINED3DSIO_DEFB) {
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("defb b%u = %s", *pToken & D3DSP_REGNUM_MASK,
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
*(pToken + 1)? "true": "false");
pToken += 2;
len += 2;
} else {
DWORD param, addr_token;
int tokens_read;
/* Print out predication source token first - it follows
* the destination token. */
if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) {
TRACE("(");
shader_dump_param(iface, *(pToken + 2), 0, 1);
TRACE(") ");
}
TRACE("%s", curOpcode->name);
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-09 23:45:12 +00:00
if (curOpcode->opcode == WINED3DSIO_IFC ||
curOpcode->opcode == WINED3DSIO_BREAKC) {
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
DWORD op = (opcode_token & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
switch (op) {
case COMPARISON_GT: TRACE("_gt"); break;
case COMPARISON_EQ: TRACE("_eq"); break;
case COMPARISON_GE: TRACE("_ge"); break;
case COMPARISON_LT: TRACE("_lt"); break;
case COMPARISON_NE: TRACE("_ne"); break;
case COMPARISON_LE: TRACE("_le"); break;
default:
wined3d: Win64 printf fixes.
2006-10-01 03:20:10 +00:00
TRACE("_(%u)", op);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 09:11:35 +00:00
}
}
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
/* Destination token */
if (curOpcode->dst_token) {
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
/* Destination token */
tokens_read = shader_get_param(iface, pToken, &param, &addr_token);
pToken += tokens_read;
len += tokens_read;
shader_dump_ins_modifiers(param);
TRACE(" ");
shader_dump_param(iface, param, addr_token, 0);
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
}
/* Predication token - already printed out, just skip it */
if (opcode_token & D3DSHADER_INSTRUCTION_PREDICATED) {
pToken++;
len++;
}
/* Other source tokens */
for (i = curOpcode->dst_token; i < curOpcode->num_params; ++i) {
tokens_read = shader_get_param(iface, pToken, &param, &addr_token);
pToken += tokens_read;
len += tokens_read;
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
wined3d: Mark instructions without a destination token. There are a total of 17 instructions without a destination token. Of those 9 have num_params != 0, which means that we will not process any of them correctly, because we assume the first token (if present) is a destination token. Those are basically all the flow control instructions, which we plan to support very soon. They have source tokens, and no destination. Add a flag that marks them up to the ins table. Use this flag in the trace pass, and generation pass.
2006-06-12 10:57:04 +00:00
TRACE((i == 0)? " " : ", ");
shader_dump_param(iface, param, addr_token, 1);
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 06:54:30 +00:00
}
}
TRACE("\n");
}
}
This->baseShader.functionLength = (len + 1) * sizeof(DWORD);
} else {
This->baseShader.functionLength = 1; /* no Function defined use fixed function vertex processing */
}
}
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 04:51:03 +00:00
void shader_delete_constant_list(
struct list* clist) {
struct list *ptr;
struct local_constant* constant;
ptr = list_head(clist);
while (ptr) {
constant = LIST_ENTRY(ptr, struct local_constant, entry);
ptr = list_next(clist, ptr);
HeapFree(GetProcessHeap(), 0, constant);
}
}
Reference in New Issue Copy Permalink