ReactOS 0.4.15-dev-7108-g1cf6ce6
arb_program_shader.c
Go to the documentation of this file.
1/*
2 * Pixel and vertex shaders implementation using ARB_vertex_program
3 * and ARB_fragment_program GL extensions.
4 *
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
12 * Copyright 2007-2011, 2013-2014 Stefan Dösinger for CodeWeavers
13 * Copyright 2009 Henri Verbeet for CodeWeavers
14 *
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 */
29
30#include "config.h"
31#include "wine/port.h"
32
33#include <stdio.h>
34
35#include "wined3d_private.h"
36
41
43{
45}
46
48{
50}
51
52static const char *get_line(const char **ptr)
53{
54 const char *p, *q;
55
56 p = *ptr;
57 if (!(q = strstr(p, "\n")))
58 {
59 if (!*p) return NULL;
60 *ptr += strlen(p);
61 return p;
62 }
63 *ptr = q + 1;
64
65 return p;
66}
67
69{
75
77};
78
80{
82 {
83 ERR("Unsupported shader type '%s'.\n", debug_shader_type(shader));
84 return "bad";
85 }
86
88 {
89 switch (value)
90 {
91 case ARB_ZERO: return "ps_helper_const.x";
92 case ARB_ONE: return "ps_helper_const.y";
93 case ARB_TWO: return "coefmul.x";
94 case ARB_0001: return "ps_helper_const.xxxy";
95 case ARB_EPS: return "ps_helper_const.z";
96 default: break;
97 }
98 }
99 else
100 {
101 switch (value)
102 {
103 case ARB_ZERO: return "helper_const.x";
104 case ARB_ONE: return "helper_const.y";
105 case ARB_TWO: return "helper_const.z";
106 case ARB_EPS: return "helper_const.w";
107 case ARB_0001: return "helper_const.xxxy";
108 case ARB_VS_REL_OFFSET: return "rel_addr_const.y";
109 }
110 }
111 FIXME("Unmanaged %s shader helper constant requested: %u.\n",
112 shader == WINED3D_SHADER_TYPE_PIXEL ? "pixel" : "vertex", value);
113 switch (value)
114 {
115 case ARB_ZERO: return "0.0";
116 case ARB_ONE: return "1.0";
117 case ARB_TWO: return "2.0";
118 case ARB_0001: return "{0.0, 0.0, 0.0, 1.0}";
119 case ARB_EPS: return "1e-8";
120 default: return "bad";
121 }
122}
123
124static inline BOOL ffp_clip_emul(const struct wined3d_context *context)
125{
126 return context->lowest_disabled_stage < 7;
127}
128
129/* ARB_program_shader private data */
130
132{
133 struct list entry;
134 enum
135 {
139 REP
143 union
144 {
145 unsigned int loop;
146 unsigned int ifc;
147 } no;
150};
151
153{
155 /* For ARB we need an offset value:
156 * With both GLSL and ARB mode the NP2 fixup information (the texture dimensions) are stored in a
157 * consecutive way (GLSL uses a uniform array). Since ARB doesn't know the notion of a "standalone"
158 * array we need an offset to the index inside the program local parameter array. */
160};
161
163{
166 WORD clip; /* only a boolean, use a WORD for alignment */
168};
169
171{
172 unsigned char texunit;
174};
175
177{
185 unsigned char numbumpenvmatconsts;
187};
188
190{
192 union
193 {
194 struct
195 {
197 unsigned char clip_texcoord;
198 unsigned char clipplane_mask;
203 union
204 {
205 unsigned char samplers[4];
209};
210
212{
219};
220
222{
224 struct list entry;
225};
226
228{
229 char addr_reg[20];
230 enum
231 {
232 /* plain GL_ARB_vertex_program or GL_ARB_fragment_program */
234 /* GL_NV_vertex_program2_option or GL_NV_fragment_program_option */
236 /* GL_NV_vertex_program3 or GL_NV_fragment_program2 */
237 NV3
239
246 struct list record;
250 int aL;
252
253 unsigned int vs_clipplanes;
256
257 /* For 3.0 vertex shaders */
259 /* For 2.x and earlier vertex shaders */
260 const char *texcrd_output[8], *color_output[2], *fog_output;
261
262 /* 3.0 pshader input for compatibility with fixed function */
264};
265
267{
271};
272
279};
280
285};
286
288{
297
300
305
309};
310
311/* Context activation for state handlers is done by the caller. */
312
313static BOOL need_rel_addr_const(const struct arb_vshader_private *shader_data,
314 const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info)
315{
316 if (shader_data->rel_offset) return TRUE;
317 if (!reg_maps->usesmova) return FALSE;
318 return !gl_info->supported[NV_VERTEX_PROGRAM2_OPTION];
319}
320
321/* Returns TRUE if result.clip from GL_NV_vertex_program2 should be used and FALSE otherwise */
322static inline BOOL use_nv_clip(const struct wined3d_gl_info *gl_info)
323{
324 return gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]
325 && !(gl_info->quirks & WINED3D_QUIRK_NV_CLIP_BROKEN);
326}
327
328static BOOL need_helper_const(const struct arb_vshader_private *shader_data,
329 const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info)
330{
331 if (need_rel_addr_const(shader_data, reg_maps, gl_info)) return TRUE;
332 if (!gl_info->supported[NV_VERTEX_PROGRAM]) return TRUE; /* Need to init colors. */
333 if (gl_info->quirks & WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT) return TRUE; /* Load the immval offset. */
334 if (gl_info->quirks & WINED3D_QUIRK_SET_TEXCOORD_W) return TRUE; /* Have to init texcoords. */
335 if (!use_nv_clip(gl_info)) return TRUE; /* Init the clip texcoord */
336 if (reg_maps->usesnrm) return TRUE; /* 0.0 */
337 if (reg_maps->usespow) return TRUE; /* EPS, 0.0 and 1.0 */
338 if (reg_maps->fog) return TRUE; /* Clamping fog coord, 0.0 and 1.0 */
339 return FALSE;
340}
341
342static unsigned int reserved_vs_const(const struct arb_vshader_private *shader_data,
343 const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info)
344{
345 unsigned int ret = 1;
346 /* We use one PARAM for the pos fixup, and in some cases one to load
347 * some immediate values into the shader. */
348 if (need_helper_const(shader_data, reg_maps, gl_info)) ++ret;
349 if (need_rel_addr_const(shader_data, reg_maps, gl_info)) ++ret;
350 return ret;
351}
352
353/* Loads floating point constants into the currently set ARB_vertex/fragment_program.
354 * When constant_list == NULL, it will load all the constants.
355 *
356 * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
357 * or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
358 */
359/* Context activation is done by the caller. */
360static unsigned int shader_arb_load_constants_f(const struct wined3d_shader *shader,
361 const struct wined3d_gl_info *gl_info, GLuint target_type, unsigned int max_constants,
362 const struct wined3d_vec4 *constants, char *dirty_consts)
363{
364 struct wined3d_shader_lconst *lconst;
365 unsigned int ret, i, j;
366
367 if (TRACE_ON(d3d_constants))
368 {
369 for (i = 0; i < max_constants; ++i)
370 {
371 if (!dirty_consts[i])
372 continue;
373 TRACE_(d3d_constants)("Loading constant %u: %s.\n", i, debug_vec4(&constants[i]));
374 }
375 }
376
377 i = 0;
378
379 /* In 1.X pixel shaders constants are implicitly clamped in the range [-1;1] */
380 if (target_type == GL_FRAGMENT_PROGRAM_ARB && shader->reg_maps.shader_version.major == 1)
381 {
382 float lcl_const[4];
383 /* ps 1.x supports only 8 constants, clamp only those. When switching between 1.x and higher
384 * shaders, the first 8 constants are marked dirty for reload
385 */
386 for (; i < min(8, max_constants); ++i)
387 {
388 if (!dirty_consts[i])
389 continue;
390 dirty_consts[i] = 0;
391
392 if (constants[i].x > 1.0f)
393 lcl_const[0] = 1.0f;
394 else if (constants[i].x < -1.0f)
395 lcl_const[0] = -1.0f;
396 else
397 lcl_const[0] = constants[i].x;
398
399 if (constants[i].y > 1.0f)
400 lcl_const[1] = 1.0f;
401 else if (constants[i].y < -1.0f)
402 lcl_const[1] = -1.0f;
403 else
404 lcl_const[1] = constants[i].y;
405
406 if (constants[i].z > 1.0f)
407 lcl_const[2] = 1.0f;
408 else if (constants[i].z < -1.0f)
409 lcl_const[2] = -1.0f;
410 else
411 lcl_const[2] = constants[i].z;
412
413 if (constants[i].w > 1.0f)
414 lcl_const[3] = 1.0f;
415 else if (constants[i].w < -1.0f)
416 lcl_const[3] = -1.0f;
417 else
418 lcl_const[3] = constants[i].w;
419
420 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, lcl_const));
421 }
422
423 /* If further constants are dirty, reload them without clamping.
424 *
425 * The alternative is not to touch them, but then we cannot reset the dirty constant count
426 * to zero. That's bad for apps that only use PS 1.x shaders, because in that case the code
427 * above would always re-check the first 8 constants since max_constant remains at the init
428 * value
429 */
430 }
431
433 {
434 /* TODO: Benchmark if we're better of with finding the dirty constants ourselves,
435 * or just reloading *all* constants at once
436 *
437 GL_EXTCALL(glProgramEnvParameters4fvEXT(target_type, i, max_constants, constants + (i * 4)));
438 */
439 for (; i < max_constants; ++i)
440 {
441 if (!dirty_consts[i])
442 continue;
443
444 /* Find the next block of dirty constants */
445 dirty_consts[i] = 0;
446 j = i;
447 for (++i; (i < max_constants) && dirty_consts[i]; ++i)
448 {
449 dirty_consts[i] = 0;
450 }
451
452 GL_EXTCALL(glProgramEnvParameters4fvEXT(target_type, j, i - j, &constants[j].x));
453 }
454 }
455 else
456 {
457 for (; i < max_constants; ++i)
458 {
459 if (dirty_consts[i])
460 {
461 dirty_consts[i] = 0;
462 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, &constants[i].x));
463 }
464 }
465 }
466 checkGLcall("glProgramEnvParameter4fvARB()");
467
468 /* Load immediate constants */
469 if (shader->load_local_constsF)
470 {
471 if (TRACE_ON(d3d_shader))
472 {
473 LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
474 {
475 GLfloat* values = (GLfloat*)lconst->value;
476 TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
477 values[0], values[1], values[2], values[3]);
478 }
479 }
480 /* Immediate constants are clamped for 1.X shaders at loading times */
481 ret = 0;
482 LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
483 {
484 dirty_consts[lconst->idx] = 1; /* Dirtify so the non-immediate constant overwrites it next time */
485 ret = max(ret, lconst->idx + 1);
486 GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, lconst->idx, (GLfloat*)lconst->value));
487 }
488 checkGLcall("glProgramEnvParameter4fvARB()");
489 return ret; /* The loaded immediate constants need reloading for the next shader */
490 } else {
491 return 0; /* No constants are dirty now */
492 }
493}
494
495/* Loads the texture dimensions for NP2 fixup into the currently set
496 * ARB_[vertex/fragment]_programs. */
498 const struct wined3d_gl_info *gl_info, const struct wined3d_state *state)
499{
500 GLfloat np2fixup_constants[4 * MAX_FRAGMENT_SAMPLERS];
501 WORD active = fixup->super.active;
502 UINT i;
503
504 if (!active)
505 return;
506
507 for (i = 0; active; active >>= 1, ++i)
508 {
509 const struct wined3d_texture *tex = state->textures[i];
510 unsigned char idx = fixup->super.idx[i];
511 GLfloat *tex_dim = &np2fixup_constants[(idx >> 1) * 4];
512
513 if (!(active & 1))
514 continue;
515
516 if (!tex)
517 {
518 ERR("Nonexistent texture is flagged for NP2 texcoord fixup.\n");
519 continue;
520 }
521
522 if (idx % 2)
523 {
524 tex_dim[2] = tex->pow2_matrix[0];
525 tex_dim[3] = tex->pow2_matrix[5];
526 }
527 else
528 {
529 tex_dim[0] = tex->pow2_matrix[0];
530 tex_dim[1] = tex->pow2_matrix[5];
531 }
532 }
533
534 for (i = 0; i < fixup->super.num_consts; ++i)
535 {
536 GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
537 fixup->offset + i, &np2fixup_constants[i * 4]));
538 }
539}
540
541/* Context activation is done by the caller. */
542static void shader_arb_ps_local_constants(const struct arb_ps_compiled_shader *gl_shader,
543 const struct wined3d_context *context, const struct wined3d_state *state, UINT rt_height)
544{
545 const struct wined3d_gl_info *gl_info = context->gl_info;
546 unsigned char i;
547
548 for(i = 0; i < gl_shader->numbumpenvmatconsts; i++)
549 {
550 int texunit = gl_shader->bumpenvmatconst[i].texunit;
551
552 /* The state manager takes care that this function is always called if the bump env matrix changes */
553 const float *data = (const float *)&state->texture_states[texunit][WINED3D_TSS_BUMPENV_MAT00];
554 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
555 gl_shader->bumpenvmatconst[i].const_num, data));
556
557 if (gl_shader->luminanceconst[i].const_num != WINED3D_CONST_NUM_UNUSED)
558 {
559 /* WINED3D_TSS_BUMPENVLSCALE and WINED3D_TSS_BUMPENVLOFFSET are next to each other.
560 * point gl to the scale, and load 4 floats. x = scale, y = offset, z and w are junk, we
561 * don't care about them. The pointers are valid for sure because the stateblock is bigger.
562 * (they're WINED3D_TSS_TEXTURETRANSFORMFLAGS and WINED3D_TSS_ADDRESSW, so most likely 0 or NaN
563 */
564 const float *scale = (const float *)&state->texture_states[texunit][WINED3D_TSS_BUMPENV_LSCALE];
565 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
566 gl_shader->luminanceconst[i].const_num, scale));
567 }
568 }
569 checkGLcall("Load bumpmap consts");
570
571 if(gl_shader->ycorrection != WINED3D_CONST_NUM_UNUSED)
572 {
573 /* ycorrection.x: Backbuffer height(onscreen) or 0(offscreen).
574 * ycorrection.y: -1.0(onscreen), 1.0(offscreen)
575 * ycorrection.z: 1.0
576 * ycorrection.w: 0.0
577 */
578 float val[4];
579 val[0] = context->render_offscreen ? 0.0f : (float) rt_height;
580 val[1] = context->render_offscreen ? 1.0f : -1.0f;
581 val[2] = 1.0f;
582 val[3] = 0.0f;
583 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->ycorrection, val));
584 checkGLcall("y correction loading");
585 }
586
587 if (!gl_shader->num_int_consts) return;
588
589 for (i = 0; i < WINED3D_MAX_CONSTS_I; ++i)
590 {
591 if(gl_shader->int_consts[i] != WINED3D_CONST_NUM_UNUSED)
592 {
593 float val[4];
594 val[0] = (float)state->ps_consts_i[i].x;
595 val[1] = (float)state->ps_consts_i[i].y;
596 val[2] = (float)state->ps_consts_i[i].z;
597 val[3] = -1.0f;
598
599 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, gl_shader->int_consts[i], val));
600 }
601 }
602 checkGLcall("Load ps int consts");
603}
604
605/* Context activation is done by the caller. */
606static void shader_arb_vs_local_constants(const struct arb_vs_compiled_shader *gl_shader,
607 const struct wined3d_context *context, const struct wined3d_state *state)
608{
609 const struct wined3d_gl_info *gl_info = context->gl_info;
610 float position_fixup[4];
611 unsigned char i;
612
613 /* Upload the position fixup */
614 shader_get_position_fixup(context, state, position_fixup);
615 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, gl_shader->pos_fixup, position_fixup));
616
617 if (!gl_shader->num_int_consts) return;
618
619 for (i = 0; i < WINED3D_MAX_CONSTS_I; ++i)
620 {
621 if(gl_shader->int_consts[i] != WINED3D_CONST_NUM_UNUSED)
622 {
623 float val[4];
624 val[0] = (float)state->vs_consts_i[i].x;
625 val[1] = (float)state->vs_consts_i[i].y;
626 val[2] = (float)state->vs_consts_i[i].z;
627 val[3] = -1.0f;
628
629 GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, gl_shader->int_consts[i], val));
630 }
631 }
632 checkGLcall("Load vs int consts");
633}
634
635static void shader_arb_select(void *shader_priv, struct wined3d_context *context,
636 const struct wined3d_state *state);
637
644/* Context activation is done by the caller (state handler). */
646 struct wined3d_context *context, const struct wined3d_state *state,
647 BOOL usePixelShader, BOOL useVertexShader, BOOL from_shader_select)
648{
649 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
650 const struct wined3d_gl_info *gl_info = context->gl_info;
651
652 if (!from_shader_select)
653 {
654 const struct wined3d_shader *vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
655 const struct wined3d_shader *pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
656
657 if (vshader
658 && (vshader->reg_maps.boolean_constants
660 && (vshader->reg_maps.integer_constants & ~vshader->reg_maps.local_int_consts))))
661 {
662 TRACE("bool/integer vertex shader constants potentially modified, forcing shader reselection.\n");
664 }
665 else if (pshader
666 && (pshader->reg_maps.boolean_constants
668 && (pshader->reg_maps.integer_constants & ~pshader->reg_maps.local_int_consts))))
669 {
670 TRACE("bool/integer pixel shader constants potentially modified, forcing shader reselection.\n");
672 }
673 }
674
675 if (context != priv->last_context)
676 {
678 sizeof(*priv->vshader_const_dirty) * d3d_info->limits.vs_uniform_count);
679 priv->highest_dirty_vs_const = d3d_info->limits.vs_uniform_count;
680
682 sizeof(*priv->pshader_const_dirty) * d3d_info->limits.ps_uniform_count);
683 priv->highest_dirty_ps_const = d3d_info->limits.ps_uniform_count;
684
685 priv->last_context = context;
686 }
687
688 if (useVertexShader)
689 {
690 const struct wined3d_shader *vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
691 const struct arb_vs_compiled_shader *gl_shader = priv->compiled_vprog;
692
693 /* Load DirectX 9 float constants for vertex shader */
695 priv->highest_dirty_vs_const, state->vs_consts_f, priv->vshader_const_dirty);
697 }
698
699 if (usePixelShader)
700 {
701 const struct wined3d_shader *pshader = state->shader[WINED3D_SHADER_TYPE_PIXEL];
702 const struct arb_ps_compiled_shader *gl_shader = priv->compiled_fprog;
703 UINT rt_height = state->fb->render_targets[0]->height;
704
705 /* Load DirectX 9 float constants for pixel shader */
707 priv->highest_dirty_ps_const, state->ps_consts_f, priv->pshader_const_dirty);
708 shader_arb_ps_local_constants(gl_shader, context, state, rt_height);
709
710 if (context->constant_update_mask & WINED3D_SHADER_CONST_PS_NP2_FIXUP)
712 }
713}
714
715static void shader_arb_load_constants(void *shader_priv, struct wined3d_context *context,
716 const struct wined3d_state *state)
717{
718 BOOL vs = use_vs(state);
719 BOOL ps = use_ps(state);
720
722}
723
725{
727 struct shader_arb_priv *priv = device->shader_priv;
728
729 /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
730 * context. On a context switch the old context will be fully dirtified */
731 if (!context || context->device != device)
732 return;
733
734 memset(priv->vshader_const_dirty + start, 1, sizeof(*priv->vshader_const_dirty) * count);
736}
737
739{
741 struct shader_arb_priv *priv = device->shader_priv;
742
743 /* We don't want shader constant dirtification to be an O(contexts), so just dirtify the active
744 * context. On a context switch the old context will be fully dirtified */
745 if (!context || context->device != device)
746 return;
747
748 memset(priv->pshader_const_dirty + start, 1, sizeof(*priv->pshader_const_dirty) * count);
750}
751
753{
754 char str[4][17];
755
756 wined3d_ftoa(values[0], str[0]);
757 wined3d_ftoa(values[1], str[1]);
758 wined3d_ftoa(values[2], str[2]);
759 wined3d_ftoa(values[3], str[3]);
760 shader_addline(buffer, "{%s, %s, %s, %s}", str[0], str[1], str[2], str[3]);
761}
762
763/* Generate the variable & register declarations for the ARB_vertex_program output target */
765 const struct wined3d_shader_reg_maps *reg_maps, struct wined3d_string_buffer *buffer,
766 const struct wined3d_gl_info *gl_info, DWORD *num_clipplanes,
767 const struct shader_arb_ctx_priv *ctx)
768{
769 DWORD i;
770 char pshader = shader_is_pshader_version(reg_maps->shader_version.type);
771 const struct wined3d_shader_lconst *lconst;
772 unsigned max_constantsF;
773 DWORD map;
774
775 /* In pixel shaders, all private constants are program local, we don't need anything
776 * from program.env. Thus we can advertise the full set of constants in pixel shaders.
777 * If we need a private constant the GL implementation will squeeze it in somewhere
778 *
779 * With vertex shaders we need the posFixup and on some GL implementations 4 helper
780 * immediate values. The posFixup is loaded using program.env for now, so always
781 * subtract one from the number of constants. If the shader uses indirect addressing,
782 * account for the helper const too because we have to declare all available d3d constants
783 * and don't know which are actually used.
784 */
785 if (pshader)
786 {
787 max_constantsF = gl_info->limits.arb_ps_native_constants;
788 /* 24 is the minimum MAX_PROGRAM_ENV_PARAMETERS_ARB value. */
789 if (max_constantsF < 24)
790 max_constantsF = gl_info->limits.arb_ps_float_constants;
791 }
792 else
793 {
794 const struct arb_vshader_private *shader_data = shader->backend_data;
795 max_constantsF = gl_info->limits.arb_vs_native_constants;
796 /* 96 is the minimum MAX_PROGRAM_ENV_PARAMETERS_ARB value.
797 * Also prevents max_constantsF from becoming less than 0 and
798 * wrapping . */
799 if (max_constantsF < 96)
800 max_constantsF = gl_info->limits.arb_vs_float_constants;
801
802 if (reg_maps->usesrelconstF)
803 {
804 DWORD highest_constf = 0, clip_limit;
805
806 max_constantsF -= reserved_vs_const(shader_data, reg_maps, gl_info);
807 max_constantsF -= wined3d_popcount(reg_maps->integer_constants);
808 max_constantsF -= gl_info->reserved_arb_constants;
809
810 for (i = 0; i < shader->limits->constant_float; ++i)
811 {
812 DWORD idx = i >> 5;
813 DWORD shift = i & 0x1f;
814 if (reg_maps->constf[idx] & (1u << shift))
815 highest_constf = i;
816 }
817
818 if(use_nv_clip(gl_info) && ctx->target_version >= NV2)
819 {
820 if(ctx->cur_vs_args->super.clip_enabled)
821 clip_limit = gl_info->limits.user_clip_distances;
822 else
823 clip_limit = 0;
824 }
825 else
826 {
827 unsigned int mask = ctx->cur_vs_args->clip.boolclip.clipplane_mask;
828 clip_limit = min(wined3d_popcount(mask), 4);
829 }
830 *num_clipplanes = min(clip_limit, max_constantsF - highest_constf - 1);
831 max_constantsF -= *num_clipplanes;
832 if(*num_clipplanes < clip_limit)
833 {
834 WARN("Only %u clip planes out of %u enabled.\n", *num_clipplanes,
835 gl_info->limits.user_clip_distances);
836 }
837 }
838 else
839 {
840 if (ctx->target_version >= NV2)
841 *num_clipplanes = gl_info->limits.user_clip_distances;
842 else
843 *num_clipplanes = min(gl_info->limits.user_clip_distances, 4);
844 }
845 }
846
847 for (i = 0, map = reg_maps->temporary; map; map >>= 1, ++i)
848 {
849 if (map & 1) shader_addline(buffer, "TEMP R%u;\n", i);
850 }
851
852 for (i = 0, map = reg_maps->address; map; map >>= 1, ++i)
853 {
854 if (map & 1) shader_addline(buffer, "ADDRESS A%u;\n", i);
855 }
856
857 if (pshader && reg_maps->shader_version.major == 1 && reg_maps->shader_version.minor <= 3)
858 {
859 for (i = 0, map = reg_maps->texcoord; map; map >>= 1, ++i)
860 {
861 if (map & 1) shader_addline(buffer, "TEMP T%u;\n", i);
862 }
863 }
864
865 if (!shader->load_local_constsF)
866 {
867 LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
868 {
869 const float *value;
870 value = (const float *)lconst->value;
871 shader_addline(buffer, "PARAM C%u = ", lconst->idx);
873 shader_addline(buffer, ";\n");
874 }
875 }
876
877 /* After subtracting privately used constants from the hardware limit(they are loaded as
878 * local constants), make sure the shader doesn't violate the env constant limit
879 */
880 if (pshader)
881 {
882 max_constantsF = min(max_constantsF, gl_info->limits.arb_ps_float_constants);
883 }
884 else
885 {
886 max_constantsF = min(max_constantsF, gl_info->limits.arb_vs_float_constants);
887 }
888
889 /* Avoid declaring more constants than needed */
890 max_constantsF = min(max_constantsF, shader->limits->constant_float);
891
892 /* we use the array-based constants array if the local constants are marked for loading,
893 * because then we use indirect addressing, or when the local constant list is empty,
894 * because then we don't know if we're using indirect addressing or not. If we're hardcoding
895 * local constants do not declare the loaded constants as an array because ARB compilers usually
896 * do not optimize unused constants away
897 */
898 if (reg_maps->usesrelconstF)
899 {
900 /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
901 shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
902 max_constantsF, max_constantsF - 1);
903 }
904 else
905 {
906 for (i = 0; i < max_constantsF; ++i)
907 {
909 {
910 shader_addline(buffer, "PARAM C%d = program.env[%d];\n",i, i);
911 }
912 }
913 }
914}
915
916static const char * const shift_tab[] = {
917 "dummy", /* 0 (none) */
918 "coefmul.x", /* 1 (x2) */
919 "coefmul.y", /* 2 (x4) */
920 "coefmul.z", /* 3 (x8) */
921 "coefmul.w", /* 4 (x16) */
922 "dummy", /* 5 (x32) */
923 "dummy", /* 6 (x64) */
924 "dummy", /* 7 (x128) */
925 "dummy", /* 8 (d256) */
926 "dummy", /* 9 (d128) */
927 "dummy", /* 10 (d64) */
928 "dummy", /* 11 (d32) */
929 "coefdiv.w", /* 12 (d16) */
930 "coefdiv.z", /* 13 (d8) */
931 "coefdiv.y", /* 14 (d4) */
932 "coefdiv.x" /* 15 (d2) */
933};
934
936 const struct wined3d_shader_dst_param *dst, char *write_mask)
937{
938 char *ptr = write_mask;
939
940 if (dst->write_mask != WINED3DSP_WRITEMASK_ALL)
941 {
942 *ptr++ = '.';
943 if (dst->write_mask & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
944 if (dst->write_mask & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
945 if (dst->write_mask & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
946 if (dst->write_mask & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
947 }
948
949 *ptr = '\0';
950}
951
952static void shader_arb_get_swizzle(const struct wined3d_shader_src_param *param, BOOL fixup, char *swizzle_str)
953{
954 /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
955 * but addressed as "rgba". To fix this we need to swap the register's x
956 * and z components. */
957 const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
958 char *ptr = swizzle_str;
959
960 /* swizzle bits fields: wwzzyyxx */
961 DWORD swizzle = param->swizzle;
962 DWORD swizzle_x = swizzle & 0x03;
963 DWORD swizzle_y = (swizzle >> 2) & 0x03;
964 DWORD swizzle_z = (swizzle >> 4) & 0x03;
965 DWORD swizzle_w = (swizzle >> 6) & 0x03;
966
967 /* If the swizzle is the default swizzle (ie, "xyzw"), we don't need to
968 * generate a swizzle string. Unless we need to our own swizzling. */
969 if (swizzle != WINED3DSP_NOSWIZZLE || fixup)
970 {
971 *ptr++ = '.';
972 if (swizzle_x == swizzle_y && swizzle_x == swizzle_z && swizzle_x == swizzle_w) {
973 *ptr++ = swizzle_chars[swizzle_x];
974 } else {
975 *ptr++ = swizzle_chars[swizzle_x];
976 *ptr++ = swizzle_chars[swizzle_y];
977 *ptr++ = swizzle_chars[swizzle_z];
978 *ptr++ = swizzle_chars[swizzle_w];
979 }
980 }
981
982 *ptr = '\0';
983}
984
985static void shader_arb_request_a0(const struct wined3d_shader_instruction *ins, const char *src)
986{
987 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
988 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
989
990 if (!strcmp(priv->addr_reg, src)) return;
991
992 strcpy(priv->addr_reg, src);
993 shader_addline(buffer, "ARL A0.x, %s;\n", src);
994}
995
996static void shader_arb_get_src_param(const struct wined3d_shader_instruction *ins,
997 const struct wined3d_shader_src_param *src, unsigned int tmpreg, char *outregstr);
998
1000 const struct wined3d_shader_register *reg, char *register_name, BOOL *is_color)
1001{
1002 /* oPos, oFog and oPts in D3D */
1003 static const char * const rastout_reg_names[] = {"TMP_OUT", "TMP_FOGCOORD", "result.pointsize"};
1004 const struct wined3d_shader *shader = ins->ctx->shader;
1005 const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
1006 BOOL pshader = shader_is_pshader_version(reg_maps->shader_version.type);
1007 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1008
1009 *is_color = FALSE;
1010
1011 switch (reg->type)
1012 {
1013 case WINED3DSPR_TEMP:
1014 sprintf(register_name, "R%u", reg->idx[0].offset);
1015 break;
1016
1017 case WINED3DSPR_INPUT:
1018 if (pshader)
1019 {
1020 if (reg_maps->shader_version.major < 3)
1021 {
1022 if (!reg->idx[0].offset)
1023 strcpy(register_name, "fragment.color.primary");
1024 else
1025 strcpy(register_name, "fragment.color.secondary");
1026 }
1027 else
1028 {
1029 if (reg->idx[0].rel_addr)
1030 {
1031 char rel_reg[50];
1032 shader_arb_get_src_param(ins, reg->idx[0].rel_addr, 0, rel_reg);
1033
1034 if (!strcmp(rel_reg, "**aL_emul**"))
1035 {
1036 DWORD idx = ctx->aL + reg->idx[0].offset;
1037 if(idx < MAX_REG_INPUT)
1038 {
1039 strcpy(register_name, ctx->ps_input[idx]);
1040 }
1041 else
1042 {
1043 ERR("Pixel shader input register out of bounds: %u\n", idx);
1044 sprintf(register_name, "out_of_bounds_%u", idx);
1045 }
1046 }
1047 else if (reg_maps->input_registers & 0x0300)
1048 {
1049 /* There are two ways basically:
1050 *
1051 * 1) Use the unrolling code that is used for loop emulation and unroll the loop.
1052 * That means trouble if the loop also contains a breakc or if the control values
1053 * aren't local constants.
1054 * 2) Generate an if block that checks if aL.y < 8, == 8 or == 9 and selects the
1055 * source dynamically. The trouble is that we cannot simply read aL.y because it
1056 * is an ADDRESS register. We could however push it, load .zw with a value and use
1057 * ADAC to load the condition code register and pop it again afterwards
1058 */
1059 FIXME("Relative input register addressing with more than 8 registers\n");
1060
1061 /* This is better than nothing for now */
1062 sprintf(register_name, "fragment.texcoord[%s + %u]", rel_reg, reg->idx[0].offset);
1063 }
1064 else if(ctx->cur_ps_args->super.vp_mode != vertexshader)
1065 {
1066 /* This is problematic because we'd have to consult the ctx->ps_input strings
1067 * for where to find the varying. Some may be "0.0", others can be texcoords or
1068 * colors. This needs either a pipeline replacement to make the vertex shader feed
1069 * proper varyings, or loop unrolling
1070 *
1071 * For now use the texcoords and hope for the best
1072 */
1073 FIXME("Non-vertex shader varying input with indirect addressing\n");
1074 sprintf(register_name, "fragment.texcoord[%s + %u]", rel_reg, reg->idx[0].offset);
1075 }
1076 else
1077 {
1078 /* D3D supports indirect addressing only with aL in loop registers. The loop instruction
1079 * pulls GL_NV_fragment_program2 in
1080 */
1081 sprintf(register_name, "fragment.texcoord[%s + %u]", rel_reg, reg->idx[0].offset);
1082 }
1083 }
1084 else
1085 {
1086 if (reg->idx[0].offset < MAX_REG_INPUT)
1087 {
1088 strcpy(register_name, ctx->ps_input[reg->idx[0].offset]);
1089 }
1090 else
1091 {
1092 ERR("Pixel shader input register out of bounds: %u\n", reg->idx[0].offset);
1093 sprintf(register_name, "out_of_bounds_%u", reg->idx[0].offset);
1094 }
1095 }
1096 }
1097 }
1098 else
1099 {
1100 if (ctx->cur_vs_args->super.swizzle_map & (1u << reg->idx[0].offset))
1101 *is_color = TRUE;
1102 sprintf(register_name, "vertex.attrib[%u]", reg->idx[0].offset);
1103 }
1104 break;
1105
1106 case WINED3DSPR_CONST:
1107 if (!pshader && reg->idx[0].rel_addr)
1108 {
1109 const struct arb_vshader_private *shader_data = shader->backend_data;
1110 UINT rel_offset = ctx->target_version == ARB ? shader_data->rel_offset : 0;
1111 BOOL aL = FALSE;
1112 char rel_reg[50];
1113 if (reg_maps->shader_version.major < 2)
1114 {
1115 sprintf(rel_reg, "A0.x");
1116 }
1117 else
1118 {
1119 shader_arb_get_src_param(ins, reg->idx[0].rel_addr, 0, rel_reg);
1120 if (ctx->target_version == ARB)
1121 {
1122 if (!strcmp(rel_reg, "**aL_emul**"))
1123 {
1124 aL = TRUE;
1125 } else {
1127 sprintf(rel_reg, "A0.x");
1128 }
1129 }
1130 }
1131 if (aL)
1132 sprintf(register_name, "C[%u]", ctx->aL + reg->idx[0].offset);
1133 else if (reg->idx[0].offset >= rel_offset)
1134 sprintf(register_name, "C[%s + %u]", rel_reg, reg->idx[0].offset - rel_offset);
1135 else
1136 sprintf(register_name, "C[%s - %u]", rel_reg, rel_offset - reg->idx[0].offset);
1137 }
1138 else
1139 {
1140 if (reg_maps->usesrelconstF)
1141 sprintf(register_name, "C[%u]", reg->idx[0].offset);
1142 else
1143 sprintf(register_name, "C%u", reg->idx[0].offset);
1144 }
1145 break;
1146
1147 case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
1148 if (pshader)
1149 {
1150 if (reg_maps->shader_version.major == 1
1151 && reg_maps->shader_version.minor <= 3)
1152 /* In ps <= 1.3, Tx is a temporary register as destination
1153 * to all instructions, and as source to most instructions.
1154 * For some instructions it is the texcoord input. Those
1155 * instructions know about the special use. */
1156 sprintf(register_name, "T%u", reg->idx[0].offset);
1157 else
1158 /* In ps 1.4 and 2.x Tx is always a (read-only) varying. */
1159 sprintf(register_name, "fragment.texcoord[%u]", reg->idx[0].offset);
1160 }
1161 else
1162 {
1163 if (reg_maps->shader_version.major == 1 || ctx->target_version >= NV2)
1164 sprintf(register_name, "A%u", reg->idx[0].offset);
1165 else
1166 sprintf(register_name, "A%u_SHADOW", reg->idx[0].offset);
1167 }
1168 break;
1169
1171 if (ctx->ps_post_process && !reg->idx[0].offset)
1172 {
1173 strcpy(register_name, "TMP_COLOR");
1174 }
1175 else
1176 {
1177 if (ctx->cur_ps_args->super.srgb_correction)
1178 FIXME("sRGB correction on higher render targets.\n");
1179 if (reg_maps->rt_mask > 1)
1180 sprintf(register_name, "result.color[%u]", reg->idx[0].offset);
1181 else
1182 strcpy(register_name, "result.color");
1183 }
1184 break;
1185
1186 case WINED3DSPR_RASTOUT:
1187 if (reg->idx[0].offset == 1)
1188 sprintf(register_name, "%s", ctx->fog_output);
1189 else
1190 sprintf(register_name, "%s", rastout_reg_names[reg->idx[0].offset]);
1191 break;
1192
1194 strcpy(register_name, "result.depth");
1195 break;
1196
1197 case WINED3DSPR_ATTROUT:
1198 /* case WINED3DSPR_OUTPUT: */
1199 if (pshader)
1200 sprintf(register_name, "oD[%u]", reg->idx[0].offset);
1201 else
1202 strcpy(register_name, ctx->color_output[reg->idx[0].offset]);
1203 break;
1204
1206 if (pshader)
1207 sprintf(register_name, "oT[%u]", reg->idx[0].offset);
1208 else if (reg_maps->shader_version.major < 3)
1209 strcpy(register_name, ctx->texcrd_output[reg->idx[0].offset]);
1210 else
1211 strcpy(register_name, ctx->vs_output[reg->idx[0].offset]);
1212 break;
1213
1214 case WINED3DSPR_LOOP:
1215 if(ctx->target_version >= NV2)
1216 {
1217 /* Pshader has an implicitly declared loop index counter A0.x that cannot be renamed */
1218 if(pshader) sprintf(register_name, "A0.x");
1219 else sprintf(register_name, "aL.y");
1220 }
1221 else
1222 {
1223 /* Unfortunately this code cannot return the value of ctx->aL here. An immediate value
1224 * would be valid, but if aL is used for indexing(its only use), there's likely an offset,
1225 * thus the result would be something like C[15 + 30], which is not valid in the ARB program
1226 * grammar. So return a marker for the emulated aL and intercept it in constant and varying
1227 * indexing
1228 */
1229 sprintf(register_name, "**aL_emul**");
1230 }
1231
1232 break;
1233
1235 sprintf(register_name, "I%u", reg->idx[0].offset);
1236 break;
1237
1239 if (!reg->idx[0].offset)
1240 sprintf(register_name, "vpos");
1241 else if (reg->idx[0].offset == 1)
1242 sprintf(register_name, "fragment.facing.x");
1243 else
1244 FIXME("Unknown MISCTYPE register index %u.\n", reg->idx[0].offset);
1245 break;
1246
1247 default:
1248 FIXME("Unhandled register type %#x[%u].\n", reg->type, reg->idx[0].offset);
1249 sprintf(register_name, "unrecognized_register[%u]", reg->idx[0].offset);
1250 break;
1251 }
1252}
1253
1255 const struct wined3d_shader_dst_param *wined3d_dst, char *str)
1256{
1257 char register_name[255];
1258 char write_mask[6];
1259 BOOL is_color;
1260
1261 shader_arb_get_register_name(ins, &wined3d_dst->reg, register_name, &is_color);
1262 strcpy(str, register_name);
1263
1264 shader_arb_get_write_mask(ins, wined3d_dst, write_mask);
1265 strcat(str, write_mask);
1266}
1267
1268static const char *shader_arb_get_fixup_swizzle(enum fixup_channel_source channel_source)
1269{
1270 switch(channel_source)
1271 {
1272 case CHANNEL_SOURCE_ZERO: return "0";
1273 case CHANNEL_SOURCE_ONE: return "1";
1274 case CHANNEL_SOURCE_X: return "x";
1275 case CHANNEL_SOURCE_Y: return "y";
1276 case CHANNEL_SOURCE_Z: return "z";
1277 case CHANNEL_SOURCE_W: return "w";
1278 default:
1279 FIXME("Unhandled channel source %#x\n", channel_source);
1280 return "undefined";
1281 }
1282}
1283
1285{
1288};
1289
1291{
1292 struct color_fixup_masks masks = {0, 0};
1293
1294 if (is_complex_fixup(fixup))
1295 {
1297 FIXME("Complex fixup (%#x) not supported\n", complex_fixup);
1298 return masks;
1299 }
1300
1301 if (fixup.x_source != CHANNEL_SOURCE_X)
1302 masks.source |= WINED3DSP_WRITEMASK_0;
1303 if (fixup.y_source != CHANNEL_SOURCE_Y)
1304 masks.source |= WINED3DSP_WRITEMASK_1;
1305 if (fixup.z_source != CHANNEL_SOURCE_Z)
1306 masks.source |= WINED3DSP_WRITEMASK_2;
1307 if (fixup.w_source != CHANNEL_SOURCE_W)
1308 masks.source |= WINED3DSP_WRITEMASK_3;
1309 masks.source &= dst_mask;
1310
1311 if (fixup.x_sign_fixup)
1313 if (fixup.y_sign_fixup)
1315 if (fixup.z_sign_fixup)
1317 if (fixup.w_sign_fixup)
1319 masks.sign &= dst_mask;
1320
1321 return masks;
1322}
1323
1324static void gen_color_correction(struct wined3d_string_buffer *buffer, const char *dst,
1325 const char *src, const char *one, const char *two,
1326 struct color_fixup_desc fixup, struct color_fixup_masks masks)
1327{
1328 const char *sign_fixup_src = dst;
1329
1330 if (masks.source)
1331 {
1332 if (masks.sign)
1333 sign_fixup_src = "TA";
1334
1335 shader_addline(buffer, "SWZ %s, %s, %s, %s, %s, %s;\n", sign_fixup_src, src,
1338 }
1339 else if (masks.sign)
1340 {
1341 sign_fixup_src = src;
1342 }
1343
1344 if (masks.sign)
1345 {
1346 char reg_mask[6];
1347 char *ptr = reg_mask;
1348
1349 if (masks.sign != WINED3DSP_WRITEMASK_ALL)
1350 {
1351 *ptr++ = '.';
1352 if (masks.sign & WINED3DSP_WRITEMASK_0)
1353 *ptr++ = 'x';
1354 if (masks.sign & WINED3DSP_WRITEMASK_1)
1355 *ptr++ = 'y';
1356 if (masks.sign & WINED3DSP_WRITEMASK_2)
1357 *ptr++ = 'z';
1358 if (masks.sign & WINED3DSP_WRITEMASK_3)
1359 *ptr++ = 'w';
1360 }
1361 *ptr = '\0';
1362
1363 shader_addline(buffer, "MAD %s%s, %s, %s, -%s;\n", dst, reg_mask, sign_fixup_src, two, one);
1364 }
1365}
1366
1367static const char *shader_arb_get_modifier(const struct wined3d_shader_instruction *ins)
1368{
1369 DWORD mod;
1370 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
1371 if (!ins->dst_count) return "";
1372
1373 mod = ins->dst[0].modifiers;
1374
1375 /* Silently ignore PARTIALPRECISION if it's not supported */
1376 if(priv->target_version == ARB) mod &= ~WINED3DSPDM_PARTIALPRECISION;
1377
1379 {
1380 FIXME("Unhandled modifier WINED3DSPDM_MSAMPCENTROID\n");
1381 mod &= ~WINED3DSPDM_MSAMPCENTROID;
1382 }
1383
1384 switch(mod)
1385 {
1387 return "H_SAT";
1388
1390 return "_SAT";
1391
1393 return "H";
1394
1395 case 0:
1396 return "";
1397
1398 default:
1399 FIXME("Unknown modifiers 0x%08x\n", mod);
1400 return "";
1401 }
1402}
1403
1404#define TEX_PROJ 0x1
1405#define TEX_BIAS 0x2
1406#define TEX_LOD 0x4
1407#define TEX_DERIV 0x10
1408
1409static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD sampler_idx,
1410 const char *dst_str, const char *coord_reg, WORD flags, const char *dsx, const char *dsy)
1411{
1412 enum wined3d_shader_resource_type resource_type = ins->ctx->reg_maps->resource_info[sampler_idx].type;
1413 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1414 const char *tex_type;
1415 BOOL np2_fixup = FALSE;
1416 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
1417 const char *mod;
1418 BOOL pshader = shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type);
1419 const struct wined3d_shader *shader;
1420 const struct wined3d_device *device;
1421 const struct wined3d_gl_info *gl_info;
1422 const char *tex_dst = dst_str;
1423 struct color_fixup_masks masks;
1424
1425 /* D3D vertex shader sampler IDs are vertex samplers(0-3), not global d3d samplers */
1426 if(!pshader) sampler_idx += MAX_FRAGMENT_SAMPLERS;
1427
1428 switch (resource_type)
1429 {
1431 tex_type = "1D";
1432 break;
1433
1435 shader = ins->ctx->shader;
1436 device = shader->device;
1437 gl_info = &device->adapter->gl_info;
1438
1439 if (pshader && priv->cur_ps_args->super.np2_fixup & (1u << sampler_idx)
1440 && gl_info->supported[ARB_TEXTURE_RECTANGLE])
1441 tex_type = "RECT";
1442 else
1443 tex_type = "2D";
1444 if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
1445 {
1446 if (priv->cur_np2fixup_info->super.active & (1u << sampler_idx))
1447 {
1448 if (flags) FIXME("Only ordinary sampling from NP2 textures is supported.\n");
1449 else np2_fixup = TRUE;
1450 }
1451 }
1452 break;
1453
1455 tex_type = "3D";
1456 break;
1457
1459 tex_type = "CUBE";
1460 break;
1461
1462 default:
1463 ERR("Unexpected resource type %#x.\n", resource_type);
1464 tex_type = "";
1465 }
1466
1467 /* TEX, TXL, TXD and TXP do not support the "H" modifier,
1468 * so don't use shader_arb_get_modifier
1469 */
1470 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE) mod = "_SAT";
1471 else mod = "";
1472
1473 /* Fragment samplers always have indentity mapping */
1474 if(sampler_idx >= MAX_FRAGMENT_SAMPLERS)
1475 {
1476 sampler_idx = priv->cur_vs_args->vertex.samplers[sampler_idx - MAX_FRAGMENT_SAMPLERS];
1477 }
1478
1479 if (pshader)
1480 {
1481 masks = calc_color_correction(priv->cur_ps_args->super.color_fixup[sampler_idx],
1482 ins->dst[0].write_mask);
1483
1484 if (masks.source || masks.sign)
1485 tex_dst = "TA";
1486 }
1487
1488 if (flags & TEX_DERIV)
1489 {
1490 if(flags & TEX_PROJ) FIXME("Projected texture sampling with custom derivatives\n");
1491 if(flags & TEX_BIAS) FIXME("Biased texture sampling with custom derivatives\n");
1492 shader_addline(buffer, "TXD%s %s, %s, %s, %s, texture[%u], %s;\n", mod, tex_dst, coord_reg,
1493 dsx, dsy, sampler_idx, tex_type);
1494 }
1495 else if(flags & TEX_LOD)
1496 {
1497 if(flags & TEX_PROJ) FIXME("Projected texture sampling with explicit lod\n");
1498 if(flags & TEX_BIAS) FIXME("Biased texture sampling with explicit lod\n");
1499 shader_addline(buffer, "TXL%s %s, %s, texture[%u], %s;\n", mod, tex_dst, coord_reg,
1500 sampler_idx, tex_type);
1501 }
1502 else if (flags & TEX_BIAS)
1503 {
1504 /* Shouldn't be possible, but let's check for it */
1505 if(flags & TEX_PROJ) FIXME("Biased and Projected texture sampling\n");
1506 /* TXB takes the 4th component of the source vector automatically, as d3d. Nothing more to do */
1507 shader_addline(buffer, "TXB%s %s, %s, texture[%u], %s;\n", mod, tex_dst, coord_reg, sampler_idx, tex_type);
1508 }
1509 else if (flags & TEX_PROJ)
1510 {
1511 shader_addline(buffer, "TXP%s %s, %s, texture[%u], %s;\n", mod, tex_dst, coord_reg, sampler_idx, tex_type);
1512 }
1513 else
1514 {
1515 if (np2_fixup)
1516 {
1517 const unsigned char idx = priv->cur_np2fixup_info->super.idx[sampler_idx];
1518 shader_addline(buffer, "MUL TA, np2fixup[%u].%s, %s;\n", idx >> 1,
1519 (idx % 2) ? "zwxy" : "xyzw", coord_reg);
1520
1521 shader_addline(buffer, "TEX%s %s, TA, texture[%u], %s;\n", mod, tex_dst, sampler_idx, tex_type);
1522 }
1523 else
1524 shader_addline(buffer, "TEX%s %s, %s, texture[%u], %s;\n", mod, tex_dst, coord_reg, sampler_idx, tex_type);
1525 }
1526
1527 if (pshader)
1528 {
1529 gen_color_correction(buffer, dst_str, tex_dst,
1532 priv->cur_ps_args->super.color_fixup[sampler_idx], masks);
1533 }
1534}
1535
1537 const struct wined3d_shader_src_param *src, unsigned int tmpreg, char *outregstr)
1538{
1539 /* Generate a line that does the input modifier computation and return the input register to use */
1540 BOOL is_color = FALSE, insert_line;
1541 char regstr[256];
1542 char swzstr[20];
1543 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1544 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1545 const char *one = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ONE);
1546 const char *two = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_TWO);
1547
1548 /* Assume a new line will be added */
1549 insert_line = TRUE;
1550
1551 /* Get register name */
1552 shader_arb_get_register_name(ins, &src->reg, regstr, &is_color);
1553 shader_arb_get_swizzle(src, is_color, swzstr);
1554
1555 switch (src->modifiers)
1556 {
1557 case WINED3DSPSM_NONE:
1558 sprintf(outregstr, "%s%s", regstr, swzstr);
1559 insert_line = FALSE;
1560 break;
1561 case WINED3DSPSM_NEG:
1562 sprintf(outregstr, "-%s%s", regstr, swzstr);
1563 insert_line = FALSE;
1564 break;
1565 case WINED3DSPSM_BIAS:
1566 shader_addline(buffer, "ADD T%c, %s, -coefdiv.x;\n", 'A' + tmpreg, regstr);
1567 break;
1569 shader_addline(buffer, "ADD T%c, -%s, coefdiv.x;\n", 'A' + tmpreg, regstr);
1570 break;
1571 case WINED3DSPSM_SIGN:
1572 shader_addline(buffer, "MAD T%c, %s, %s, -%s;\n", 'A' + tmpreg, regstr, two, one);
1573 break;
1575 shader_addline(buffer, "MAD T%c, %s, -%s, %s;\n", 'A' + tmpreg, regstr, two, one);
1576 break;
1577 case WINED3DSPSM_COMP:
1578 shader_addline(buffer, "SUB T%c, %s, %s;\n", 'A' + tmpreg, one, regstr);
1579 break;
1580 case WINED3DSPSM_X2:
1581 shader_addline(buffer, "ADD T%c, %s, %s;\n", 'A' + tmpreg, regstr, regstr);
1582 break;
1583 case WINED3DSPSM_X2NEG:
1584 shader_addline(buffer, "ADD T%c, -%s, -%s;\n", 'A' + tmpreg, regstr, regstr);
1585 break;
1586 case WINED3DSPSM_DZ:
1587 shader_addline(buffer, "RCP T%c, %s.z;\n", 'A' + tmpreg, regstr);
1588 shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
1589 break;
1590 case WINED3DSPSM_DW:
1591 shader_addline(buffer, "RCP T%c, %s.w;\n", 'A' + tmpreg, regstr);
1592 shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
1593 break;
1594 case WINED3DSPSM_ABS:
1595 if(ctx->target_version >= NV2) {
1596 sprintf(outregstr, "|%s%s|", regstr, swzstr);
1597 insert_line = FALSE;
1598 } else {
1599 shader_addline(buffer, "ABS T%c, %s;\n", 'A' + tmpreg, regstr);
1600 }
1601 break;
1602 case WINED3DSPSM_ABSNEG:
1603 if(ctx->target_version >= NV2) {
1604 sprintf(outregstr, "-|%s%s|", regstr, swzstr);
1605 } else {
1606 shader_addline(buffer, "ABS T%c, %s;\n", 'A' + tmpreg, regstr);
1607 sprintf(outregstr, "-T%c%s", 'A' + tmpreg, swzstr);
1608 }
1609 insert_line = FALSE;
1610 break;
1611 default:
1612 sprintf(outregstr, "%s%s", regstr, swzstr);
1613 insert_line = FALSE;
1614 }
1615
1616 /* Return modified or original register, with swizzle */
1617 if (insert_line)
1618 sprintf(outregstr, "T%c%s", 'A' + tmpreg, swzstr);
1619}
1620
1621static void pshader_hw_bem(const struct wined3d_shader_instruction *ins)
1622{
1623 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1624 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1625 DWORD sampler_code = dst->reg.idx[0].offset;
1626 char dst_name[50];
1627 char src_name[2][50];
1628
1629 shader_arb_get_dst_param(ins, dst, dst_name);
1630
1631 /* Sampling the perturbation map in Tsrc was done already, including the signedness correction if needed
1632 *
1633 * Keep in mind that src_name[1] can be "TB" and src_name[0] can be "TA" because modifiers like _x2 are valid
1634 * with bem. So delay loading the first parameter until after the perturbation calculation which needs two
1635 * temps is done.
1636 */
1637 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1638 shader_addline(buffer, "SWZ TA, bumpenvmat%d, x, z, 0, 0;\n", sampler_code);
1639 shader_addline(buffer, "DP3 TC.r, TA, %s;\n", src_name[1]);
1640 shader_addline(buffer, "SWZ TA, bumpenvmat%d, y, w, 0, 0;\n", sampler_code);
1641 shader_addline(buffer, "DP3 TC.g, TA, %s;\n", src_name[1]);
1642
1643 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1644 shader_addline(buffer, "ADD %s, %s, TC;\n", dst_name, src_name[0]);
1645}
1646
1647static DWORD negate_modifiers(DWORD mod, char *extra_char)
1648{
1649 *extra_char = ' ';
1650 switch(mod)
1651 {
1652 case WINED3DSPSM_NONE: return WINED3DSPSM_NEG;
1653 case WINED3DSPSM_NEG: return WINED3DSPSM_NONE;
1658 case WINED3DSPSM_COMP: *extra_char = '-'; return WINED3DSPSM_COMP;
1659 case WINED3DSPSM_X2: return WINED3DSPSM_X2NEG;
1660 case WINED3DSPSM_X2NEG: return WINED3DSPSM_X2;
1661 case WINED3DSPSM_DZ: *extra_char = '-'; return WINED3DSPSM_DZ;
1662 case WINED3DSPSM_DW: *extra_char = '-'; return WINED3DSPSM_DW;
1665 }
1666 FIXME("Unknown modifier %u\n", mod);
1667 return mod;
1668}
1669
1670static void pshader_hw_cnd(const struct wined3d_shader_instruction *ins)
1671{
1672 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1673 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1674 char dst_name[50];
1675 char src_name[3][50];
1676 DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1677 ins->ctx->reg_maps->shader_version.minor);
1678
1679 shader_arb_get_dst_param(ins, dst, dst_name);
1680 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1681
1682 if (shader_version <= WINED3D_SHADER_VERSION(1, 3) && ins->coissue
1683 && ins->dst->write_mask != WINED3DSP_WRITEMASK_3)
1684 {
1685 shader_addline(buffer, "MOV%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name[1]);
1686 }
1687 else
1688 {
1689 struct wined3d_shader_src_param src0_copy = ins->src[0];
1690 char extra_neg;
1691
1692 /* src0 may have a negate srcmod set, so we can't blindly add "-" to the name */
1693 src0_copy.modifiers = negate_modifiers(src0_copy.modifiers, &extra_neg);
1694
1695 shader_arb_get_src_param(ins, &src0_copy, 0, src_name[0]);
1696 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1697 shader_addline(buffer, "ADD TA, %c%s, coefdiv.x;\n", extra_neg, src_name[0]);
1698 shader_addline(buffer, "CMP%s %s, TA, %s, %s;\n", shader_arb_get_modifier(ins),
1699 dst_name, src_name[1], src_name[2]);
1700 }
1701}
1702
1703static void pshader_hw_cmp(const struct wined3d_shader_instruction *ins)
1704{
1705 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1706 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1707 char dst_name[50];
1708 char src_name[3][50];
1709
1710 shader_arb_get_dst_param(ins, dst, dst_name);
1711
1712 /* Generate input register names (with modifiers) */
1713 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1714 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1715 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1716
1717 shader_addline(buffer, "CMP%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins),
1718 dst_name, src_name[0], src_name[2], src_name[1]);
1719}
1720
1723static void pshader_hw_dp2add(const struct wined3d_shader_instruction *ins)
1724{
1725 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1726 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1727 char dst_name[50];
1728 char src_name[3][50];
1729 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1730
1731 shader_arb_get_dst_param(ins, dst, dst_name);
1732 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
1733 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
1734
1735 if(ctx->target_version >= NV3)
1736 {
1737 /* GL_NV_fragment_program2 has a 1:1 matching instruction */
1738 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1739 shader_addline(buffer, "DP2A%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins),
1740 dst_name, src_name[0], src_name[1], src_name[2]);
1741 }
1742 else if(ctx->target_version >= NV2)
1743 {
1744 /* dst.x = src2.?, src0.x, src1.x + src0.y * src1.y
1745 * dst.y = src2.?, src0.x, src1.z + src0.y * src1.w
1746 * dst.z = src2.?, src0.x, src1.x + src0.y * src1.y
1747 * dst.z = src2.?, src0.x, src1.z + src0.y * src1.w
1748 *
1749 * Make sure that src1.zw = src1.xy, then we get a classic dp2add
1750 *
1751 * .xyxy and other swizzles that we could get with this are not valid in
1752 * plain ARBfp, but luckily the NV extension grammar lifts this limitation.
1753 */
1754 struct wined3d_shader_src_param tmp_param = ins->src[1];
1755 DWORD swizzle = tmp_param.swizzle & 0xf; /* Selects .xy */
1756 tmp_param.swizzle = swizzle | (swizzle << 4); /* Creates .xyxy */
1757
1758 shader_arb_get_src_param(ins, &tmp_param, 1, src_name[1]);
1759
1760 shader_addline(buffer, "X2D%s %s, %s, %s, %s;\n", shader_arb_get_modifier(ins),
1761 dst_name, src_name[2], src_name[0], src_name[1]);
1762 }
1763 else
1764 {
1765 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
1766 /* Emulate a DP2 with a DP3 and 0.0. Don't use the dest as temp register, it could be src[1] or src[2]
1767 * src_name[0] can be TA, but TA is a private temp for modifiers, so it is save to overwrite
1768 */
1769 shader_addline(buffer, "MOV TA, %s;\n", src_name[0]);
1770 shader_addline(buffer, "MOV TA.z, 0.0;\n");
1771 shader_addline(buffer, "DP3 TA, TA, %s;\n", src_name[1]);
1772 shader_addline(buffer, "ADD%s %s, TA, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name[2]);
1773 }
1774}
1775
1776/* Map the opcode 1-to-1 to the GL code */
1777static void shader_hw_map2gl(const struct wined3d_shader_instruction *ins)
1778{
1779 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1780 const char *instruction;
1781 char arguments[256], dst_str[50];
1782 unsigned int i;
1783 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1784
1785 switch (ins->handler_idx)
1786 {
1787 case WINED3DSIH_ABS: instruction = "ABS"; break;
1788 case WINED3DSIH_ADD: instruction = "ADD"; break;
1789 case WINED3DSIH_CRS: instruction = "XPD"; break;
1790 case WINED3DSIH_DP3: instruction = "DP3"; break;
1791 case WINED3DSIH_DP4: instruction = "DP4"; break;
1792 case WINED3DSIH_DST: instruction = "DST"; break;
1793 case WINED3DSIH_FRC: instruction = "FRC"; break;
1794 case WINED3DSIH_LIT: instruction = "LIT"; break;
1795 case WINED3DSIH_LRP: instruction = "LRP"; break;
1796 case WINED3DSIH_MAD: instruction = "MAD"; break;
1797 case WINED3DSIH_MAX: instruction = "MAX"; break;
1798 case WINED3DSIH_MIN: instruction = "MIN"; break;
1799 case WINED3DSIH_MOV: instruction = "MOV"; break;
1800 case WINED3DSIH_MUL: instruction = "MUL"; break;
1801 case WINED3DSIH_SGE: instruction = "SGE"; break;
1802 case WINED3DSIH_SLT: instruction = "SLT"; break;
1803 case WINED3DSIH_SUB: instruction = "SUB"; break;
1804 case WINED3DSIH_MOVA:instruction = "ARR"; break;
1805 case WINED3DSIH_DSX: instruction = "DDX"; break;
1806 default: instruction = "";
1807 FIXME("Unhandled opcode %s.\n", debug_d3dshaderinstructionhandler(ins->handler_idx));
1808 break;
1809 }
1810
1811 /* Note that shader_arb_add_dst_param() adds spaces. */
1812 arguments[0] = '\0';
1813 shader_arb_get_dst_param(ins, dst, dst_str);
1814 for (i = 0; i < ins->src_count; ++i)
1815 {
1816 char operand[100];
1817 strcat(arguments, ", ");
1818 shader_arb_get_src_param(ins, &ins->src[i], i, operand);
1819 strcat(arguments, operand);
1820 }
1821 shader_addline(buffer, "%s%s %s%s;\n", instruction, shader_arb_get_modifier(ins), dst_str, arguments);
1822}
1823
1824static void shader_hw_nop(const struct wined3d_shader_instruction *ins) {}
1825
1827{
1828 return ((swizzle >> 2 * component) & 0x3) * 0x55;
1829}
1830
1831static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
1832{
1833 const struct wined3d_shader *shader = ins->ctx->shader;
1834 const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
1835 BOOL pshader = shader_is_pshader_version(reg_maps->shader_version.type);
1836 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
1837 const char *zero = arb_get_helper_value(reg_maps->shader_version.type, ARB_ZERO);
1838 const char *one = arb_get_helper_value(reg_maps->shader_version.type, ARB_ONE);
1839 const char *two = arb_get_helper_value(reg_maps->shader_version.type, ARB_TWO);
1840
1841 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1842 char src0_param[256];
1843
1844 if (ins->handler_idx == WINED3DSIH_MOVA)
1845 {
1846 const struct arb_vshader_private *shader_data = shader->backend_data;
1847 char write_mask[6];
1849
1850 if(ctx->target_version >= NV2) {
1851 shader_hw_map2gl(ins);
1852 return;
1853 }
1854 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_param);
1855 shader_arb_get_write_mask(ins, &ins->dst[0], write_mask);
1856
1857 /* This implements the mova formula used in GLSL. The first two instructions
1858 * prepare the sign() part. Note that it is fine to have my_sign(0.0) = 1.0
1859 * in this case:
1860 * mova A0.x, 0.0
1861 *
1862 * A0.x = arl(floor(abs(0.0) + 0.5) * 1.0) = floor(0.5) = 0.0 since arl does a floor
1863 *
1864 * The ARL is performed when A0 is used - the requested component is read from A0_SHADOW into
1865 * A0.x. We can use the overwritten component of A0_shadow as temporary storage for the sign.
1866 */
1867 shader_addline(buffer, "SGE A0_SHADOW%s, %s, %s;\n", write_mask, src0_param, zero);
1868 shader_addline(buffer, "MAD A0_SHADOW%s, A0_SHADOW, %s, -%s;\n", write_mask, two, one);
1869
1870 shader_addline(buffer, "ABS TA%s, %s;\n", write_mask, src0_param);
1871 shader_addline(buffer, "ADD TA%s, TA, rel_addr_const.x;\n", write_mask);
1872 shader_addline(buffer, "FLR TA%s, TA;\n", write_mask);
1873 if (shader_data->rel_offset)
1874 {
1875 shader_addline(buffer, "ADD TA%s, TA, %s;\n", write_mask, offset);
1876 }
1877 shader_addline(buffer, "MUL A0_SHADOW%s, TA, A0_SHADOW;\n", write_mask);
1878
1879 ((struct shader_arb_ctx_priv *)ins->ctx->backend_data)->addr_reg[0] = '\0';
1880 }
1881 else if (reg_maps->shader_version.major == 1
1882 && !shader_is_pshader_version(reg_maps->shader_version.type)
1883 && ins->dst[0].reg.type == WINED3DSPR_ADDR)
1884 {
1885 const struct arb_vshader_private *shader_data = shader->backend_data;
1886 src0_param[0] = '\0';
1887
1888 if (shader_data->rel_offset && ctx->target_version == ARB)
1889 {
1891 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_param);
1892 shader_addline(buffer, "ADD TA.x, %s, %s;\n", src0_param, offset);
1893 shader_addline(buffer, "ARL A0.x, TA.x;\n");
1894 }
1895 else
1896 {
1897 /* Apple's ARB_vertex_program implementation does not accept an ARL source argument
1898 * with more than one component. Thus replicate the first source argument over all
1899 * 4 components. For example, .xyzw -> .x (or better: .xxxx), .zwxy -> .z, etc) */
1900 struct wined3d_shader_src_param tmp_src = ins->src[0];
1901 tmp_src.swizzle = shader_arb_select_component(tmp_src.swizzle, 0);
1902 shader_arb_get_src_param(ins, &tmp_src, 0, src0_param);
1903 shader_addline(buffer, "ARL A0.x, %s;\n", src0_param);
1904 }
1905 }
1906 else if (ins->dst[0].reg.type == WINED3DSPR_COLOROUT && !ins->dst[0].reg.idx[0].offset && pshader)
1907 {
1908 if (ctx->ps_post_process && shader->u.ps.color0_mov)
1909 {
1910 shader_addline(buffer, "#mov handled in srgb write or fog code\n");
1911 return;
1912 }
1913 shader_hw_map2gl(ins);
1914 }
1915 else
1916 {
1917 shader_hw_map2gl(ins);
1918 }
1919}
1920
1922{
1923 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1924 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
1925 char reg_dest[40];
1926
1927 /* No swizzles are allowed in d3d's texkill. PS 1.x ignores the 4th component as documented,
1928 * but >= 2.0 honors it (undocumented, but tested by the d3d9 testsuite)
1929 */
1930 shader_arb_get_dst_param(ins, dst, reg_dest);
1931
1932 if (ins->ctx->reg_maps->shader_version.major >= 2)
1933 {
1934 const char *kilsrc = "TA";
1935 BOOL is_color;
1936
1937 shader_arb_get_register_name(ins, &dst->reg, reg_dest, &is_color);
1938 if(dst->write_mask == WINED3DSP_WRITEMASK_ALL)
1939 {
1940 kilsrc = reg_dest;
1941 }
1942 else
1943 {
1944 /* Sigh. KIL doesn't support swizzles/writemasks. KIL passes a writemask, but ".xy" for example
1945 * is not valid as a swizzle in ARB (needs ".xyyy"). Use SWZ to load the register properly, and set
1946 * masked out components to 0(won't kill)
1947 */
1948 char x = '0', y = '0', z = '0', w = '0';
1949 if(dst->write_mask & WINED3DSP_WRITEMASK_0) x = 'x';
1950 if(dst->write_mask & WINED3DSP_WRITEMASK_1) y = 'y';
1951 if(dst->write_mask & WINED3DSP_WRITEMASK_2) z = 'z';
1952 if(dst->write_mask & WINED3DSP_WRITEMASK_3) w = 'w';
1953 shader_addline(buffer, "SWZ TA, %s, %c, %c, %c, %c;\n", reg_dest, x, y, z, w);
1954 }
1955 shader_addline(buffer, "KIL %s;\n", kilsrc);
1956 }
1957 else
1958 {
1959 /* ARB fp doesn't like swizzles on the parameter of the KIL instruction. To mask the 4th component,
1960 * copy the register into our general purpose TMP variable, overwrite .w and pass TMP to KIL
1961 *
1962 * ps_1_3 shaders use the texcoord incarnation of the Tx register. ps_1_4 shaders can use the same,
1963 * or pass in any temporary register(in shader phase 2)
1964 */
1965 if (ins->ctx->reg_maps->shader_version.minor <= 3)
1966 sprintf(reg_dest, "fragment.texcoord[%u]", dst->reg.idx[0].offset);
1967 else
1968 shader_arb_get_dst_param(ins, dst, reg_dest);
1969 shader_addline(buffer, "SWZ TA, %s, x, y, z, 1;\n", reg_dest);
1970 shader_addline(buffer, "KIL TA;\n");
1971 }
1972}
1973
1974static void pshader_hw_tex(const struct wined3d_shader_instruction *ins)
1975{
1976 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
1977 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
1978 DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
1979 ins->ctx->reg_maps->shader_version.minor);
1981
1982 char reg_dest[40];
1983 char reg_coord[40];
1984 DWORD reg_sampler_code;
1985 WORD myflags = 0;
1986 BOOL swizzle_coord = FALSE;
1987
1988 /* All versions have a destination register */
1989 shader_arb_get_dst_param(ins, dst, reg_dest);
1990
1991 /* 1.0-1.4: Use destination register number as texture code.
1992 2.0+: Use provided sampler number as texture code. */
1993 if (shader_version < WINED3D_SHADER_VERSION(2,0))
1994 reg_sampler_code = dst->reg.idx[0].offset;
1995 else
1996 reg_sampler_code = ins->src[1].reg.idx[0].offset;
1997
1998 /* 1.0-1.3: Use the texcoord varying.
1999 1.4+: Use provided coordinate source register. */
2000 if (shader_version < WINED3D_SHADER_VERSION(1,4))
2001 sprintf(reg_coord, "fragment.texcoord[%u]", reg_sampler_code);
2002 else {
2003 /* TEX is the only instruction that can handle DW and DZ natively */
2004 src = ins->src[0];
2005 if(src.modifiers == WINED3DSPSM_DW) src.modifiers = WINED3DSPSM_NONE;
2006 if(src.modifiers == WINED3DSPSM_DZ) src.modifiers = WINED3DSPSM_NONE;
2007 shader_arb_get_src_param(ins, &src, 0, reg_coord);
2008 }
2009
2010 /* projection flag:
2011 * 1.1, 1.2, 1.3: Use WINED3D_TSS_TEXTURETRANSFORMFLAGS
2012 * 1.4: Use WINED3DSPSM_DZ or WINED3DSPSM_DW on src[0]
2013 * 2.0+: Use WINED3DSI_TEXLD_PROJECT on the opcode
2014 */
2015 if (shader_version < WINED3D_SHADER_VERSION(1,4))
2016 {
2017 DWORD flags = 0;
2018 if (reg_sampler_code < MAX_TEXTURES)
2019 flags = priv->cur_ps_args->super.tex_transform >> reg_sampler_code * WINED3D_PSARGS_TEXTRANSFORM_SHIFT;
2021 {
2022 myflags |= TEX_PROJ;
2024 swizzle_coord = TRUE;
2025 }
2026 }
2027 else if (shader_version < WINED3D_SHADER_VERSION(2,0))
2028 {
2029 enum wined3d_shader_src_modifier src_mod = ins->src[0].modifiers;
2030 if (src_mod == WINED3DSPSM_DZ)
2031 {
2032 swizzle_coord = TRUE;
2033 myflags |= TEX_PROJ;
2034 } else if(src_mod == WINED3DSPSM_DW) {
2035 myflags |= TEX_PROJ;
2036 }
2037 } else {
2038 if (ins->flags & WINED3DSI_TEXLD_PROJECT) myflags |= TEX_PROJ;
2039 if (ins->flags & WINED3DSI_TEXLD_BIAS) myflags |= TEX_BIAS;
2040 }
2041
2042 if (swizzle_coord)
2043 {
2044 /* TXP cannot handle DZ natively, so move the z coordinate to .w.
2045 * reg_coord is a read-only varying register, so we need a temp reg */
2046 shader_addline(ins->ctx->buffer, "SWZ TA, %s, x, y, z, z;\n", reg_coord);
2047 strcpy(reg_coord, "TA");
2048 }
2049
2050 shader_hw_sample(ins, reg_sampler_code, reg_dest, reg_coord, myflags, NULL, NULL);
2051}
2052
2054{
2055 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2056 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2057 DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
2058 ins->ctx->reg_maps->shader_version.minor);
2059 char dst_str[50];
2060
2061 if (shader_version < WINED3D_SHADER_VERSION(1,4))
2062 {
2063 DWORD reg = dst->reg.idx[0].offset;
2064
2065 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2066 shader_addline(buffer, "MOV_SAT %s, fragment.texcoord[%u];\n", dst_str, reg);
2067 } else {
2068 char reg_src[40];
2069
2070 shader_arb_get_src_param(ins, &ins->src[0], 0, reg_src);
2071 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2072 shader_addline(buffer, "MOV %s, %s;\n", dst_str, reg_src);
2073 }
2074}
2075
2077{
2078 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2079 DWORD flags = 0;
2080
2081 DWORD reg1 = ins->dst[0].reg.idx[0].offset;
2082 char dst_str[50];
2083 char src_str[50];
2084
2085 /* Note that texreg2ar treats Tx as a temporary register, not as a varying */
2086 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2087 shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
2088 /* Move .x first in case src_str is "TA" */
2089 shader_addline(buffer, "MOV TA.y, %s.x;\n", src_str);
2090 shader_addline(buffer, "MOV TA.x, %s.w;\n", src_str);
2091 if (reg1 < MAX_TEXTURES)
2092 {
2093 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2094 flags = priv->cur_ps_args->super.tex_transform >> reg1 * WINED3D_PSARGS_TEXTRANSFORM_SHIFT;
2095 }
2096 shader_hw_sample(ins, reg1, dst_str, "TA", flags & WINED3D_PSARGS_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2097}
2098
2100{
2101 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2102
2103 DWORD reg1 = ins->dst[0].reg.idx[0].offset;
2104 char dst_str[50];
2105 char src_str[50];
2106
2107 /* Note that texreg2gb treats Tx as a temporary register, not as a varying */
2108 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2109 shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
2110 shader_addline(buffer, "MOV TA.x, %s.y;\n", src_str);
2111 shader_addline(buffer, "MOV TA.y, %s.z;\n", src_str);
2112 shader_hw_sample(ins, reg1, dst_str, "TA", 0, NULL, NULL);
2113}
2114
2116{
2117 DWORD reg1 = ins->dst[0].reg.idx[0].offset;
2118 char dst_str[50];
2119 char src_str[50];
2120
2121 /* Note that texreg2rg treats Tx as a temporary register, not as a varying */
2122 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2123 shader_arb_get_src_param(ins, &ins->src[0], 0, src_str);
2124 shader_hw_sample(ins, reg1, dst_str, src_str, 0, NULL, NULL);
2125}
2126
2127static void pshader_hw_texbem(const struct wined3d_shader_instruction *ins)
2128{
2129 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2130 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2131 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2132 char reg_coord[40], dst_reg[50], src_reg[50];
2133 DWORD reg_dest_code;
2134
2135 /* All versions have a destination register. The Tx where the texture coordinates come
2136 * from is the varying incarnation of the texture register
2137 */
2138 reg_dest_code = dst->reg.idx[0].offset;
2139 shader_arb_get_dst_param(ins, &ins->dst[0], dst_reg);
2140 shader_arb_get_src_param(ins, &ins->src[0], 0, src_reg);
2141 sprintf(reg_coord, "fragment.texcoord[%u]", reg_dest_code);
2142
2143 /* Sampling the perturbation map in Tsrc was done already, including the signedness correction if needed
2144 * The Tx in which the perturbation map is stored is the tempreg incarnation of the texture register
2145 *
2146 * GL_NV_fragment_program_option could handle this in one instruction via X2D:
2147 * X2D TA.xy, fragment.texcoord, T%u, bumpenvmat%u.xzyw
2148 *
2149 * However, the NV extensions are never enabled for <= 2.0 shaders because of the performance penalty that
2150 * comes with it, and texbem is an 1.x only instruction. No 1.x instruction forces us to enable the NV
2151 * extension.
2152 */
2153 shader_addline(buffer, "SWZ TB, bumpenvmat%d, x, z, 0, 0;\n", reg_dest_code);
2154 shader_addline(buffer, "DP3 TA.x, TB, %s;\n", src_reg);
2155 shader_addline(buffer, "SWZ TB, bumpenvmat%d, y, w, 0, 0;\n", reg_dest_code);
2156 shader_addline(buffer, "DP3 TA.y, TB, %s;\n", src_reg);
2157
2158 /* with projective textures, texbem only divides the static texture coord, not the displacement,
2159 * so we can't let the GL handle this.
2160 */
2161 if ((priv->cur_ps_args->super.tex_transform >> reg_dest_code * WINED3D_PSARGS_TEXTRANSFORM_SHIFT)
2163 {
2164 shader_addline(buffer, "RCP TB.w, %s.w;\n", reg_coord);
2165 shader_addline(buffer, "MUL TB.xy, %s, TB.w;\n", reg_coord);
2166 shader_addline(buffer, "ADD TA.xy, TA, TB;\n");
2167 } else {
2168 shader_addline(buffer, "ADD TA.xy, TA, %s;\n", reg_coord);
2169 }
2170
2171 shader_hw_sample(ins, reg_dest_code, dst_reg, "TA", 0, NULL, NULL);
2172
2173 if (ins->handler_idx == WINED3DSIH_TEXBEML)
2174 {
2175 /* No src swizzles are allowed, so this is ok */
2176 shader_addline(buffer, "MAD TA, %s.z, luminance%d.x, luminance%d.y;\n",
2177 src_reg, reg_dest_code, reg_dest_code);
2178 shader_addline(buffer, "MUL %s, %s, TA;\n", dst_reg, dst_reg);
2179 }
2180}
2181
2183{
2184 DWORD reg = ins->dst[0].reg.idx[0].offset;
2185 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2186 char src0_name[50], dst_name[50];
2187 BOOL is_color;
2188 struct wined3d_shader_register tmp_reg = ins->dst[0].reg;
2189
2190 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2191 /* The next instruction will be a texm3x2tex or texm3x2depth that writes to the uninitialized
2192 * T<reg+1> register. Use this register to store the calculated vector
2193 */
2194 tmp_reg.idx[0].offset = reg + 1;
2195 shader_arb_get_register_name(ins, &tmp_reg, dst_name, &is_color);
2196 shader_addline(buffer, "DP3 %s.x, fragment.texcoord[%u], %s;\n", dst_name, reg, src0_name);
2197}
2198
2200{
2201 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2202 DWORD flags;
2203 DWORD reg = ins->dst[0].reg.idx[0].offset;
2204 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2205 char dst_str[50];
2206 char src0_name[50];
2207 char dst_reg[50];
2208 BOOL is_color;
2209
2210 /* We know that we're writing to the uninitialized T<reg> register, so use it for temporary storage */
2211 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
2212
2213 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2214 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2215 shader_addline(buffer, "DP3 %s.y, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
2216 flags = reg < MAX_TEXTURES ? priv->cur_ps_args->super.tex_transform >> reg * WINED3D_PSARGS_TEXTRANSFORM_SHIFT : 0;
2217 shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3D_PSARGS_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2218}
2219
2221{
2222 struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
2223 DWORD reg = ins->dst[0].reg.idx[0].offset;
2224 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2225 char src0_name[50], dst_name[50];
2226 struct wined3d_shader_register tmp_reg = ins->dst[0].reg;
2227 BOOL is_color;
2228
2229 /* There are always 2 texm3x3pad instructions followed by one texm3x3[tex,vspec, ...] instruction, with
2230 * incrementing ins->dst[0].register_idx numbers. So the pad instruction already knows the final destination
2231 * register, and this register is uninitialized(otherwise the assembler complains that it is 'redeclared')
2232 */
2233 tmp_reg.idx[0].offset = reg + 2 - tex_mx->current_row;
2234 shader_arb_get_register_name(ins, &tmp_reg, dst_name, &is_color);
2235
2236 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2237 shader_addline(buffer, "DP3 %s.%c, fragment.texcoord[%u], %s;\n",
2238 dst_name, 'x' + tex_mx->current_row, reg, src0_name);
2239 tex_mx->texcoord_w[tex_mx->current_row++] = reg;
2240}
2241
2243{
2244 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2245 struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
2246 DWORD flags;
2247 DWORD reg = ins->dst[0].reg.idx[0].offset;
2248 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2249 char dst_str[50];
2250 char src0_name[50], dst_name[50];
2251 BOOL is_color;
2252
2253 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2254 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2255 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_name, reg, src0_name);
2256
2257 /* Sample the texture using the calculated coordinates */
2258 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2259 flags = reg < MAX_TEXTURES ? priv->cur_ps_args->super.tex_transform >> reg * WINED3D_PSARGS_TEXTRANSFORM_SHIFT : 0;
2260 shader_hw_sample(ins, reg, dst_str, dst_name, flags & WINED3D_PSARGS_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2261 tex_mx->current_row = 0;
2262}
2263
2265{
2266 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2267 struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
2268 DWORD flags;
2269 DWORD reg = ins->dst[0].reg.idx[0].offset;
2270 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2271 char dst_str[50];
2272 char src0_name[50];
2273 char dst_reg[50];
2274 BOOL is_color;
2275
2276 /* Get the dst reg without writemask strings. We know this register is uninitialized, so we can use all
2277 * components for temporary data storage
2278 */
2279 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
2280 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2281 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
2282
2283 /* Construct the eye-ray vector from w coordinates */
2284 shader_addline(buffer, "MOV TB.x, fragment.texcoord[%u].w;\n", tex_mx->texcoord_w[0]);
2285 shader_addline(buffer, "MOV TB.y, fragment.texcoord[%u].w;\n", tex_mx->texcoord_w[1]);
2286 shader_addline(buffer, "MOV TB.z, fragment.texcoord[%u].w;\n", reg);
2287
2288 /* Calculate reflection vector
2289 */
2290 shader_addline(buffer, "DP3 %s.w, %s, TB;\n", dst_reg, dst_reg);
2291 /* The .w is ignored when sampling, so I can use TB.w to calculate dot(N, N) */
2292 shader_addline(buffer, "DP3 TB.w, %s, %s;\n", dst_reg, dst_reg);
2293 shader_addline(buffer, "RCP TB.w, TB.w;\n");
2294 shader_addline(buffer, "MUL %s.w, %s.w, TB.w;\n", dst_reg, dst_reg);
2295 shader_addline(buffer, "MUL %s, %s.w, %s;\n", dst_reg, dst_reg, dst_reg);
2296 shader_addline(buffer, "MAD %s, coefmul.x, %s, -TB;\n", dst_reg, dst_reg);
2297
2298 /* Sample the texture using the calculated coordinates */
2299 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2300 flags = reg < MAX_TEXTURES ? priv->cur_ps_args->super.tex_transform >> reg * WINED3D_PSARGS_TEXTRANSFORM_SHIFT : 0;
2301 shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3D_PSARGS_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2302 tex_mx->current_row = 0;
2303}
2304
2306{
2307 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2308 struct wined3d_shader_tex_mx *tex_mx = ins->ctx->tex_mx;
2309 DWORD flags;
2310 DWORD reg = ins->dst[0].reg.idx[0].offset;
2311 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2312 char dst_str[50];
2313 char src0_name[50];
2314 char src1_name[50];
2315 char dst_reg[50];
2316 BOOL is_color;
2317
2318 shader_arb_get_src_param(ins, &ins->src[0], 0, src0_name);
2319 shader_arb_get_src_param(ins, &ins->src[0], 1, src1_name);
2320 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_reg, &is_color);
2321 /* Note: dst_reg.xy is input here, generated by two texm3x3pad instructions */
2322 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_reg, reg, src0_name);
2323
2324 /* Calculate reflection vector.
2325 *
2326 * dot(N, E)
2327 * dst_reg.xyz = 2 * --------- * N - E
2328 * dot(N, N)
2329 *
2330 * Which normalizes the normal vector
2331 */
2332 shader_addline(buffer, "DP3 %s.w, %s, %s;\n", dst_reg, dst_reg, src1_name);
2333 shader_addline(buffer, "DP3 TC.w, %s, %s;\n", dst_reg, dst_reg);
2334 shader_addline(buffer, "RCP TC.w, TC.w;\n");
2335 shader_addline(buffer, "MUL %s.w, %s.w, TC.w;\n", dst_reg, dst_reg);
2336 shader_addline(buffer, "MUL %s, %s.w, %s;\n", dst_reg, dst_reg, dst_reg);
2337 shader_addline(buffer, "MAD %s, coefmul.x, %s, -%s;\n", dst_reg, dst_reg, src1_name);
2338
2339 /* Sample the texture using the calculated coordinates */
2340 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2341 flags = reg < MAX_TEXTURES ? priv->cur_ps_args->super.tex_transform >> reg * WINED3D_PSARGS_TEXTRANSFORM_SHIFT : 0;
2342 shader_hw_sample(ins, reg, dst_str, dst_reg, flags & WINED3D_PSARGS_PROJECTED ? TEX_PROJ : 0, NULL, NULL);
2343 tex_mx->current_row = 0;
2344}
2345
2347{
2348 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2349 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2350 char dst_name[50];
2351 const char *zero = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ZERO);
2352 const char *one = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ONE);
2353
2354 /* texdepth has an implicit destination, the fragment depth value. It's only parameter,
2355 * which is essentially an input, is the destination register because it is the first
2356 * parameter. According to the msdn, this must be register r5, but let's keep it more flexible
2357 * here(writemasks/swizzles are not valid on texdepth)
2358 */
2359 shader_arb_get_dst_param(ins, dst, dst_name);
2360
2361 /* According to the msdn, the source register(must be r5) is unusable after
2362 * the texdepth instruction, so we're free to modify it
2363 */
2364 shader_addline(buffer, "MIN %s.y, %s.y, %s;\n", dst_name, dst_name, one);
2365
2366 /* How to deal with the special case dst_name.g == 0? if r != 0, then
2367 * the r * (1 / 0) will give infinity, which is clamped to 1.0, the correct
2368 * result. But if r = 0.0, then 0 * inf = 0, which is incorrect.
2369 */
2370 shader_addline(buffer, "RCP %s.y, %s.y;\n", dst_name, dst_name);
2371 shader_addline(buffer, "MUL TA.x, %s.x, %s.y;\n", dst_name, dst_name);
2372 shader_addline(buffer, "MIN TA.x, TA.x, %s;\n", one);
2373 shader_addline(buffer, "MAX result.depth, TA.x, %s;\n", zero);
2374}
2375
2380{
2381 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2382 DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
2383 char src0[50];
2384 char dst_str[50];
2385
2386 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2387 shader_addline(buffer, "MOV TB, 0.0;\n");
2388 shader_addline(buffer, "DP3 TB.x, fragment.texcoord[%u], %s;\n", sampler_idx, src0);
2389
2390 shader_arb_get_dst_param(ins, &ins->dst[0], dst_str);
2391 shader_hw_sample(ins, sampler_idx, dst_str, "TB", 0 /* Only one coord, can't be projected */, NULL, NULL);
2392}
2393
2396static void pshader_hw_texdp3(const struct wined3d_shader_instruction *ins)
2397{
2398 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2399 char src0[50];
2400 char dst_str[50];
2401 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2402
2403 /* Handle output register */
2404 shader_arb_get_dst_param(ins, dst, dst_str);
2405 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2406 shader_addline(buffer, "DP3 %s, fragment.texcoord[%u], %s;\n", dst_str, dst->reg.idx[0].offset, src0);
2407}
2408
2412{
2413 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2414 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2415 char dst_str[50], dst_name[50];
2416 char src0[50];
2417 BOOL is_color;
2418
2419 shader_arb_get_dst_param(ins, dst, dst_str);
2420 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2421 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2422 shader_addline(buffer, "DP3 %s.z, fragment.texcoord[%u], %s;\n", dst_name, dst->reg.idx[0].offset, src0);
2423 shader_addline(buffer, "MOV %s, %s;\n", dst_str, dst_name);
2424}
2425
2432{
2433 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2434 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2435 char src0[50], dst_name[50];
2436 BOOL is_color;
2437 const char *zero = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ZERO);
2438 const char *one = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ONE);
2439
2440 shader_arb_get_src_param(ins, &ins->src[0], 0, src0);
2441 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2442 shader_addline(buffer, "DP3 %s.y, fragment.texcoord[%u], %s;\n", dst_name, dst->reg.idx[0].offset, src0);
2443
2444 /* How to deal with the special case dst_name.g == 0? if r != 0, then
2445 * the r * (1 / 0) will give infinity, which is clamped to 1.0, the correct
2446 * result. But if r = 0.0, then 0 * inf = 0, which is incorrect.
2447 */
2448 shader_addline(buffer, "RCP %s.y, %s.y;\n", dst_name, dst_name);
2449 shader_addline(buffer, "MUL %s.x, %s.x, %s.y;\n", dst_name, dst_name, dst_name);
2450 shader_addline(buffer, "MIN %s.x, %s.x, %s;\n", dst_name, dst_name, one);
2451 shader_addline(buffer, "MAX result.depth, %s.x, %s;\n", dst_name, zero);
2452}
2453
2456static void shader_hw_mnxn(const struct wined3d_shader_instruction *ins)
2457{
2458 int i;
2459 int nComponents = 0;
2460 struct wined3d_shader_dst_param tmp_dst = {{0}};
2461 struct wined3d_shader_src_param tmp_src[2] = {{{0}}};
2462 struct wined3d_shader_instruction tmp_ins;
2463
2464 memset(&tmp_ins, 0, sizeof(tmp_ins));
2465
2466 /* Set constants for the temporary argument */
2467 tmp_ins.ctx = ins->ctx;
2468 tmp_ins.dst_count = 1;
2469 tmp_ins.dst = &tmp_dst;
2470 tmp_ins.src_count = 2;
2471 tmp_ins.src = tmp_src;
2472
2473 switch(ins->handler_idx)
2474 {
2475 case WINED3DSIH_M4x4:
2476 nComponents = 4;
2477 tmp_ins.handler_idx = WINED3DSIH_DP4;
2478 break;
2479 case WINED3DSIH_M4x3:
2480 nComponents = 3;
2481 tmp_ins.handler_idx = WINED3DSIH_DP4;
2482 break;
2483 case WINED3DSIH_M3x4:
2484 nComponents = 4;
2485 tmp_ins.handler_idx = WINED3DSIH_DP3;
2486 break;
2487 case WINED3DSIH_M3x3:
2488 nComponents = 3;
2489 tmp_ins.handler_idx = WINED3DSIH_DP3;
2490 break;
2491 case WINED3DSIH_M3x2:
2492 nComponents = 2;
2493 tmp_ins.handler_idx = WINED3DSIH_DP3;
2494 break;
2495 default:
2496 FIXME("Unhandled opcode %s.\n", debug_d3dshaderinstructionhandler(ins->handler_idx));
2497 break;
2498 }
2499
2500 tmp_dst = ins->dst[0];
2501 tmp_src[0] = ins->src[0];
2502 tmp_src[1] = ins->src[1];
2503 for (i = 0; i < nComponents; ++i)
2504 {
2505 tmp_dst.write_mask = WINED3DSP_WRITEMASK_0 << i;
2506 shader_hw_map2gl(&tmp_ins);
2507 ++tmp_src[1].reg.idx[0].offset;
2508 }
2509}
2510
2511static DWORD abs_modifier(DWORD mod, BOOL *need_abs)
2512{
2513 *need_abs = FALSE;
2514
2515 switch(mod)
2516 {
2517 case WINED3DSPSM_NONE: return WINED3DSPSM_ABS;
2518 case WINED3DSPSM_NEG: return WINED3DSPSM_ABS;
2519 case WINED3DSPSM_BIAS: *need_abs = TRUE; return WINED3DSPSM_BIAS;
2520 case WINED3DSPSM_BIASNEG: *need_abs = TRUE; return WINED3DSPSM_BIASNEG;
2521 case WINED3DSPSM_SIGN: *need_abs = TRUE; return WINED3DSPSM_SIGN;
2522 case WINED3DSPSM_SIGNNEG: *need_abs = TRUE; return WINED3DSPSM_SIGNNEG;
2523 case WINED3DSPSM_COMP: *need_abs = TRUE; return WINED3DSPSM_COMP;
2524 case WINED3DSPSM_X2: *need_abs = TRUE; return WINED3DSPSM_X2;
2525 case WINED3DSPSM_X2NEG: *need_abs = TRUE; return WINED3DSPSM_X2NEG;
2526 case WINED3DSPSM_DZ: *need_abs = TRUE; return WINED3DSPSM_DZ;
2527 case WINED3DSPSM_DW: *need_abs = TRUE; return WINED3DSPSM_DW;
2528 case WINED3DSPSM_ABS: return WINED3DSPSM_ABS;
2530 }
2531 FIXME("Unknown modifier %u\n", mod);
2532 return mod;
2533}
2534
2536{
2537 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2538 const char *instruction;
2539 struct wined3d_shader_src_param src0_copy = ins->src[0];
2540 BOOL need_abs = FALSE;
2541
2542 char dst[50];
2543 char src[50];
2544
2545 switch(ins->handler_idx)
2546 {
2547 case WINED3DSIH_RSQ: instruction = "RSQ"; break;
2548 case WINED3DSIH_RCP: instruction = "RCP"; break;
2549 case WINED3DSIH_EXPP:
2550 if (ins->ctx->reg_maps->shader_version.major < 2)
2551 {
2552 instruction = "EXP";
2553 break;
2554 }
2555 /* Drop through. */
2556 case WINED3DSIH_EXP:
2557 instruction = "EX2";
2558 break;
2559 case WINED3DSIH_LOG:
2560 case WINED3DSIH_LOGP:
2561 /* The precision requirements suggest that LOGP matches ARBvp's LOG
2562 * instruction, but notice that the output of those instructions is
2563 * different. */
2564 src0_copy.modifiers = abs_modifier(src0_copy.modifiers, &need_abs);
2565 instruction = "LG2";
2566 break;
2567 default: instruction = "";
2568 FIXME("Unhandled opcode %s.\n", debug_d3dshaderinstructionhandler(ins->handler_idx));
2569 break;
2570 }
2571
2572 /* Dx sdk says .x is used if no swizzle is given, but our test shows that
2573 * .w is used. */
2574 src0_copy.swizzle = shader_arb_select_component(src0_copy.swizzle, 3);
2575
2576 shader_arb_get_dst_param(ins, &ins->dst[0], dst); /* Destination */
2577 shader_arb_get_src_param(ins, &src0_copy, 0, src);
2578
2579 if(need_abs)
2580 {
2581 shader_addline(buffer, "ABS TA.w, %s;\n", src);
2582 shader_addline(buffer, "%s%s %s, TA.w;\n", instruction, shader_arb_get_modifier(ins), dst);
2583 }
2584 else
2585 {
2586 shader_addline(buffer, "%s%s %s, %s;\n", instruction, shader_arb_get_modifier(ins), dst, src);
2587 }
2588
2589}
2590
2591static void shader_hw_nrm(const struct wined3d_shader_instruction *ins)
2592{
2593 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2594 char dst_name[50];
2595 char src_name[50];
2596 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2597 BOOL pshader = shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type);
2598 const char *zero = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ZERO);
2599
2600 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2601 shader_arb_get_src_param(ins, &ins->src[0], 1 /* Use TB */, src_name);
2602
2603 /* In D3D, NRM of a vector with length zero returns zero. Catch this situation, as
2604 * otherwise NRM or RSQ would return NaN */
2605 if(pshader && priv->target_version >= NV3)
2606 {
2607 /* GL_NV_fragment_program2's NRM needs protection against length zero vectors too
2608 *
2609 * TODO: Find out if DP3+NRM+MOV is really faster than DP3+RSQ+MUL
2610 */
2611 shader_addline(buffer, "DP3C TA, %s, %s;\n", src_name, src_name);
2612 shader_addline(buffer, "NRM%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name);
2613 shader_addline(buffer, "MOV %s (EQ), %s;\n", dst_name, zero);
2614 }
2615 else if(priv->target_version >= NV2)
2616 {
2617 shader_addline(buffer, "DP3C TA.x, %s, %s;\n", src_name, src_name);
2618 shader_addline(buffer, "RSQ TA.x (NE), TA.x;\n");
2619 shader_addline(buffer, "MUL%s %s, %s, TA.x;\n", shader_arb_get_modifier(ins), dst_name,
2620 src_name);
2621 }
2622 else
2623 {
2624 const char *one = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ONE);
2625
2626 shader_addline(buffer, "DP3 TA.x, %s, %s;\n", src_name, src_name);
2627 /* Pass any non-zero value to RSQ if the input vector has a length of zero. The
2628 * RSQ result doesn't matter, as long as multiplying it by 0 returns 0.
2629 */
2630 shader_addline(buffer, "SGE TA.y, -TA.x, %s;\n", zero);
2631 shader_addline(buffer, "MAD TA.x, %s, TA.y, TA.x;\n", one);
2632
2633 shader_addline(buffer, "RSQ TA.x, TA.x;\n");
2634 /* dst.w = src[0].w * 1 / (src.x^2 + src.y^2 + src.z^2)^(1/2) according to msdn*/
2635 shader_addline(buffer, "MUL%s %s, %s, TA.x;\n", shader_arb_get_modifier(ins), dst_name,
2636 src_name);
2637 }
2638}
2639
2640static void shader_hw_lrp(const struct wined3d_shader_instruction *ins)
2641{
2642 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2643 char dst_name[50];
2644 char src_name[3][50];
2645
2646 /* ARB_fragment_program has a convenient LRP instruction */
2647 if(shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)) {
2648 shader_hw_map2gl(ins);
2649 return;
2650 }
2651
2652 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2653 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name[0]);
2654 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name[1]);
2655 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name[2]);
2656
2657 shader_addline(buffer, "SUB TA, %s, %s;\n", src_name[1], src_name[2]);
2658 shader_addline(buffer, "MAD%s %s, %s, TA, %s;\n", shader_arb_get_modifier(ins),
2659 dst_name, src_name[0], src_name[2]);
2660}
2661
2662static void shader_hw_sincos(const struct wined3d_shader_instruction *ins)
2663{
2664 /* This instruction exists in ARB, but the d3d instruction takes two extra parameters which
2665 * must contain fixed constants. So we need a separate function to filter those constants and
2666 * can't use map2gl
2667 */
2668 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2669 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2670 const struct wined3d_shader_dst_param *dst = &ins->dst[0];
2671 char dst_name[50];
2672 char src_name0[50], src_name1[50], src_name2[50];
2673 BOOL is_color;
2674
2675 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
2676 if(shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)) {
2677 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2678 /* No modifiers are supported on SCS */
2679 shader_addline(buffer, "SCS %s, %s;\n", dst_name, src_name0);
2680
2681 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE)
2682 {
2683 shader_arb_get_register_name(ins, &dst->reg, src_name0, &is_color);
2684 shader_addline(buffer, "MOV_SAT %s, %s;\n", dst_name, src_name0);
2685 }
2686 } else if(priv->target_version >= NV2) {
2687 shader_arb_get_register_name(ins, &dst->reg, dst_name, &is_color);
2688
2689 /* Sincos writemask must be .x, .y or .xy */
2690 if(dst->write_mask & WINED3DSP_WRITEMASK_0)
2691 shader_addline(buffer, "COS%s %s.x, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name0);
2692 if(dst->write_mask & WINED3DSP_WRITEMASK_1)
2693 shader_addline(buffer, "SIN%s %s.y, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name0);
2694 } else {
2695 /* Approximate sine and cosine with a taylor series, as per math textbook. The application passes 8
2696 * helper constants(D3DSINCOSCONST1 and D3DSINCOSCONST2) in src1 and src2.
2697 *
2698 * sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ...
2699 * cos(x) = 1 - x^2/2! + x^4/4! - x^6/6! + ...
2700 *
2701 * The constants we get are:
2702 *
2703 * +1 +1, -1 -1 +1 +1 -1 -1
2704 * ---- , ---- , ---- , ----- , ----- , ----- , ------
2705 * 1!*2 2!*4 3!*8 4!*16 5!*32 6!*64 7!*128
2706 *
2707 * If used with x^2, x^3, x^4 etc they calculate sin(x/2) and cos(x/2):
2708 *
2709 * (x/2)^2 = x^2 / 4
2710 * (x/2)^3 = x^3 / 8
2711 * (x/2)^4 = x^4 / 16
2712 * (x/2)^5 = x^5 / 32
2713 * etc
2714 *
2715 * To get the final result:
2716 * sin(x) = 2 * sin(x/2) * cos(x/2)
2717 * cos(x) = cos(x/2)^2 - sin(x/2)^2
2718 * (from sin(x+y) and cos(x+y) rules)
2719 *
2720 * As per MSDN, dst.z is undefined after the operation, and so is
2721 * dst.x and dst.y if they're masked out by the writemask. Ie
2722 * sincos dst.y, src1, c0, c1
2723 * returns the sine in dst.y. dst.x and dst.z are undefined, dst.w is not touched. The assembler
2724 * vsa.exe also stops with an error if the dest register is the same register as the source
2725 * register. This means we can use dest.xyz as temporary storage. The assembler vsa.exe output also
2726 * indicates that sincos consumes 8 instruction slots in vs_2_0(and, strangely, in vs_3_0).
2727 */
2728 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
2729 shader_arb_get_src_param(ins, &ins->src[2], 2, src_name2);
2730 shader_arb_get_register_name(ins, &dst->reg, dst_name, &is_color);
2731
2732 shader_addline(buffer, "MUL %s.x, %s, %s;\n", dst_name, src_name0, src_name0); /* x ^ 2 */
2733 shader_addline(buffer, "MUL TA.y, %s.x, %s;\n", dst_name, src_name0); /* x ^ 3 */
2734 shader_addline(buffer, "MUL %s.y, TA.y, %s;\n", dst_name, src_name0); /* x ^ 4 */
2735 shader_addline(buffer, "MUL TA.z, %s.y, %s;\n", dst_name, src_name0); /* x ^ 5 */
2736 shader_addline(buffer, "MUL %s.z, TA.z, %s;\n", dst_name, src_name0); /* x ^ 6 */
2737 shader_addline(buffer, "MUL TA.w, %s.z, %s;\n", dst_name, src_name0); /* x ^ 7 */
2738
2739 /* sin(x/2)
2740 *
2741 * Unfortunately we don't get the constants in a DP4-capable form. Is there a way to
2742 * properly merge that with MULs in the code above?
2743 * The swizzles .yz and xw however fit into the .yzxw swizzle added to ps_2_0. Maybe
2744 * we can merge the sine and cosine MAD rows to calculate them together.
2745 */
2746 shader_addline(buffer, "MUL TA.x, %s, %s.w;\n", src_name0, src_name2); /* x^1, +1/(1!*2) */
2747 shader_addline(buffer, "MAD TA.x, TA.y, %s.x, TA.x;\n", src_name2); /* -1/(3!*8) */
2748 shader_addline(buffer, "MAD TA.x, TA.z, %s.w, TA.x;\n", src_name1); /* +1/(5!*32) */
2749 shader_addline(buffer, "MAD TA.x, TA.w, %s.x, TA.x;\n", src_name1); /* -1/(7!*128) */
2750
2751 /* cos(x/2) */
2752 shader_addline(buffer, "MAD TA.y, %s.x, %s.y, %s.z;\n", dst_name, src_name2, src_name2); /* -1/(2!*4), +1.0 */
2753 shader_addline(buffer, "MAD TA.y, %s.y, %s.z, TA.y;\n", dst_name, src_name1); /* +1/(4!*16) */
2754 shader_addline(buffer, "MAD TA.y, %s.z, %s.y, TA.y;\n", dst_name, src_name1); /* -1/(6!*64) */
2755
2756 if(dst->write_mask & WINED3DSP_WRITEMASK_0) {
2757 /* cos x */
2758 shader_addline(buffer, "MUL TA.z, TA.y, TA.y;\n");
2759 shader_addline(buffer, "MAD %s.x, -TA.x, TA.x, TA.z;\n", dst_name);
2760 }
2761 if(dst->write_mask & WINED3DSP_WRITEMASK_1) {
2762 /* sin x */
2763 shader_addline(buffer, "MUL %s.y, TA.x, TA.y;\n", dst_name);
2764 shader_addline(buffer, "ADD %s.y, %s.y, %s.y;\n", dst_name, dst_name, dst_name);
2765 }
2766 }
2767}
2768
2769static void shader_hw_sgn(const struct wined3d_shader_instruction *ins)
2770{
2771 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2772 char dst_name[50];
2773 char src_name[50];
2774 struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
2775
2776 shader_arb_get_dst_param(ins, &ins->dst[0], dst_name);
2777 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name);
2778
2779 /* SGN is only valid in vertex shaders */
2780 if(ctx->target_version >= NV2) {
2781 shader_addline(buffer, "SSG%s %s, %s;\n", shader_arb_get_modifier(ins), dst_name, src_name);
2782 return;
2783 }
2784
2785 /* If SRC > 0.0, -SRC < SRC = TRUE, otherwise false.
2786 * if SRC < 0.0, SRC < -SRC = TRUE. If neither is true, src = 0.0
2787 */
2788 if(ins->dst[0].modifiers & WINED3DSPDM_SATURATE) {
2789 shader_addline(buffer, "SLT %s, -%s, %s;\n", dst_name, src_name, src_name);
2790 } else {
2791 /* src contains TA? Write to the dest first. This won't overwrite our destination.
2792 * Then use TA, and calculate the final result
2793 *
2794 * Not reading from TA? Store the first result in TA to avoid overwriting the
2795 * destination if src reg = dst reg
2796 */
2797 if(strstr(src_name, "TA"))
2798 {
2799 shader_addline(buffer, "SLT %s, %s, -%s;\n", dst_name, src_name, src_name);
2800 shader_addline(buffer, "SLT TA, -%s, %s;\n", src_name, src_name);
2801 shader_addline(buffer, "ADD %s, %s, -TA;\n", dst_name, dst_name);
2802 }
2803 else
2804 {
2805 shader_addline(buffer, "SLT TA, -%s, %s;\n", src_name, src_name);
2806 shader_addline(buffer, "SLT %s, %s, -%s;\n", dst_name, src_name, src_name);
2807 shader_addline(buffer, "ADD %s, TA, -%s;\n", dst_name, dst_name);
2808 }
2809 }
2810}
2811
2812static void shader_hw_dsy(const struct wined3d_shader_instruction *ins)
2813{
2814 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2815 char src[50];
2816 char dst[50];
2817 char dst_name[50];
2818 BOOL is_color;
2819
2820 shader_arb_get_dst_param(ins, &ins->dst[0], dst);
2821 shader_arb_get_src_param(ins, &ins->src[0], 0, src);
2822 shader_arb_get_register_name(ins, &ins->dst[0].reg, dst_name, &is_color);
2823
2824 shader_addline(buffer, "DDY %s, %s;\n", dst, src);
2825 shader_addline(buffer, "MUL%s %s, %s, ycorrection.y;\n", shader_arb_get_modifier(ins), dst, dst_name);
2826}
2827
2828static void shader_hw_pow(const struct wined3d_shader_instruction *ins)
2829{
2830 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2831 char src0[50], src1[50], dst[50];
2832 struct wined3d_shader_src_param src0_copy = ins->src[0];
2833 BOOL need_abs = FALSE;
2834 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2835 const char *one = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ONE);
2836
2837 /* POW operates on the absolute value of the input */
2838 src0_copy.modifiers = abs_modifier(src0_copy.modifiers, &need_abs);
2839
2840 shader_arb_get_dst_param(ins, &ins->dst[0], dst);
2841 shader_arb_get_src_param(ins, &src0_copy, 0, src0);
2842 shader_arb_get_src_param(ins, &ins->src[1], 1, src1);
2843
2844 if (need_abs)
2845 shader_addline(buffer, "ABS TA.x, %s;\n", src0);
2846 else
2847 shader_addline(buffer, "MOV TA.x, %s;\n", src0);
2848
2849 if (priv->target_version >= NV2)
2850 {
2851 shader_addline(buffer, "MOVC TA.y, %s;\n", src1);
2852 shader_addline(buffer, "POW%s %s, TA.x, TA.y;\n", shader_arb_get_modifier(ins), dst);
2853 shader_addline(buffer, "MOV %s (EQ.y), %s;\n", dst, one);
2854 }
2855 else
2856 {
2857 const char *zero = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_ZERO);
2858 const char *flt_eps = arb_get_helper_value(ins->ctx->reg_maps->shader_version.type, ARB_EPS);
2859
2860 shader_addline(buffer, "ABS TA.y, %s;\n", src1);
2861 shader_addline(buffer, "SGE TA.y, -TA.y, %s;\n", zero);
2862 /* Possibly add flt_eps to avoid getting float special values */
2863 shader_addline(buffer, "MAD TA.z, TA.y, %s, %s;\n", flt_eps, src1);
2864 shader_addline(buffer, "POW%s TA.x, TA.x, TA.z;\n", shader_arb_get_modifier(ins));
2865 shader_addline(buffer, "MAD TA.x, -TA.x, TA.y, TA.x;\n");
2866 shader_addline(buffer, "MAD %s, TA.y, %s, TA.x;\n", dst, one);
2867 }
2868}
2869
2870static void shader_hw_loop(const struct wined3d_shader_instruction *ins)
2871{
2872 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2873 char src_name[50];
2874 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2875
2876 /* src0 is aL */
2877 shader_arb_get_src_param(ins, &ins->src[1], 0, src_name);
2878
2879 if(vshader)
2880 {
2881 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2882 struct list *e = list_head(&priv->control_frames);
2884
2885 if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
2886 /* The constant loader makes sure to load -1 into iX.w */
2887 shader_addline(buffer, "ARLC aL, %s.xywz;\n", src_name);
2888 shader_addline(buffer, "BRA loop_%u_end (LE.x);\n", control_frame->no.loop);
2889 shader_addline(buffer, "loop_%u_start:\n", control_frame->no.loop);
2890 }
2891 else
2892 {
2893 shader_addline(buffer, "LOOP %s;\n", src_name);
2894 }
2895}
2896
2897static void shader_hw_rep(const struct wined3d_shader_instruction *ins)
2898{
2899 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2900 char src_name[50];
2901 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2902
2903 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name);
2904
2905 /* The constant loader makes sure to load -1 into iX.w */
2906 if(vshader)
2907 {
2908 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2909 struct list *e = list_head(&priv->control_frames);
2911
2912 if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
2913
2914 shader_addline(buffer, "ARLC aL, %s.xywz;\n", src_name);
2915 shader_addline(buffer, "BRA loop_%u_end (LE.x);\n", control_frame->no.loop);
2916 shader_addline(buffer, "loop_%u_start:\n", control_frame->no.loop);
2917 }
2918 else
2919 {
2920 shader_addline(buffer, "REP %s;\n", src_name);
2921 }
2922}
2923
2924static void shader_hw_endloop(const struct wined3d_shader_instruction *ins)
2925{
2926 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2927 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2928
2929 if(vshader)
2930 {
2931 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2932 struct list *e = list_head(&priv->control_frames);
2934
2935 shader_addline(buffer, "ARAC aL.xy, aL;\n");
2936 shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->no.loop);
2937 shader_addline(buffer, "loop_%u_end:\n", control_frame->no.loop);
2938
2939 if(priv->loop_depth > 1) shader_addline(buffer, "POPA aL;\n");
2940 }
2941 else
2942 {
2943 shader_addline(buffer, "ENDLOOP;\n");
2944 }
2945}
2946
2947static void shader_hw_endrep(const struct wined3d_shader_instruction *ins)
2948{
2949 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2950 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2951
2952 if(vshader)
2953 {
2954 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
2955 struct list *e = list_head(&priv->control_frames);
2957
2958 shader_addline(buffer, "ARAC aL.xy, aL;\n");
2959 shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->no.loop);
2960 shader_addline(buffer, "loop_%u_end:\n", control_frame->no.loop);
2961
2962 if(priv->loop_depth > 1) shader_addline(buffer, "POPA aL;\n");
2963 }
2964 else
2965 {
2966 shader_addline(buffer, "ENDREP;\n");
2967 }
2968}
2969
2970static const struct control_frame *find_last_loop(const struct shader_arb_ctx_priv *priv)
2971{
2973
2975 {
2977 }
2978 ERR("Could not find loop for break\n");
2979 return NULL;
2980}
2981
2982static void shader_hw_break(const struct wined3d_shader_instruction *ins)
2983{
2984 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
2985 const struct control_frame *control_frame = find_last_loop(ins->ctx->backend_data);
2986 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
2987
2988 if(vshader)
2989 {
2990 shader_addline(buffer, "BRA loop_%u_end;\n", control_frame->no.loop);
2991 }
2992 else
2993 {
2994 shader_addline(buffer, "BRK;\n");
2995 }
2996}
2997
2998static const char *get_compare(enum wined3d_shader_rel_op op)
2999{
3000 switch (op)
3001 {
3002 case WINED3D_SHADER_REL_OP_GT: return "GT";
3003 case WINED3D_SHADER_REL_OP_EQ: return "EQ";
3004 case WINED3D_SHADER_REL_OP_GE: return "GE";
3005 case WINED3D_SHADER_REL_OP_LT: return "LT";
3006 case WINED3D_SHADER_REL_OP_NE: return "NE";
3007 case WINED3D_SHADER_REL_OP_LE: return "LE";
3008 default:
3009 FIXME("Unrecognized operator %#x.\n", op);
3010 return "(\?\?)";
3011 }
3012}
3013
3015{
3016 switch (op)
3017 {
3024 default:
3025 FIXME("Unrecognized operator %#x.\n", op);
3026 return -1;
3027 }
3028}
3029
3030static void shader_hw_breakc(const struct wined3d_shader_instruction *ins)
3031{
3032 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
3033 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
3034 const struct control_frame *control_frame = find_last_loop(ins->ctx->backend_data);
3035 char src_name0[50];
3036 char src_name1[50];
3037 const char *comp = get_compare(ins->flags);
3038
3039 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
3040 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
3041
3042 if(vshader)
3043 {
3044 /* SUBC CC, src0, src1" works only in pixel shaders, so use TA to throw
3045 * away the subtraction result
3046 */
3047 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
3048 shader_addline(buffer, "BRA loop_%u_end (%s.x);\n", control_frame->no.loop, comp);
3049 }
3050 else
3051 {
3052 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
3053 shader_addline(buffer, "BRK (%s.x);\n", comp);
3054 }
3055}
3056
3057static void shader_hw_ifc(const struct wined3d_shader_instruction *ins)
3058{
3059 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
3060 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3061 struct list *e = list_head(&priv->control_frames);
3063 const char *comp;
3064 char src_name0[50];
3065 char src_name1[50];
3066 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
3067
3068 shader_arb_get_src_param(ins, &ins->src[0], 0, src_name0);
3069 shader_arb_get_src_param(ins, &ins->src[1], 1, src_name1);
3070
3071 if(vshader)
3072 {
3073 /* Invert the flag. We jump to the else label if the condition is NOT true */
3074 comp = get_compare(invert_compare(ins->flags));
3075 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
3076 shader_addline(buffer, "BRA ifc_%u_else (%s.x);\n", control_frame->no.ifc, comp);
3077 }
3078 else
3079 {
3080 comp = get_compare(ins->flags);
3081 shader_addline(buffer, "SUBC TA, %s, %s;\n", src_name0, src_name1);
3082 shader_addline(buffer, "IF %s.x;\n", comp);
3083 }
3084}
3085
3086static void shader_hw_else(const struct wined3d_shader_instruction *ins)
3087{
3088 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
3089 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3090 struct list *e = list_head(&priv->control_frames);
3092 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
3093
3094 if(vshader)
3095 {
3096 shader_addline(buffer, "BRA ifc_%u_endif;\n", control_frame->no.ifc);
3097 shader_addline(buffer, "ifc_%u_else:\n", control_frame->no.ifc);
3099 }
3100 else
3101 {
3102 shader_addline(buffer, "ELSE;\n");
3103 }
3104}
3105
3106static void shader_hw_endif(const struct wined3d_shader_instruction *ins)
3107{
3108 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
3109 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3110 struct list *e = list_head(&priv->control_frames);
3112 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
3113
3114 if(vshader)
3115 {
3117 {
3118 shader_addline(buffer, "ifc_%u_endif:\n", control_frame->no.ifc);
3119 }
3120 else
3121 {
3122 shader_addline(buffer, "#No else branch. else is endif\n");
3123 shader_addline(buffer, "ifc_%u_else:\n", control_frame->no.ifc);
3124 }
3125 }
3126 else
3127 {
3128 shader_addline(buffer, "ENDIF;\n");
3129 }
3130}
3131
3132static void shader_hw_texldd(const struct wined3d_shader_instruction *ins)
3133{
3134 DWORD sampler_idx = ins->src[1].reg.idx[0].offset;
3135 char reg_dest[40];
3136 char reg_src[3][40];
3138
3139 shader_arb_get_dst_param(ins, &ins->dst[0], reg_dest);
3140 shader_arb_get_src_param(ins, &ins->src[0], 0, reg_src[0]);
3141 shader_arb_get_src_param(ins, &ins->src[2], 1, reg_src[1]);
3142 shader_arb_get_src_param(ins, &ins->src[3], 2, reg_src[2]);
3143
3146
3147 shader_hw_sample(ins, sampler_idx, reg_dest, reg_src[0], flags, reg_src[1], reg_src[2]);
3148}
3149
3150static void shader_hw_texldl(const struct wined3d_shader_instruction *ins)
3151{
3152 DWORD sampler_idx = ins->src[1].reg.idx[0].offset;
3153 char reg_dest[40];
3154 char reg_coord[40];
3155 WORD flags = TEX_LOD;
3156
3157 shader_arb_get_dst_param(ins, &ins->dst[0], reg_dest);
3158 shader_arb_get_src_param(ins, &ins->src[0], 0, reg_coord);
3159
3162
3163 shader_hw_sample(ins, sampler_idx, reg_dest, reg_coord, flags, NULL, NULL);
3164}
3165
3166static void shader_hw_label(const struct wined3d_shader_instruction *ins)
3167{
3168 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
3169 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3170
3171 priv->in_main_func = FALSE;
3172 /* Call instructions activate the NV extensions, not labels and rets. If there is an uncalled
3173 * subroutine, don't generate a label that will make GL complain
3174 */
3175 if(priv->target_version == ARB) return;
3176
3177 shader_addline(buffer, "l%u:\n", ins->src[0].reg.idx[0].offset);
3178}
3179
3180static void vshader_add_footer(struct shader_arb_ctx_priv *priv_ctx,
3181 const struct arb_vshader_private *shader_data, const struct arb_vs_compile_args *args,
3182 const struct wined3d_shader_reg_maps *reg_maps, const struct wined3d_gl_info *gl_info,
3184{
3185 unsigned int i;
3186
3187 /* The D3DRS_FOGTABLEMODE render state defines if the shader-generated fog coord is used
3188 * or if the fragment depth is used. If the fragment depth is used(FOGTABLEMODE != NONE),
3189 * the fog frag coord is thrown away. If the fog frag coord is used, but not written by
3190 * the shader, it is set to 0.0(fully fogged, since start = 1.0, end = 0.0)
3191 */
3192 if (args->super.fog_src == VS_FOG_Z)
3193 {
3194 shader_addline(buffer, "MOV result.fogcoord, TMP_OUT.z;\n");
3195 }
3196 else
3197 {
3198 if (!reg_maps->fog)
3199 {
3200 /* posFixup.x is always 1.0, so we can safely use it */
3201 shader_addline(buffer, "ADD result.fogcoord, posFixup.x, -posFixup.x;\n");
3202 }
3203 else
3204 {
3205 /* Clamp fogcoord */
3206 const char *zero = arb_get_helper_value(reg_maps->shader_version.type, ARB_ZERO);
3207 const char *one = arb_get_helper_value(reg_maps->shader_version.type, ARB_ONE);
3208
3209 shader_addline(buffer, "MIN TMP_FOGCOORD.x, TMP_FOGCOORD.x, %s;\n", one);
3210 shader_addline(buffer, "MAX result.fogcoord.x, TMP_FOGCOORD.x, %s;\n", zero);
3211 }
3212 }
3213
3214 /* Clipplanes are always stored without y inversion */
3215 if (use_nv_clip(gl_info) && priv_ctx->target_version >= NV2)
3216 {
3217 if (args->super.clip_enabled)
3218 {
3219 for (i = 0; i < priv_ctx->vs_clipplanes; i++)
3220 {
3221 shader_addline(buffer, "DP4 result.clip[%u].x, TMP_OUT, state.clip[%u].plane;\n", i, i);
3222 }
3223 }
3224 }
3225 else if (args->clip.boolclip.clip_texcoord)
3226 {
3227 static const char component[4] = {'x', 'y', 'z', 'w'};
3228 unsigned int cur_clip = 0;
3230
3231 for (i = 0; i < gl_info->limits.user_clip_distances; ++i)
3232 {
3233 if (args->clip.boolclip.clipplane_mask & (1u << i))
3234 {
3235 shader_addline(buffer, "DP4 TA.%c, TMP_OUT, state.clip[%u].plane;\n",
3236 component[cur_clip++], i);
3237 }
3238 }
3239 switch (cur_clip)
3240 {
3241 case 0:
3242 shader_addline(buffer, "MOV TA, %s;\n", zero);
3243 break;
3244 case 1:
3245 shader_addline(buffer, "MOV TA.yzw, %s;\n", zero);
3246 break;
3247 case 2:
3248 shader_addline(buffer, "MOV TA.zw, %s;\n", zero);
3249 break;
3250 case 3:
3251 shader_addline(buffer, "MOV TA.w, %s;\n", zero);
3252 break;
3253 }
3254 shader_addline(buffer, "MOV result.texcoord[%u], TA;\n",
3255 args->clip.boolclip.clip_texcoord - 1);
3256 }
3257
3258 /* Write the final position.
3259 *
3260 * OpenGL coordinates specify the center of the pixel while d3d coords specify
3261 * the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
3262 * 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
3263 * contains 1.0 to allow a mad, but arb vs swizzles are too restricted for that.
3264 */
3265 if (!gl_info->supported[ARB_CLIP_CONTROL])
3266 {
3267 shader_addline(buffer, "MUL TA, posFixup, TMP_OUT.w;\n");
3268 shader_addline(buffer, "ADD TMP_OUT.x, TMP_OUT.x, TA.z;\n");
3269 shader_addline(buffer, "MAD TMP_OUT.y, TMP_OUT.y, posFixup.y, TA.w;\n");
3270
3271 /* Z coord [0;1]->[-1;1] mapping, see comment in
3272 * get_projection_matrix() in utils.c. */
3273 if (need_helper_const(shader_data, reg_maps, gl_info))
3274 {
3276 shader_addline(buffer, "MAD TMP_OUT.z, TMP_OUT.z, %s, -TMP_OUT.w;\n", two);
3277 }
3278 else
3279 {
3280 shader_addline(buffer, "ADD TMP_OUT.z, TMP_OUT.z, TMP_OUT.z;\n");
3281 shader_addline(buffer, "ADD TMP_OUT.z, TMP_OUT.z, -TMP_OUT.w;\n");
3282 }
3283 }
3284
3285 shader_addline(buffer, "MOV result.position, TMP_OUT;\n");
3286
3287 priv_ctx->footer_written = TRUE;
3288}
3289
3290static void shader_hw_ret(const struct wined3d_shader_instruction *ins)
3291{
3292 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
3293 struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
3294 const struct wined3d_shader *shader = ins->ctx->shader;
3295 BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
3296
3297 if(priv->target_version == ARB) return;
3298
3299 if(vshader)
3300 {
3301 if (priv->in_main_func) vshader_add_footer(priv, shader->backend_data,
3302 priv->cur_vs_args, ins->ctx->reg_maps, ins->ctx->gl_info, buffer);
3303 }
3304
3305 shader_addline(buffer, "RET;\n");
3306}
3307
3308static void shader_hw_call(const struct wined3d_shader_instruction *ins)
3309{
3310 struct wined3d_string_buffer *buffer = ins->ctx->buffer;
3311 shader_addline(buffer, "CAL l%u;\n", ins->src[0].reg.idx[0].offset);
3312}
3313
3314static BOOL shader_arb_compile(const struct wined3d_gl_info *gl_info, GLenum target, const char *src)
3315{
3316 const char *ptr, *line;
3317 GLint native, pos;
3318
3319 if (TRACE_ON(d3d_shader))
3320 {
3321 ptr = src;
3322 while ((line = get_line(&ptr))) TRACE_(d3d_shader)(" %.*s", (int)(ptr - line), line);
3323 }
3324
3325 GL_EXTCALL(glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(src), src));
3326 checkGLcall("glProgramStringARB()");
3327
3328 if (FIXME_ON(d3d_shader))
3329 {
3330 gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
3331 if (pos != -1)
3332 {
3333 FIXME_(d3d_shader)("Program error at position %d: %s\n\n", pos,
3334 debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
3335 ptr = src;
3336 while ((line = get_line(&ptr))) FIXME_(d3d_shader)(" %.*s", (int)(ptr - line), line);
3337 FIXME_(d3d_shader)("\n");
3338
3339 return FALSE;
3340 }
3341 }
3342
3343 if (WARN_ON(d3d_perf))
3344 {
3345 GL_EXTCALL(glGetProgramivARB(target, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native));
3346 checkGLcall("glGetProgramivARB()");
3347 if (!native)
3348 WARN_(d3d_perf)("Program exceeds native resource limits.\n");
3349 }
3350
3351 return TRUE;
3352}
3353
3354static void arbfp_add_sRGB_correction(struct wined3d_string_buffer *buffer, const char *fragcolor,
3355 const char *tmp1, const char *tmp2, const char *tmp3, const char *tmp4, BOOL condcode)
3356{
3357 /* Perform sRGB write correction. See GLX_EXT_framebuffer_sRGB */
3358
3359 if(condcode)
3360 {
3361 /* Sigh. MOVC CC doesn't work, so use one of the temps as dummy dest */
3362 shader_addline(buffer, "SUBC %s, %s.x, srgb_consts1.x;\n", tmp1, fragcolor);
3363 /* Calculate the > 0.0031308 case */
3364 shader_addline(buffer, "POW %s.x (GE), %s.x, srgb_consts0.x;\n", fragcolor, fragcolor);
3365 shader_addline(buffer, "POW %s.y (GE), %s.y, srgb_consts0.x;\n", fragcolor, fragcolor);
3366 shader_addline(buffer, "POW %s.z (GE), %s.z, srgb_consts0.x;\n", fragcolor, fragcolor);
3367 shader_addline(buffer, "MUL %s.xyz (GE), %s, srgb_consts0.y;\n", fragcolor, fragcolor);
3368 shader_addline(buffer, "SUB %s.xyz (GE), %s, srgb_consts0.z;\n", fragcolor, fragcolor);
3369 /* Calculate the < case */
3370 shader_addline(buffer, "MUL %s.xyz (LT), srgb_consts0.w, %s;\n", fragcolor, fragcolor);
3371 }
3372 else
3373 {
3374 /* Calculate the > 0.0031308 case */
3375 shader_addline(buffer, "POW %s.x, %s.x, srgb_consts0.x;\n", tmp1, fragcolor);
3376 shader_addline(buffer, "POW %s.y, %s.y, srgb_consts0.x;\n", tmp1, fragcolor);
3377 shader_addline(buffer, "POW %s.z, %s.z, srgb_consts0.x;\n", tmp1, fragcolor);
3378 shader_addline(buffer, "MUL %s, %s, srgb_consts0.y;\n", tmp1, tmp1);
3379 shader_addline(buffer, "SUB %s, %s, srgb_consts0.z;\n", tmp1, tmp1);
3380 /* Calculate the < case */
3381 shader_addline(buffer, "MUL %s, srgb_consts0.w, %s;\n", tmp2, fragcolor);
3382 /* Get 1.0 / 0.0 masks for > 0.0031308 and < 0.0031308 */
3383 shader_addline(buffer, "SLT %s, srgb_consts1.x, %s;\n", tmp3, fragcolor);
3384 shader_addline(buffer, "SGE %s, srgb_consts1.x, %s;\n", tmp4, fragcolor);
3385 /* Store the components > 0.0031308 in the destination */
3386 shader_addline(buffer, "MUL %s.xyz, %s, %s;\n", fragcolor, tmp1, tmp3);
3387 /* Add the components that are < 0.0031308 */
3388 shader_addline(buffer, "MAD %s.xyz, %s, %s, %s;\n", fragcolor, tmp2, tmp4, fragcolor);
3389 /* Move everything into result.color at once. Nvidia hardware cannot handle partial
3390 * result.color writes(.rgb first, then .a), or handle overwriting already written
3391 * components. The assembler uses a temporary register in this case, which is usually
3392 * not allocated from one of our registers that were used earlier.
3393 */
3394 }
3395 /* [0.0;1.0] clamping. Not needed, this is done implicitly */
3396}
3397
3399{
3400 const struct wined3d_shader_lconst *constant;
3401
3403 {
3404 if (constant->idx == idx)
3405 {
3406 return constant->value;
3407 }
3408 }
3409 return NULL;
3410}
3411
3412static void init_ps_input(const struct wined3d_shader *shader,
3413 const struct arb_ps_compile_args *args, struct shader_arb_ctx_priv *priv)
3414{
3415 static const char * const texcoords[8] =
3416 {
3417 "fragment.texcoord[0]", "fragment.texcoord[1]", "fragment.texcoord[2]", "fragment.texcoord[3]",
3418 "fragment.texcoord[4]", "fragment.texcoord[5]", "fragment.texcoord[6]", "fragment.texcoord[7]"
3419 };
3420 unsigned int i;
3422 const char *semantic_name;
3424
3425 switch(args->super.vp_mode)
3426 {
3427 case pretransformed:
3428 case fixedfunction:
3429 /* The pixelshader has to collect the varyings on its own. In any case properly load
3430 * color0 and color1. In the case of pretransformed vertices also load texcoords. Set
3431 * other attribs to 0.0.
3432 *
3433 * For fixedfunction this behavior is correct, according to the tests. For pretransformed
3434 * we'd either need a replacement shader that can load other attribs like BINORMAL, or
3435 * load the texcoord attrib pointers to match the pixel shader signature
3436 */
3437 for (i = 0; i < shader->input_signature.element_count; ++i)
3438 {
3439 input = &shader->input_signature.elements[i];
3440 if (!(semantic_name = input->semantic_name))
3441 continue;
3442 semantic_idx = input->semantic_idx;
3443
3445 {
3446 if (!semantic_idx)
3447 priv->ps_input[input->register_idx] = "fragment.color.primary";
3448 else if (semantic_idx == 1)
3449 priv->ps_input[input->register_idx] = "fragment.color.secondary";
3450 else
3451 priv->ps_input[input->register_idx] = "0.0";
3452 }
3453 else if (args->super.vp_mode == fixedfunction)
3454 {
3455 priv->ps_input[input->register_idx] = "0.0";
3456 }
3458 {
3459 if (semantic_idx < 8)
3460 priv->ps_input[input->register_idx] = texcoords[semantic_idx];
3461 else
3462 priv->ps_input[input->register_idx] = "0.0";
3463 }
3465 {
3466 if (!semantic_idx)
3467 priv->ps_input[input->register_idx] = "fragment.fogcoord";
3468 else
3469 priv->ps_input[input->register_idx] = "0.0";
3470 }
3471 else
3472 {
3473 priv->ps_input[input->register_idx] = "0.0";
3474 }
3475
3476 TRACE("v%u, semantic %s%u is %s\n", input->register_idx,
3477 semantic_name, semantic_idx, priv->ps_input[input->register_idx]);
3478 }
3479 break;
3480
3481 case vertexshader:
3482 /* That one is easy. The vertex shaders provide v0-v7 in fragment.texcoord and v8 and v9 in
3483 * fragment.color
3484 */
3485 for(i = 0; i < 8; i++)
3486 {
3487 priv->ps_input[i] = texcoords[i];
3488 }
3489 priv->ps_input[8] = "fragment.color.primary";
3490 priv->ps_input[9] = "fragment.color.secondary";
3491 break;
3492 }
3493}
3494
3496 const char *fragcolor, const char *tmp)
3497{
3498 shader_addline(buffer, "SUB %s.x, state.fog.params.z, fragment.fogcoord.x;\n", tmp);
3499 shader_addline(buffer, "MUL_SAT %s.x, %s.x, state.fog.params.w;\n", tmp, tmp);
3500 shader_addline(buffer, "LRP %s.rgb, %s.x, %s, state.fog.color;\n", fragcolor, tmp, fragcolor);
3501}
3502
3503/* Context activation is done by the caller. */
3505 const struct wined3d_gl_info *gl_info, struct wined3d_string_buffer *buffer,
3506 const struct arb_ps_compile_args *args, struct arb_ps_compiled_shader *compiled)
3507{
3508 const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
3509 GLuint retval;
3510 char fragcolor[16];
3511 DWORD next_local = 0;
3512 struct shader_arb_ctx_priv priv_ctx;
3513 BOOL dcl_td = FALSE;
3514 BOOL want_nv_prog = FALSE;
3515 struct arb_pshader_private *shader_priv = shader->backend_data;
3516 DWORD map;
3517 BOOL custom_linear_fog = FALSE;
3518
3519 char srgbtmp[4][4];
3520 char ftoa_tmp[17];
3521 unsigned int i, found = 0;
3522
3523 for (i = 0, map = reg_maps->temporary; map; map >>= 1, ++i)
3524 {
3525 if (!(map & 1)
3526 || (shader->u.ps.color0_mov && i == shader->u.ps.color0_reg)
3527 || (reg_maps->shader_version.major < 2 && !i))
3528 continue;
3529
3530 sprintf(srgbtmp[found], "R%u", i);
3531 ++found;
3532 if (found == 4) break;
3533 }
3534
3535 switch(found) {
3536 case 0:
3537 sprintf(srgbtmp[0], "TA");
3538 sprintf(srgbtmp[1], "TB");
3539 sprintf(srgbtmp[2], "TC");
3540 sprintf(srgbtmp[3], "TD");
3541 dcl_td = TRUE;
3542 break;
3543 case 1:
3544 sprintf(srgbtmp[1], "TA");
3545 sprintf(srgbtmp[2], "TB");
3546 sprintf(srgbtmp[3], "TC");
3547 break;
3548 case 2:
3549 sprintf(srgbtmp[2], "TA");
3550 sprintf(srgbtmp[3], "TB");
3551 break;
3552 case 3:
3553 sprintf(srgbtmp[3], "TA");
3554 break;
3555 case 4:
3556 break;
3557 }
3558
3559 /* Create the hw ARB shader */
3560 memset(&priv_ctx, 0, sizeof(priv_ctx));
3561 priv_ctx.cur_ps_args = args;
3562 priv_ctx.compiled_fprog = compiled;
3563 priv_ctx.cur_np2fixup_info = &compiled->np2fixup_info;
3564 init_ps_input(shader, args, &priv_ctx);
3565 list_init(&priv_ctx.control_frames);
3566 priv_ctx.ps_post_process = args->super.srgb_correction;
3567
3568 /* Avoid enabling NV_fragment_program* if we do not need it.
3569 *
3570 * Enabling GL_NV_fragment_program_option causes the driver to occupy a temporary register,
3571 * and it slows down the shader execution noticeably(about 5%). Usually our instruction emulation
3572 * is faster than what we gain from using higher native instructions. There are some things though
3573 * that cannot be emulated. In that case enable the extensions.
3574 * If the extension is enabled, instruction handlers that support both ways will use it.
3575 *
3576 * Testing shows no performance difference between OPTION NV_fragment_program2 and NV_fragment_program.
3577 * So enable the best we can get.
3578 */
3579 if(reg_maps->usesdsx || reg_maps->usesdsy || reg_maps->loop_depth > 0 || reg_maps->usestexldd ||
3580 reg_maps->usestexldl || reg_maps->usesfacing || reg_maps->usesifc || reg_maps->usescall)
3581 {
3582 want_nv_prog = TRUE;
3583 }
3584
3585 shader_addline(buffer, "!!ARBfp1.0\n");
3586 if (want_nv_prog && gl_info->supported[NV_FRAGMENT_PROGRAM2])
3587 {
3588 shader_addline(buffer, "OPTION NV_fragment_program2;\n");
3589 priv_ctx.target_version = NV3;
3590 }
3591 else if (want_nv_prog && gl_info->supported[NV_FRAGMENT_PROGRAM_OPTION])
3592 {
3593 shader_addline(buffer, "OPTION NV_fragment_program;\n");
3594 priv_ctx.target_version = NV2;
3595 } else {
3596 if(want_nv_prog)
3597 {
3598 /* This is an error - either we're advertising the wrong shader version, or aren't enforcing some
3599 * limits properly
3600 */
3601 ERR("The shader requires instructions that are not available in plain GL_ARB_fragment_program\n");
3602 ERR("Try GLSL\n");
3603 }
3604 priv_ctx.target_version = ARB;
3605 }
3606
3607 if (reg_maps->rt_mask > 1)
3608 {
3609 shader_addline(buffer, "OPTION ARB_draw_buffers;\n");
3610 }
3611
3612 if (reg_maps->shader_version.major < 3)
3613 {
3614 switch (args->super.fog)
3615 {
3617 break;
3619 if (gl_info->quirks & WINED3D_QUIRK_BROKEN_ARB_FOG)
3620 {
3621 custom_linear_fog = TRUE;
3622 priv_ctx.ps_post_process = TRUE;
3623 break;
3624 }
3625 shader_addline(buffer, "OPTION ARB_fog_linear;\n");
3626 break;
3628 shader_addline(buffer, "OPTION ARB_fog_exp;\n");
3629 break;
3631 shader_addline(buffer, "OPTION ARB_fog_exp2;\n");
3632 break;
3633 }
3634 }
3635
3636 /* For now always declare the temps. At least the Nvidia assembler optimizes completely
3637 * unused temps away(but occupies them for the whole shader if they're used once). Always
3638 * declaring them avoids tricky bookkeeping work
3639 */
3640 shader_addline(buffer, "TEMP TA;\n"); /* Used for modifiers */
3641 shader_addline(buffer, "TEMP TB;\n"); /* Used for modifiers */
3642 shader_addline(buffer, "TEMP TC;\n"); /* Used for modifiers */
3643 if(dcl_td) shader_addline(buffer, "TEMP TD;\n"); /* Used for sRGB writing */
3644 shader_addline(buffer, "PARAM coefdiv = { 0.5, 0.25, 0.125, 0.0625 };\n");
3645 shader_addline(buffer, "PARAM coefmul = { 2, 4, 8, 16 };\n");
3646 wined3d_ftoa(eps, ftoa_tmp);
3647 shader_addline(buffer, "PARAM ps_helper_const = { 0.0, 1.0, %s, 0.0 };\n", ftoa_tmp);
3648
3649 if (reg_maps->shader_version.major < 2)
3650 {
3651 strcpy(fragcolor, "R0");
3652 }
3653 else
3654 {
3655 if (priv_ctx.ps_post_process)
3656 {
3657 if (shader->u.ps.color0_mov)
3658 {
3659 sprintf(fragcolor, "R%u", shader->u.ps.color0_reg);
3660 }
3661 else
3662 {
3663 shader_addline(buffer, "TEMP TMP_COLOR;\n");
3664 strcpy(fragcolor, "TMP_COLOR");
3665 }
3666 } else {
3667 strcpy(fragcolor, "result.color");
3668 }
3669 }
3670
3671 if (args->super.srgb_correction)
3672 {
3673 shader_addline(buffer, "PARAM srgb_consts0 = ");
3675 shader_addline(buffer, ";\n");
3676 shader_addline(buffer, "PARAM srgb_consts1 = ");
3678 shader_addline(buffer, ";\n");
3679 }
3680
3681 /* Base Declarations */
3682 shader_generate_arb_declarations(shader, reg_maps, buffer, gl_info, NULL, &priv_ctx);
3683
3684 for (i = 0, map = reg_maps->bumpmat; map; map >>= 1, ++i)
3685 {
3686 unsigned char bump_const;
3687
3688 if (!(map & 1)) continue;
3689
3690 bump_const = compiled->numbumpenvmatconsts;
3691 compiled->bumpenvmatconst[bump_const].const_num = WINED3D_CONST_NUM_UNUSED;
3692 compiled->bumpenvmatconst[bump_const].texunit = i;
3693 compiled->luminanceconst[bump_const].const_num = WINED3D_CONST_NUM_UNUSED;
3694 compiled->luminanceconst[bump_const].texunit = i;
3695
3696 /* We can fit the constants into the constant limit for sure because texbem, texbeml, bem and beml are only supported
3697 * in 1.x shaders, and GL_ARB_fragment_program has a constant limit of 24 constants. So in the worst case we're loading
3698 * 8 shader constants, 8 bump matrices and 8 luminance parameters and are perfectly fine. (No NP2 fixup on bumpmapped
3699 * textures due to conditional NP2 restrictions)
3700 *
3701 * Use local constants to load the bump env parameters, not program.env. This avoids collisions with d3d constants of
3702 * shaders in newer shader models. Since the bump env parameters have to share their space with NP2 fixup constants,
3703 * their location is shader dependent anyway and they cannot be loaded globally.
3704 */
3705 compiled->bumpenvmatconst[bump_const].const_num = next_local++;
3706 shader_addline(buffer, "PARAM bumpenvmat%d = program.local[%d];\n",
3707 i, compiled->bumpenvmatconst[bump_const].const_num);
3708 compiled->numbumpenvmatconsts = bump_const + 1;
3709
3710 if (!(reg_maps->luminanceparams & (1u << i)))
3711 continue;
3712
3713 compiled->luminanceconst[bump_const].const_num = next_local++;
3714 shader_addline(buffer, "PARAM luminance%d = program.local[%d];\n",
3715 i, compiled->luminanceconst[bump_const].const_num);
3716 }
3717
3718 for (i = 0; i < WINED3D_MAX_CONSTS_I; ++i)
3719 {
3721 if (reg_maps->integer_constants & (1u << i) && priv_ctx.target_version >= NV2)
3722 {
3723 const DWORD *control_values = find_loop_control_values(shader, i);
3724
3725 if(control_values)
3726 {
3727 shader_addline(buffer, "PARAM I%u = {%u, %u, %u, -1};\n", i,
3728 control_values[0], control_values[1], control_values[2]);
3729 }
3730 else
3731 {
3732 compiled->int_consts[i] = next_local;
3733 compiled->num_int_consts++;
3734 shader_addline(buffer, "PARAM I%u = program.local[%u];\n", i, next_local++);
3735 }
3736 }
3737 }
3738
3739 if(reg_maps->vpos || reg_maps->usesdsy)
3740 {
3741 compiled->ycorrection = next_local;
3742 shader_addline(buffer, "PARAM ycorrection = program.local[%u];\n", next_local++);
3743
3744 if(reg_maps->vpos)
3745 {
3746 shader_addline(buffer, "TEMP vpos;\n");
3747 /* ycorrection.x: Backbuffer height(onscreen) or 0(offscreen).
3748 * ycorrection.y: -1.0(onscreen), 1.0(offscreen)
3749 * ycorrection.z: 1.0
3750 * ycorrection.w: 0.0
3751 */
3752 shader_addline(buffer, "MAD vpos, fragment.position, ycorrection.zyww, ycorrection.wxww;\n");
3753 shader_addline(buffer, "FLR vpos.xy, vpos;\n");
3754 }
3755 }
3756 else
3757 {
3759 }
3760
3761 /* Load constants to fixup NP2 texcoords if there are still free constants left:
3762 * Constants (texture dimensions) for the NP2 fixup are loaded as local program parameters. This will consume
3763 * at most 8 (MAX_FRAGMENT_SAMPLERS / 2) parameters, which is highly unlikely, since the application had to
3764 * use 16 NP2 textures at the same time. In case that we run out of constants the fixup is simply not
3765 * applied / activated. This will probably result i