2 * Pixel and vertex shaders implementation using ARB_vertex_program
3 * and ARB_fragment_program GL extensions.
5 * Copyright 2002-2003 Jason Edmeades
6 * Copyright 2002-2003 Raphael Junqueira
7 * Copyright 2004 Christian Costa
8 * Copyright 2005 Oliver Stieber
9 * Copyright 2006 Ivan Gyurdiev
10 * Copyright 2006 Jason Green
11 * Copyright 2006 Henri Verbeet
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
33 #include "wined3d_private.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader
);
37 #define GLINFO_LOCATION (*gl_info)
39 /********************************************************
40 * ARB_[vertex/fragment]_program helper functions follow
41 ********************************************************/
44 * Loads floating point constants into the currently set ARB_vertex/fragment_program.
45 * When constant_list == NULL, it will load all the constants.
47 * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
48 * or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
50 static void shader_arb_load_constantsF(IWineD3DBaseShaderImpl
* This
, WineD3D_GL_Info
*gl_info
, GLuint target_type
,
51 unsigned int max_constants
, float* constants
, struct list
*constant_list
) {
52 constant_entry
*constant
;
53 local_constant
* lconst
;
57 if (TRACE_ON(d3d_shader
)) {
58 for (i
= 0; i
< max_constants
; ++i
) {
59 TRACE("Loading constants %i: %f, %f, %f, %f\n", i
,
60 constants
[i
* 4 + 0], constants
[i
* 4 + 1],
61 constants
[i
* 4 + 2], constants
[i
* 4 + 3]);
64 for (i
= 0; i
< max_constants
; ++i
) {
65 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type
, i
, constants
+ (i
* 4)));
67 checkGLcall("glProgramEnvParameter4fvARB()");
69 if (TRACE_ON(d3d_shader
)) {
70 LIST_FOR_EACH_ENTRY(constant
, constant_list
, constant_entry
, entry
) {
72 TRACE("Loading constants %i: %f, %f, %f, %f\n", i
,
73 constants
[i
* 4 + 0], constants
[i
* 4 + 1],
74 constants
[i
* 4 + 2], constants
[i
* 4 + 3]);
77 LIST_FOR_EACH_ENTRY(constant
, constant_list
, constant_entry
, entry
) {
79 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type
, i
, constants
+ (i
* 4)));
81 checkGLcall("glProgramEnvParameter4fvARB()");
84 /* Load immediate constants */
85 if (TRACE_ON(d3d_shader
)) {
86 LIST_FOR_EACH_ENTRY(lconst
, &This
->baseShader
.constantsF
, local_constant
, entry
) {
87 GLfloat
* values
= (GLfloat
*)lconst
->value
;
88 TRACE("Loading local constants %i: %f, %f, %f, %f\n", lconst
->idx
,
89 values
[0], values
[1], values
[2], values
[3]);
92 LIST_FOR_EACH_ENTRY(lconst
, &This
->baseShader
.constantsF
, local_constant
, entry
) {
93 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type
, lconst
->idx
, (GLfloat
*)lconst
->value
));
95 checkGLcall("glProgramEnvParameter4fvARB()");
99 * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
101 * We only support float constants in ARB at the moment, so don't
102 * worry about the Integers or Booleans
104 void shader_arb_load_constants(
105 IWineD3DDevice
* device
,
107 char useVertexShader
) {
109 IWineD3DDeviceImpl
* deviceImpl
= (IWineD3DDeviceImpl
*) device
;
110 IWineD3DStateBlockImpl
* stateBlock
= deviceImpl
->stateBlock
;
111 WineD3D_GL_Info
*gl_info
= &((IWineD3DImpl
*)deviceImpl
->wineD3D
)->gl_info
;
113 if (useVertexShader
) {
114 IWineD3DBaseShaderImpl
* vshader
= (IWineD3DBaseShaderImpl
*) stateBlock
->vertexShader
;
115 IWineD3DVertexShaderImpl
* vshader_impl
= (IWineD3DVertexShaderImpl
*) stateBlock
->vertexShader
;
116 IWineD3DVertexDeclarationImpl
* vertexDeclaration
=
117 (IWineD3DVertexDeclarationImpl
*) vshader_impl
->vertexDeclaration
;
119 if (NULL
!= vertexDeclaration
&& NULL
!= vertexDeclaration
->constants
) {
120 /* Load DirectX 8 float constants for vertex shader */
121 shader_arb_load_constantsF(vshader
, gl_info
, GL_VERTEX_PROGRAM_ARB
,
122 GL_LIMITS(vshader_constantsF
),
123 vertexDeclaration
->constants
, NULL
);
126 /* Load DirectX 9 float constants for vertex shader */
127 shader_arb_load_constantsF(vshader
, gl_info
, GL_VERTEX_PROGRAM_ARB
,
128 GL_LIMITS(vshader_constantsF
),
129 stateBlock
->vertexShaderConstantF
,
130 &stateBlock
->set_vconstantsF
);
132 /* Upload the position fixup */
133 GL_EXTCALL(glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB
, ARB_SHADER_PRIVCONST_POS
, deviceImpl
->posFixup
));
136 if (usePixelShader
) {
138 IWineD3DBaseShaderImpl
* pshader
= (IWineD3DBaseShaderImpl
*) stateBlock
->pixelShader
;
140 /* Load DirectX 9 float constants for pixel shader */
141 shader_arb_load_constantsF(pshader
, gl_info
, GL_FRAGMENT_PROGRAM_ARB
,
142 GL_LIMITS(pshader_constantsF
),
143 stateBlock
->pixelShaderConstantF
,
144 &stateBlock
->set_pconstantsF
);
148 /* Generate the variable & register declarations for the ARB_vertex_program output target */
149 void shader_generate_arb_declarations(
150 IWineD3DBaseShader
*iface
,
151 shader_reg_maps
* reg_maps
,
152 SHADER_BUFFER
* buffer
,
153 WineD3D_GL_Info
* gl_info
) {
155 IWineD3DBaseShaderImpl
* This
= (IWineD3DBaseShaderImpl
*) iface
;
157 char pshader
= shader_is_pshader_version(This
->baseShader
.hex_version
);
158 unsigned max_constantsF
= min(This
->baseShader
.limits
.constant_float
,
159 (pshader
? GL_LIMITS(pshader_constantsF
) : GL_LIMITS(vshader_constantsF
)));
161 /* Temporary Output register */
162 shader_addline(buffer
, "TEMP TMP_OUT;\n");
164 for(i
= 0; i
< This
->baseShader
.limits
.temporary
; i
++) {
165 if (reg_maps
->temporary
[i
])
166 shader_addline(buffer
, "TEMP R%u;\n", i
);
169 for (i
= 0; i
< This
->baseShader
.limits
.address
; i
++) {
170 if (reg_maps
->address
[i
])
171 shader_addline(buffer
, "ADDRESS A%d;\n", i
);
174 for(i
= 0; i
< This
->baseShader
.limits
.texcoord
; i
++) {
175 if (reg_maps
->texcoord
[i
])
176 shader_addline(buffer
,"TEMP T%u;\n", i
);
179 /* Texture coordinate registers must be pre-loaded */
180 for (i
= 0; i
< This
->baseShader
.limits
.texcoord
; i
++) {
181 if (reg_maps
->texcoord
[i
])
182 shader_addline(buffer
, "MOV T%u, fragment.texcoord[%u];\n", i
, i
);
185 /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
186 shader_addline(buffer
, "PARAM C[%d] = { program.env[0..%d] };\n",
187 max_constantsF
, max_constantsF
- 1);
190 static const char* shift_tab
[] = {
191 "dummy", /* 0 (none) */
192 "coefmul.x", /* 1 (x2) */
193 "coefmul.y", /* 2 (x4) */
194 "coefmul.z", /* 3 (x8) */
195 "coefmul.w", /* 4 (x16) */
196 "dummy", /* 5 (x32) */
197 "dummy", /* 6 (x64) */
198 "dummy", /* 7 (x128) */
199 "dummy", /* 8 (d256) */
200 "dummy", /* 9 (d128) */
201 "dummy", /* 10 (d64) */
202 "dummy", /* 11 (d32) */
203 "coefdiv.w", /* 12 (d16) */
204 "coefdiv.z", /* 13 (d8) */
205 "coefdiv.y", /* 14 (d4) */
206 "coefdiv.x" /* 15 (d2) */
209 static void pshader_get_write_mask(const DWORD output_reg
, char *write_mask
) {
211 if ((output_reg
& WINED3DSP_WRITEMASK_ALL
) != WINED3DSP_WRITEMASK_ALL
) {
212 strcat(write_mask
, ".");
213 if (output_reg
& WINED3DSP_WRITEMASK_0
) strcat(write_mask
, "r");
214 if (output_reg
& WINED3DSP_WRITEMASK_1
) strcat(write_mask
, "g");
215 if (output_reg
& WINED3DSP_WRITEMASK_2
) strcat(write_mask
, "b");
216 if (output_reg
& WINED3DSP_WRITEMASK_3
) strcat(write_mask
, "a");
220 /* TODO: merge with pixel shader */
221 static void vshader_program_add_output_param_swizzle(const DWORD param
, int is_color
, char *hwLine
) {
222 /** operand output */
223 if ((param
& WINED3DSP_WRITEMASK_ALL
) != WINED3DSP_WRITEMASK_ALL
) {
225 if (param
& WINED3DSP_WRITEMASK_0
) { strcat(hwLine
, "x"); }
226 if (param
& WINED3DSP_WRITEMASK_1
) { strcat(hwLine
, "y"); }
227 if (param
& WINED3DSP_WRITEMASK_2
) { strcat(hwLine
, "z"); }
228 if (param
& WINED3DSP_WRITEMASK_3
) { strcat(hwLine
, "w"); }
232 static void pshader_get_input_register_swizzle(const DWORD instr
, char *swzstring
) {
233 static const char swizzle_reg_chars
[] = "rgba";
234 DWORD swizzle
= (instr
& WINED3DSP_SWIZZLE_MASK
) >> WINED3DSP_SWIZZLE_SHIFT
;
235 DWORD swizzle_x
= swizzle
& 0x03;
236 DWORD swizzle_y
= (swizzle
>> 2) & 0x03;
237 DWORD swizzle_z
= (swizzle
>> 4) & 0x03;
238 DWORD swizzle_w
= (swizzle
>> 6) & 0x03;
240 * swizzle bits fields:
244 if ((WINED3DSP_NOSWIZZLE
>> WINED3DSP_SWIZZLE_SHIFT
) != swizzle
) {
245 if (swizzle_x
== swizzle_y
&&
246 swizzle_x
== swizzle_z
&&
247 swizzle_x
== swizzle_w
) {
248 sprintf(swzstring
, ".%c", swizzle_reg_chars
[swizzle_x
]);
250 sprintf(swzstring
, ".%c%c%c%c",
251 swizzle_reg_chars
[swizzle_x
],
252 swizzle_reg_chars
[swizzle_y
],
253 swizzle_reg_chars
[swizzle_z
],
254 swizzle_reg_chars
[swizzle_w
]);
259 /* TODO: merge with pixel shader */
260 static void vshader_program_add_input_param_swizzle(const DWORD param
, int is_color
, char *hwLine
) {
261 static const char swizzle_reg_chars_color_fix
[] = "zyxw";
262 static const char swizzle_reg_chars
[] = "xyzw";
263 const char* swizzle_regs
= NULL
;
267 DWORD swizzle
= (param
& WINED3DVS_SWIZZLE_MASK
) >> WINED3DVS_SWIZZLE_SHIFT
;
268 DWORD swizzle_x
= swizzle
& 0x03;
269 DWORD swizzle_y
= (swizzle
>> 2) & 0x03;
270 DWORD swizzle_z
= (swizzle
>> 4) & 0x03;
271 DWORD swizzle_w
= (swizzle
>> 6) & 0x03;
274 swizzle_regs
= swizzle_reg_chars_color_fix
;
276 swizzle_regs
= swizzle_reg_chars
;
280 * swizzle bits fields:
283 if ((WINED3DVS_NOSWIZZLE
>> WINED3DVS_SWIZZLE_SHIFT
) == swizzle
) {
285 sprintf(tmpReg
, ".%c%c%c%c",
286 swizzle_regs
[swizzle_x
],
287 swizzle_regs
[swizzle_y
],
288 swizzle_regs
[swizzle_z
],
289 swizzle_regs
[swizzle_w
]);
290 strcat(hwLine
, tmpReg
);
294 if (swizzle_x
== swizzle_y
&&
295 swizzle_x
== swizzle_z
&&
296 swizzle_x
== swizzle_w
)
298 sprintf(tmpReg
, ".%c", swizzle_regs
[swizzle_x
]);
299 strcat(hwLine
, tmpReg
);
301 sprintf(tmpReg
, ".%c%c%c%c",
302 swizzle_regs
[swizzle_x
],
303 swizzle_regs
[swizzle_y
],
304 swizzle_regs
[swizzle_z
],
305 swizzle_regs
[swizzle_w
]);
306 strcat(hwLine
, tmpReg
);
310 static void pshader_get_register_name(
311 const DWORD param
, char* regstr
) {
313 DWORD reg
= param
& WINED3DSP_REGNUM_MASK
;
314 DWORD regtype
= shader_get_regtype(param
);
317 case WINED3DSPR_TEMP
:
318 sprintf(regstr
, "R%u", reg
);
320 case WINED3DSPR_INPUT
:
322 strcpy(regstr
, "fragment.color.primary");
324 strcpy(regstr
, "fragment.color.secondary");
327 case WINED3DSPR_CONST
:
328 sprintf(regstr
, "C[%u]", reg
);
330 case WINED3DSPR_TEXTURE
: /* case WINED3DSPR_ADDR: */
331 sprintf(regstr
,"T%u", reg
);
333 case WINED3DSPR_COLOROUT
:
335 sprintf(regstr
, "result.color");
337 /* TODO: See GL_ARB_draw_buffers */
338 FIXME("Unsupported write to render target %u\n", reg
);
339 sprintf(regstr
, "unsupported_register");
342 case WINED3DSPR_DEPTHOUT
:
343 sprintf(regstr
, "result.depth");
345 case WINED3DSPR_ATTROUT
:
346 sprintf(regstr
, "oD[%u]", reg
);
348 case WINED3DSPR_TEXCRDOUT
:
349 sprintf(regstr
, "oT[%u]", reg
);
352 FIXME("Unhandled register name Type(%d)\n", regtype
);
353 sprintf(regstr
, "unrecognized_register");
358 /* TODO: merge with pixel shader */
359 static void vshader_program_add_param(SHADER_OPCODE_ARG
*arg
, const DWORD param
, BOOL is_input
, char *hwLine
) {
361 IWineD3DVertexShaderImpl
* This
= (IWineD3DVertexShaderImpl
*) arg
->shader
;
363 /* oPos, oFog and oPts in D3D */
364 static const char* hwrastout_reg_names
[] = { "TMP_OUT", "TMP_FOG", "result.pointsize" };
366 DWORD reg
= param
& WINED3DSP_REGNUM_MASK
;
367 DWORD regtype
= shader_get_regtype(param
);
369 BOOL is_color
= FALSE
;
371 if ((param
& WINED3DSP_SRCMOD_MASK
) == WINED3DSPSM_NEG
) {
372 strcat(hwLine
, " -");
378 case WINED3DSPR_TEMP
:
379 sprintf(tmpReg
, "R%u", reg
);
380 strcat(hwLine
, tmpReg
);
382 case WINED3DSPR_INPUT
:
384 if (vshader_input_is_color((IWineD3DVertexShader
*) This
, reg
))
387 sprintf(tmpReg
, "vertex.attrib[%u]", reg
);
388 strcat(hwLine
, tmpReg
);
390 case WINED3DSPR_CONST
:
391 sprintf(tmpReg
, "C[%s%u]", (param
& WINED3DSHADER_ADDRMODE_RELATIVE
) ? "A0.x + " : "", reg
);
392 strcat(hwLine
, tmpReg
);
394 case WINED3DSPR_ADDR
: /*case D3DSPR_TEXTURE:*/
395 sprintf(tmpReg
, "A%u", reg
);
396 strcat(hwLine
, tmpReg
);
398 case WINED3DSPR_RASTOUT
:
399 sprintf(tmpReg
, "%s", hwrastout_reg_names
[reg
]);
400 strcat(hwLine
, tmpReg
);
402 case WINED3DSPR_ATTROUT
:
404 strcat(hwLine
, "result.color.primary");
406 strcat(hwLine
, "result.color.secondary");
409 case WINED3DSPR_TEXCRDOUT
:
410 sprintf(tmpReg
, "result.texcoord[%u]", reg
);
411 strcat(hwLine
, tmpReg
);
414 FIXME("Unknown reg type %d %d\n", regtype
, reg
);
415 strcat(hwLine
, "unrecognized_register");
420 vshader_program_add_output_param_swizzle(param
, is_color
, hwLine
);
422 vshader_program_add_input_param_swizzle(param
, is_color
, hwLine
);
426 static void pshader_gen_input_modifier_line (
427 SHADER_BUFFER
* buffer
,
432 /* Generate a line that does the input modifier computation and return the input register to use */
437 /* Assume a new line will be added */
440 /* Get register name */
441 pshader_get_register_name(instr
, regstr
);
442 pshader_get_input_register_swizzle(instr
, swzstr
);
444 switch (instr
& WINED3DSP_SRCMOD_MASK
) {
445 case WINED3DSPSM_NONE
:
446 sprintf(outregstr
, "%s%s", regstr
, swzstr
);
449 case WINED3DSPSM_NEG
:
450 sprintf(outregstr
, "-%s%s", regstr
, swzstr
);
453 case WINED3DSPSM_BIAS
:
454 shader_addline(buffer
, "ADD T%c, %s, -coefdiv.x;\n", 'A' + tmpreg
, regstr
);
456 case WINED3DSPSM_BIASNEG
:
457 shader_addline(buffer
, "ADD T%c, -%s, coefdiv.x;\n", 'A' + tmpreg
, regstr
);
459 case WINED3DSPSM_SIGN
:
460 shader_addline(buffer
, "MAD T%c, %s, coefmul.x, -one.x;\n", 'A' + tmpreg
, regstr
);
462 case WINED3DSPSM_SIGNNEG
:
463 shader_addline(buffer
, "MAD T%c, %s, -coefmul.x, one.x;\n", 'A' + tmpreg
, regstr
);
465 case WINED3DSPSM_COMP
:
466 shader_addline(buffer
, "SUB T%c, one.x, %s;\n", 'A' + tmpreg
, regstr
);
469 shader_addline(buffer
, "ADD T%c, %s, %s;\n", 'A' + tmpreg
, regstr
, regstr
);
471 case WINED3DSPSM_X2NEG
:
472 shader_addline(buffer
, "ADD T%c, -%s, -%s;\n", 'A' + tmpreg
, regstr
, regstr
);
475 shader_addline(buffer
, "RCP T%c, %s.z;\n", 'A' + tmpreg
, regstr
);
476 shader_addline(buffer
, "MUL T%c, %s, T%c;\n", 'A' + tmpreg
, regstr
, 'A' + tmpreg
);
479 shader_addline(buffer
, "RCP T%c, %s.w;\n", 'A' + tmpreg
, regstr
);
480 shader_addline(buffer
, "MUL T%c, %s, T%c;\n", 'A' + tmpreg
, regstr
, 'A' + tmpreg
);
483 sprintf(outregstr
, "%s%s", regstr
, swzstr
);
487 /* Return modified or original register, with swizzle */
489 sprintf(outregstr
, "T%c%s", 'A' + tmpreg
, swzstr
);
492 inline static void pshader_gen_output_modifier_line(
493 SHADER_BUFFER
* buffer
,
499 /* Generate a line that does the output modifier computation */
500 shader_addline(buffer
, "MUL%s %s%s, %s, %s;\n", saturate
? "_SAT" : "",
501 regstr
, write_mask
, regstr
, shift_tab
[shift
]);
504 void pshader_hw_cnd(SHADER_OPCODE_ARG
* arg
) {
506 SHADER_BUFFER
* buffer
= arg
->buffer
;
509 char src_name
[3][50];
511 /* FIXME: support output modifiers */
513 /* Handle output register */
514 pshader_get_register_name(arg
->dst
, dst_name
);
515 pshader_get_write_mask(arg
->dst
, dst_wmask
);
516 strcat(dst_name
, dst_wmask
);
518 /* Generate input register names (with modifiers) */
519 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src_name
[0]);
520 pshader_gen_input_modifier_line(buffer
, arg
->src
[1], 1, src_name
[1]);
521 pshader_gen_input_modifier_line(buffer
, arg
->src
[2], 2, src_name
[2]);
523 shader_addline(buffer
, "ADD TMP, -%s, coefdiv.x;\n", src_name
[0]);
524 shader_addline(buffer
, "CMP %s, TMP, %s, %s;\n", dst_name
, src_name
[1], src_name
[2]);
527 void pshader_hw_cmp(SHADER_OPCODE_ARG
* arg
) {
529 SHADER_BUFFER
* buffer
= arg
->buffer
;
532 char src_name
[3][50];
534 /* FIXME: support output modifiers */
536 /* Handle output register */
537 pshader_get_register_name(arg
->dst
, dst_name
);
538 pshader_get_write_mask(arg
->dst
, dst_wmask
);
539 strcat(dst_name
, dst_wmask
);
541 /* Generate input register names (with modifiers) */
542 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src_name
[0]);
543 pshader_gen_input_modifier_line(buffer
, arg
->src
[1], 1, src_name
[1]);
544 pshader_gen_input_modifier_line(buffer
, arg
->src
[2], 2, src_name
[2]);
546 shader_addline(buffer
, "CMP %s, %s, %s, %s;\n", dst_name
,
547 src_name
[0], src_name
[2], src_name
[1]);
550 /* Map the opcode 1-to-1 to the GL code */
551 void pshader_hw_map2gl(SHADER_OPCODE_ARG
* arg
) {
553 CONST SHADER_OPCODE
* curOpcode
= arg
->opcode
;
554 SHADER_BUFFER
* buffer
= arg
->buffer
;
555 DWORD dst
= arg
->dst
;
556 DWORD
* src
= arg
->src
;
561 /* Output token related */
562 char output_rname
[256];
563 char output_wmask
[20];
564 BOOL saturate
= FALSE
;
565 BOOL centroid
= FALSE
;
566 BOOL partialprecision
= FALSE
;
569 strcpy(tmpLine
, curOpcode
->glname
);
571 /* Process modifiers */
572 if (0 != (dst
& WINED3DSP_DSTMOD_MASK
)) {
573 DWORD mask
= dst
& WINED3DSP_DSTMOD_MASK
;
575 saturate
= mask
& WINED3DSPDM_SATURATE
;
576 centroid
= mask
& WINED3DSPDM_MSAMPCENTROID
;
577 partialprecision
= mask
& WINED3DSPDM_PARTIALPRECISION
;
578 mask
&= ~(WINED3DSPDM_MSAMPCENTROID
| WINED3DSPDM_PARTIALPRECISION
| WINED3DSPDM_SATURATE
);
580 FIXME("Unrecognized modifier(0x%#x)\n", mask
>> WINED3DSP_DSTMOD_SHIFT
);
583 FIXME("Unhandled modifier(0x%#x)\n", mask
>> WINED3DSP_DSTMOD_SHIFT
);
585 shift
= (dst
& WINED3DSP_DSTSHIFT_MASK
) >> WINED3DSP_DSTSHIFT_SHIFT
;
587 /* Generate input and output registers */
588 if (curOpcode
->num_params
> 0) {
589 char operands
[4][100];
591 /* Generate input register names (with modifiers) */
592 for (i
= 1; i
< curOpcode
->num_params
; ++i
)
593 pshader_gen_input_modifier_line(buffer
, src
[i
-1], i
-1, operands
[i
]);
595 /* Handle output register */
596 pshader_get_register_name(dst
, output_rname
);
597 strcpy(operands
[0], output_rname
);
598 pshader_get_write_mask(dst
, output_wmask
);
599 strcat(operands
[0], output_wmask
);
601 if (saturate
&& (shift
== 0))
602 strcat(tmpLine
, "_SAT");
603 strcat(tmpLine
, " ");
604 strcat(tmpLine
, operands
[0]);
605 for (i
= 1; i
< curOpcode
->num_params
; i
++) {
606 strcat(tmpLine
, ", ");
607 strcat(tmpLine
, operands
[i
]);
609 strcat(tmpLine
,";\n");
610 shader_addline(buffer
, tmpLine
);
612 /* A shift requires another line. */
614 pshader_gen_output_modifier_line(buffer
, saturate
, output_wmask
, shift
, output_rname
);
618 void pshader_hw_tex(SHADER_OPCODE_ARG
* arg
) {
620 IWineD3DPixelShaderImpl
* This
= (IWineD3DPixelShaderImpl
*) arg
->shader
;
621 IWineD3DDeviceImpl
* deviceImpl
= (IWineD3DDeviceImpl
*) This
->baseShader
.device
;
623 DWORD dst
= arg
->dst
;
624 DWORD
* src
= arg
->src
;
625 SHADER_BUFFER
* buffer
= arg
->buffer
;
626 DWORD hex_version
= This
->baseShader
.hex_version
;
630 const char *tex_type
;
632 DWORD reg_sampler_code
;
635 /* All versions have a destination register */
636 reg_dest_code
= dst
& WINED3DSP_REGNUM_MASK
;
637 pshader_get_register_name(dst
, reg_dest
);
639 /* 1.0-1.3: Use destination register as coordinate source.
640 1.4+: Use provided coordinate source register. */
641 if (hex_version
< WINED3DPS_VERSION(1,4))
642 strcpy(reg_coord
, reg_dest
);
644 pshader_gen_input_modifier_line(buffer
, src
[0], 0, reg_coord
);
646 /* 1.0-1.4: Use destination register number as texture code.
647 2.0+: Use provided sampler number as texure code. */
648 if (hex_version
< WINED3DPS_VERSION(2,0))
649 reg_sampler_code
= reg_dest_code
;
651 reg_sampler_code
= src
[1] & WINED3DSP_REGNUM_MASK
;
653 sampler_type
= arg
->reg_maps
->samplers
[reg_sampler_code
] & WINED3DSP_TEXTURETYPE_MASK
;
654 switch(sampler_type
) {
663 case WINED3DSTT_VOLUME
:
667 case WINED3DSTT_CUBE
:
672 ERR("Unexpected texture type %d\n", sampler_type
);
676 if (deviceImpl
->stateBlock
->textureState
[reg_sampler_code
][WINED3DTSS_TEXTURETRANSFORMFLAGS
] & WINED3DTTFF_PROJECTED
) {
677 shader_addline(buffer
, "TXP %s, %s, texture[%u], %s;\n",
678 reg_dest
, reg_coord
, reg_sampler_code
, tex_type
);
680 shader_addline(buffer
, "TEX %s, %s, texture[%u], %s;\n",
681 reg_dest
, reg_coord
, reg_sampler_code
, tex_type
);
685 void pshader_hw_texcoord(SHADER_OPCODE_ARG
* arg
) {
687 IWineD3DPixelShaderImpl
* This
= (IWineD3DPixelShaderImpl
*) arg
->shader
;
688 DWORD dst
= arg
->dst
;
689 DWORD
* src
= arg
->src
;
690 SHADER_BUFFER
* buffer
= arg
->buffer
;
691 DWORD hex_version
= This
->baseShader
.hex_version
;
694 pshader_get_write_mask(dst
, tmp
);
695 if (hex_version
!= WINED3DPS_VERSION(1,4)) {
696 DWORD reg
= dst
& WINED3DSP_REGNUM_MASK
;
697 shader_addline(buffer
, "MOV_SAT T%u%s, fragment.texcoord[%u];\n", reg
, tmp
, reg
);
699 DWORD reg1
= dst
& WINED3DSP_REGNUM_MASK
;
700 DWORD reg2
= src
[0] & WINED3DSP_REGNUM_MASK
;
701 shader_addline(buffer
, "MOV R%u%s, fragment.texcoord[%u];\n", reg1
, tmp
, reg2
);
705 void pshader_hw_texreg2ar(SHADER_OPCODE_ARG
* arg
) {
707 SHADER_BUFFER
* buffer
= arg
->buffer
;
709 DWORD reg1
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
710 DWORD reg2
= arg
->src
[0] & WINED3DSP_REGNUM_MASK
;
711 shader_addline(buffer
, "MOV TMP.r, T%u.a;\n", reg2
);
712 shader_addline(buffer
, "MOV TMP.g, T%u.r;\n", reg2
);
713 shader_addline(buffer
, "TEX T%u, TMP, texture[%u], 2D;\n", reg1
, reg1
);
716 void pshader_hw_texreg2gb(SHADER_OPCODE_ARG
* arg
) {
718 SHADER_BUFFER
* buffer
= arg
->buffer
;
720 DWORD reg1
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
721 DWORD reg2
= arg
->src
[0] & WINED3DSP_REGNUM_MASK
;
722 shader_addline(buffer
, "MOV TMP.r, T%u.g;\n", reg2
);
723 shader_addline(buffer
, "MOV TMP.g, T%u.b;\n", reg2
);
724 shader_addline(buffer
, "TEX T%u, TMP, texture[%u], 2D;\n", reg1
, reg1
);
727 void pshader_hw_texbem(SHADER_OPCODE_ARG
* arg
) {
729 SHADER_BUFFER
* buffer
= arg
->buffer
;
730 DWORD reg1
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
731 DWORD reg2
= arg
->src
[0] & WINED3DSP_REGNUM_MASK
;
733 /* FIXME: Should apply the BUMPMAPENV matrix */
734 shader_addline(buffer
, "ADD TMP.rg, fragment.texcoord[%u], T%u;\n", reg1
, reg2
);
735 shader_addline(buffer
, "TEX T%u, TMP, texture[%u], 2D;\n", reg1
, reg1
);
738 void pshader_hw_texm3x2pad(SHADER_OPCODE_ARG
* arg
) {
740 DWORD reg
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
741 SHADER_BUFFER
* buffer
= arg
->buffer
;
744 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src0_name
);
745 shader_addline(buffer
, "DP3 TMP.x, T%u, %s;\n", reg
, src0_name
);
748 void pshader_hw_texm3x2tex(SHADER_OPCODE_ARG
* arg
) {
750 DWORD reg
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
751 SHADER_BUFFER
* buffer
= arg
->buffer
;
754 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src0_name
);
755 shader_addline(buffer
, "DP3 TMP.y, T%u, %s;\n", reg
, src0_name
);
756 shader_addline(buffer
, "TEX T%u, TMP, texture[%u], 2D;\n", reg
, reg
);
759 void pshader_hw_texm3x3pad(SHADER_OPCODE_ARG
* arg
) {
761 IWineD3DPixelShaderImpl
* This
= (IWineD3DPixelShaderImpl
*) arg
->shader
;
762 DWORD reg
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
763 SHADER_BUFFER
* buffer
= arg
->buffer
;
764 SHADER_PARSE_STATE
* current_state
= &This
->baseShader
.parse_state
;
767 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src0_name
);
768 shader_addline(buffer
, "DP3 TMP.%c, T%u, %s;\n", 'x' + current_state
->current_row
, reg
, src0_name
);
769 current_state
->texcoord_w
[current_state
->current_row
++] = reg
;
772 void pshader_hw_texm3x3tex(SHADER_OPCODE_ARG
* arg
) {
774 IWineD3DPixelShaderImpl
* This
= (IWineD3DPixelShaderImpl
*) arg
->shader
;
775 DWORD reg
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
776 SHADER_BUFFER
* buffer
= arg
->buffer
;
777 SHADER_PARSE_STATE
* current_state
= &This
->baseShader
.parse_state
;
780 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src0_name
);
781 shader_addline(buffer
, "DP3 TMP.z, T%u, %s;\n", reg
, src0_name
);
783 /* Cubemap textures will be more used than 3D ones. */
784 shader_addline(buffer
, "TEX T%u, TMP, texture[%u], CUBE;\n", reg
, reg
);
785 current_state
->current_row
= 0;
788 void pshader_hw_texm3x3vspec(SHADER_OPCODE_ARG
* arg
) {
790 IWineD3DPixelShaderImpl
* This
= (IWineD3DPixelShaderImpl
*) arg
->shader
;
791 DWORD reg
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
792 SHADER_BUFFER
* buffer
= arg
->buffer
;
793 SHADER_PARSE_STATE
* current_state
= &This
->baseShader
.parse_state
;
796 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src0_name
);
797 shader_addline(buffer
, "DP3 TMP.z, T%u, %s;\n", reg
, src0_name
);
799 /* Construct the eye-ray vector from w coordinates */
800 shader_addline(buffer
, "MOV TMP2.x, fragment.texcoord[%u].w;\n", current_state
->texcoord_w
[0]);
801 shader_addline(buffer
, "MOV TMP2.y, fragment.texcoord[%u].w;\n", current_state
->texcoord_w
[1]);
802 shader_addline(buffer
, "MOV TMP2.z, fragment.texcoord[%u].w;\n", reg
);
804 /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
805 shader_addline(buffer
, "DP3 TMP.w, TMP, TMP2;\n");
806 shader_addline(buffer
, "MUL TMP, TMP.w, TMP;\n");
807 shader_addline(buffer
, "MAD TMP, coefmul.x, TMP, -TMP2;\n");
809 /* Cubemap textures will be more used than 3D ones. */
810 shader_addline(buffer
, "TEX T%u, TMP, texture[%u], CUBE;\n", reg
, reg
);
811 current_state
->current_row
= 0;
814 void pshader_hw_texm3x3spec(SHADER_OPCODE_ARG
* arg
) {
816 IWineD3DPixelShaderImpl
* This
= (IWineD3DPixelShaderImpl
*) arg
->shader
;
817 DWORD reg
= arg
->dst
& WINED3DSP_REGNUM_MASK
;
818 DWORD reg3
= arg
->src
[1] & WINED3DSP_REGNUM_MASK
;
819 SHADER_PARSE_STATE
* current_state
= &This
->baseShader
.parse_state
;
820 SHADER_BUFFER
* buffer
= arg
->buffer
;
823 pshader_gen_input_modifier_line(buffer
, arg
->src
[0], 0, src0_name
);
824 shader_addline(buffer
, "DP3 TMP.z, T%u, %s;\n", reg
, src0_name
);
826 /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
827 shader_addline(buffer
, "DP3 TMP.w, TMP, C[%u];\n", reg3
);
828 shader_addline(buffer
, "MUL TMP, TMP.w, TMP;\n");
829 shader_addline(buffer
, "MAD TMP, coefmul.x, TMP, -C[%u];\n", reg3
);
831 /* Cubemap textures will be more used than 3D ones. */
832 shader_addline(buffer
, "TEX T%u, TMP, texture[%u], CUBE;\n", reg
, reg
);
833 current_state
->current_row
= 0;
836 /** Handles transforming all WINED3DSIO_M?x? opcodes for
837 Vertex shaders to ARB_vertex_program codes */
838 void vshader_hw_mnxn(SHADER_OPCODE_ARG
* arg
) {
842 SHADER_OPCODE_ARG tmpArg
;
844 memset(&tmpArg
, 0, sizeof(SHADER_OPCODE_ARG
));
846 /* Set constants for the temporary argument */
847 tmpArg
.shader
= arg
->shader
;
848 tmpArg
.buffer
= arg
->buffer
;
849 tmpArg
.src
[0] = arg
->src
[0];
850 tmpArg
.src_addr
[0] = arg
->src_addr
[0];
851 tmpArg
.src_addr
[1] = arg
->src_addr
[1];
852 tmpArg
.reg_maps
= arg
->reg_maps
;
854 switch(arg
->opcode
->opcode
) {
855 case WINED3DSIO_M4x4
:
857 tmpArg
.opcode
= &IWineD3DVertexShaderImpl_shader_ins
[WINED3DSIO_DP4
];
859 case WINED3DSIO_M4x3
:
861 tmpArg
.opcode
= &IWineD3DVertexShaderImpl_shader_ins
[WINED3DSIO_DP4
];
863 case WINED3DSIO_M3x4
:
865 tmpArg
.opcode
= &IWineD3DVertexShaderImpl_shader_ins
[WINED3DSIO_DP3
];
867 case WINED3DSIO_M3x3
:
869 tmpArg
.opcode
= &IWineD3DVertexShaderImpl_shader_ins
[WINED3DSIO_DP3
];
871 case WINED3DSIO_M3x2
:
873 tmpArg
.opcode
= &IWineD3DVertexShaderImpl_shader_ins
[WINED3DSIO_DP3
];
879 for (i
= 0; i
< nComponents
; i
++) {
880 tmpArg
.dst
= ((arg
->dst
) & ~WINED3DSP_WRITEMASK_ALL
)|(WINED3DSP_WRITEMASK_0
<<i
);
881 tmpArg
.src
[1] = arg
->src
[1]+i
;
882 vshader_hw_map2gl(&tmpArg
);
886 /* TODO: merge with pixel shader */
887 /* Map the opcode 1-to-1 to the GL code */
888 void vshader_hw_map2gl(SHADER_OPCODE_ARG
* arg
) {
890 CONST SHADER_OPCODE
* curOpcode
= arg
->opcode
;
891 SHADER_BUFFER
* buffer
= arg
->buffer
;
892 DWORD dst
= arg
->dst
;
893 DWORD
* src
= arg
->src
;
895 DWORD dst_regtype
= shader_get_regtype(dst
);
899 if ((curOpcode
->opcode
== WINED3DSIO_MOV
&& dst_regtype
== WINED3DSPR_ADDR
) || curOpcode
->opcode
== WINED3DSIO_MOVA
)
900 strcpy(tmpLine
, "ARL");
902 strcpy(tmpLine
, curOpcode
->glname
);
904 if (curOpcode
->num_params
> 0) {
905 vshader_program_add_param(arg
, dst
, FALSE
, tmpLine
);
906 for (i
= 1; i
< curOpcode
->num_params
; ++i
) {
907 strcat(tmpLine
, ",");
908 vshader_program_add_param(arg
, src
[i
-1], TRUE
, tmpLine
);
911 shader_addline(buffer
, "%s;\n", tmpLine
);