ReactOS  0.4.14-dev-49-gfb4591c
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 
37 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
38 WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
41 
43 {
45 }
46 
48 {
50 }
51 
52 static 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 
124 static 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  {
136  IF,
140  } type;
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 */
167  unsigned char loop_ctrl[WINED3D_MAX_CONSTS_I][3];
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;
199  } boolclip;
201  } clip;
203  union
204  {
205  unsigned char samplers[4];
207  } vertex;
208  unsigned char loop_ctrl[WINED3D_MAX_CONSTS_I][3];
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 */
238  } target_version;
239 
246  struct list record;
249  unsigned int num_loops, loop_depth, num_ifcs;
250  int aL;
252 
253  unsigned int vs_clipplanes;
256 
257  /* For 3.0 vertex shaders */
258  const char *vs_output[MAX_REG_OUTPUT];
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 */
263  const char *ps_input[MAX_REG_INPUT];
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 
313 static 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 */
322 static 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 
328 static 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 
342 static 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. */
360 static 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. */
542 static 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. */
606 static 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 
635 static 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
659  || (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]
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  {
677  memset(priv->vshader_const_dirty, 1,
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 
681  memset(priv->pshader_const_dirty, 1,
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 
715 static 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 
721  shader_arb_load_constants_internal(shader_priv, context, state, ps, vs, FALSE);
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 
916 static 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 
952 static 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 
985 static 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 
996 static 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 
1170  case WINED3DSPR_COLOROUT:
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 
1193  case WINED3DSPR_DEPTHOUT:
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 
1205  case WINED3DSPR_TEXCRDOUT:
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 
1234  case WINED3DSPR_CONSTINT:
1235  sprintf(register_name, "I%u", reg->idx[0].offset);
1236  break;
1237 
1238  case WINED3DSPR_MISCTYPE:
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 
1268 static 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)
1312  masks.sign |= WINED3DSP_WRITEMASK_0;
1313  if (fixup.y_sign_fixup)
1314  masks.sign |= WINED3DSP_WRITEMASK_1;
1315  if (fixup.z_sign_fixup)
1316  masks.sign |= WINED3DSP_WRITEMASK_2;
1317  if (fixup.w_sign_fixup)
1318  masks.sign |= WINED3DSP_WRITEMASK_3;
1319  masks.sign &= dst_mask;
1320 
1321  return masks;
1322 }
1323 
1324 static 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 
1367 static 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 */
1377 
1379  {
1380  FIXME("Unhandled modifier WINED3DSPDM_MSAMPCENTROID\n");
1382  }
1383 
1384  switch(mod)
1385  {
1387  return "H_SAT";
1388 
1389  case WINED3DSPDM_SATURATE:
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 
1409 static 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;
1568  case WINED3DSPSM_BIASNEG:
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;
1574  case WINED3DSPSM_SIGNNEG:
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 
1621 static 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 
1647 static 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;
1663  case WINED3DSPSM_ABS: return WINED3DSPSM_ABSNEG;
1664  case WINED3DSPSM_ABSNEG: return WINED3DSPSM_ABS;
1665  }
1666  FIXME("Unknown modifier %u\n", mod);
1667  return mod;
1668 }
1669 
1670 static 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 
1703 static 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 
1723 static 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 */
1777 static 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 
1824 static void shader_hw_nop(const struct wined3d_shader_instruction *ins) {}
1825 
1827 {
1828  return ((swizzle >> 2 * component) & 0x3) * 0x55;
1829 }
1830 
1831 static 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 
1921 static void pshader_hw_texkill(const struct wined3d_shader_instruction *ins)
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 
1974 static 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 
2053 static void pshader_hw_texcoord(const struct wined3d_shader_instruction *ins)
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 
2076 static void pshader_hw_texreg2ar(const struct wined3d_shader_instruction *ins)
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 
2099 static void pshader_hw_texreg2gb(const struct wined3d_shader_instruction *ins)
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 
2127 static 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 
2346 static void pshader_hw_texdepth(const struct wined3d_shader_instruction *ins)
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 
2379 static void pshader_hw_texdp3tex(const struct wined3d_shader_instruction *ins)
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 
2396 static 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 
2411 static void pshader_hw_texm3x3(const struct wined3d_shader_instruction *ins)
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 
2456 static 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 
2511 static 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;
2529  case WINED3DSPSM_ABSNEG: return WINED3DSPSM_ABS;
2530  }
2531  FIXME("Unknown modifier %u\n", mod);
2532  return mod;
2533 }
2534 
2535 static void shader_hw_scalar_op(const struct wined3d_shader_instruction *ins)
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 
2591 static 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 
2640 static 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 
2662 static 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 
2769 static 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 
2812 static 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 
2828 static 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 
2870 static 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 
2897 static 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 
2924 static 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 
2947 static 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 
2970 static const struct control_frame *find_last_loop(const struct shader_arb_ctx_priv *priv)
2971 {
2972  struct control_frame *control_frame;
2973 
2975  {
2976  if(control_frame->type == LOOP || control_frame->type == REP) return control_frame;
2977  }
2978  ERR("Could not find loop for break\n");
2979  return NULL;
2980 }
2981 
2982 static 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 
2998 static 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 
3030 static 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 
3057 static 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 
3086 static 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 
3106 static 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  {
3116  if(control_frame->had_else)
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 
3132 static 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];
3137  WORD flags = TEX_DERIV;
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 
3145  if (ins->flags & WINED3DSI_TEXLD_BIAS) flags |= TEX_BIAS;
3146 
3147  shader_hw_sample(ins, sampler_idx, reg_dest, reg_src[0], flags, reg_src[1], reg_src[2]);
3148 }
3149 
3150 static 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 
3161  if (ins->flags & WINED3DSI_TEXLD_BIAS) flags |= TEX_BIAS;
3162 
3163  shader_hw_sample(ins, sampler_idx, reg_dest, reg_coord, flags, NULL, NULL);
3164 }
3165 
3166 static 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 
3180 static 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,
3183  struct wined3d_string_buffer *buffer)
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 
3290 static 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 
3308 static 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 
3314 static 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 
3354 static 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 
3412 static 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  {
3720  compiled->int_consts[i] = WINED3D_CONST_NUM_UNUSED;
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 in wrong rendering of the texture, but will save us from
3766  * shader compilation errors and the subsequent errors when drawing with this shader. */
3767  if (priv_ctx.cur_ps_args->super.np2_fixup) {
3768  unsigned char cur_fixup_sampler = 0;
3769 
3770  struct arb_ps_np2fixup_info* const fixup = priv_ctx.cur_np2fixup_info;
3771  const WORD map = priv_ctx.cur_ps_args->super.np2_fixup;
3772  const UINT max_lconsts = gl_info->limits.arb_ps_local_constants;
3773 
3774  fixup->offset = next_local;
3775  fixup->super.active = 0;
3776 
3777  for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
3778  {
3779  if (!(map & (1u << i)))
3780  continue;
3781 
3782  if (fixup->offset + (cur_fixup_sampler >> 1) < max_lconsts)
3783  {
3784  fixup->super.active |= (1u << i);
3785  fixup->super.idx[i] = cur_fixup_sampler++;
3786  }
3787  else
3788  {
3789  FIXME("No free constant found to load NP2 fixup data into shader. "
3790  "Sampling from this texture will probably look wrong.\n");
3791  break;
3792  }
3793  }
3794 
3795  fixup->super.num_consts = (cur_fixup_sampler + 1) >> 1;
3796  if (fixup->super.num_consts) {
3797  shader_addline(buffer, "PARAM np2fixup[%u] = { program.env[%u..%u] };\n",
3798  fixup->super.num_consts, fixup->offset, fixup->super.num_consts + fixup->offset - 1);
3799  }
3800  }
3801 
3802  if (shader_priv->clipplane_emulation != ~0U && args->clip)
3803  {
3804  shader_addline(buffer, "KIL fragment.texcoord[%u];\n", shader_priv->clipplane_emulation);
3805  }
3806 
3807  /* Base Shader Body */
3808  if (FAILED(shader_generate_code(shader, buffer, reg_maps, &priv_ctx, NULL, NULL)))
3809  return 0;
3810 
3811  if(args->super.srgb_correction) {
3812  arbfp_add_sRGB_correction(buffer, fragcolor, srgbtmp[0], srgbtmp[1], srgbtmp[2], srgbtmp[3],
3813  priv_ctx.target_version >= NV2);
3814  }
3815 
3816  if (custom_linear_fog)
3817  arbfp_add_linear_fog(buffer, fragcolor, "TA");
3818 
3819  if(strcmp(fragcolor, "result.color")) {
3820  shader_addline(buffer, "MOV result.color, %s;\n", fragcolor);
3821  }
3822  shader_addline(buffer, "END\n");
3823 
3824  /* TODO: change to resource.glObjectHandle or something like that */
3825  GL_EXTCALL(glGenProgramsARB(1, &retval));
3826 
3827  TRACE("Creating a hw pixel shader, prg=%d\n", retval);
3828  GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, retval));
3829 
3830  TRACE("Created hw pixel shader, prg=%d\n", retval);
3831  if (!shader_arb_compile(gl_info, GL_FRAGMENT_PROGRAM_ARB, buffer->buffer))
3832  return 0;
3833 
3834  return retval;
3835 }
3836 
3837 static int compare_sig(const struct wined3d_shader_signature *sig1, const struct wined3d_shader_signature *sig2)
3838 {
3839  unsigned int i;
3840  int ret;
3841 
3842  if (sig1->element_count != sig2->element_count)
3843  return sig1->element_count < sig2->element_count ? -1 : 1;
3844 
3845  for (i = 0; i < sig1->element_count; ++i)
3846  {
3847  const struct wined3d_shader_signature_element *e1, *e2;
3848 
3849  e1 = &sig1->elements[i];
3850  e2 = &sig2->elements[i];
3851 
3852  if (!e1->semantic_name || !e2->semantic_name)
3853  {
3854  /* Compare pointers, not contents. One string is NULL (element
3855  * does not exist), the other one is not NULL. */
3856  if (e1->semantic_name != e2->semantic_name)
3857  return e1->semantic_name < e2->semantic_name ? -1 : 1;
3858  continue;
3859  }
3860 
3861  if ((ret = strcmp(e1->semantic_name, e2->semantic_name)))
3862  return ret;
3863  if (e1->semantic_idx != e2->semantic_idx)
3864  return e1->semantic_idx < e2->semantic_idx ? -1 : 1;
3865  if (e1->sysval_semantic != e2->sysval_semantic)
3866  return e1->sysval_semantic < e2->sysval_semantic ? -1 : 1;
3867  if (e1->component_type != e2->component_type)
3868  return e1->component_type < e2->component_type ? -1 : 1;
3869  if (e1->register_idx != e2->register_idx)
3870  return e1->register_idx < e2->register_idx ? -1 : 1;
3871  if (e1->mask != e2->mask)
3872  return e1->mask < e2->mask ? -1 : 1;
3873  }
3874  return 0;
3875 }
3876 
3877 static void clone_sig(struct wined3d_shader_signature *new, const struct wined3d_shader_signature *sig)
3878 {
3879  unsigned int i;
3880  char *name;
3881 
3882  new->element_count = sig->element_count;
3883  new->elements = heap_calloc(new->element_count, sizeof(*new->elements));
3884  for (i = 0; i < sig->element_count; ++i)
3885  {
3886  new->elements[i] = sig->elements[i];
3887 
3888  if (!new->elements[i].semantic_name)
3889  continue;
3890 
3891  /* Clone the semantic string */
3892  name = heap_alloc(strlen(sig->elements[i].semantic_name) + 1);
3893  strcpy(name, sig->elements[i].semantic_name);
3894  new->elements[i].semantic_name = name;
3895  }
3896 }
3897 
3899 {
3900  struct wine_rb_entry *entry = wine_rb_get(&priv->signature_tree, sig);
3901  struct ps_signature *found_sig;
3902 
3903  if (entry)
3904  {
3905  found_sig = WINE_RB_ENTRY_VALUE(entry, struct ps_signature, entry);
3906  TRACE("Found existing signature %u\n", found_sig->idx);
3907  return found_sig->idx;
3908  }
3909  found_sig = heap_alloc_zero(sizeof(*found_sig));
3910  clone_sig(&found_sig->sig, sig);
3911  found_sig->idx = priv->ps_sig_number++;
3912  TRACE("New signature stored and assigned number %u\n", found_sig->idx);
3913  if(wine_rb_put(&priv->signature_tree, sig, &found_sig->entry) == -1)
3914  {
3915  ERR("Failed to insert program entry.\n");
3916  }
3917  return found_sig->idx;
3918 }
3919 
3920 static void init_output_registers(const struct wined3d_shader *shader,
3921  const struct wined3d_shader_signature *ps_input_sig,
3922  struct shader_arb_ctx_priv *priv_ctx, struct arb_vs_compiled_shader *compiled)
3923 {
3924  unsigned int i, j;
3925  static const char * const texcoords[8] =
3926  {
3927  "result.texcoord[0]", "result.texcoord[1]", "result.texcoord[2]", "result.texcoord[3]",
3928  "result.texcoord[4]", "result.texcoord[5]", "result.texcoord[6]", "result.texcoord[7]"
3929  };
3930  /* Write generic input varyings 0 to 7 to result.texcoord[], varying 8 to result.color.primary
3931  * and varying 9 to result.color.secondary
3932  */
3933  static const char * const decl_idx_to_string[MAX_REG_INPUT] =
3934  {
3935  "result.texcoord[0]", "result.texcoord[1]", "result.texcoord[2]", "result.texcoord[3]",
3936  "result.texcoord[4]", "result.texcoord[5]", "result.texcoord[6]", "result.texcoord[7]",
3937  "result.color.primary", "result.color.secondary"
3938  };
3939 
3940  if (!ps_input_sig)
3941  {
3942  TRACE("Pixel shader uses builtin varyings\n");
3943  /* Map builtins to builtins */
3944  for(i = 0; i < 8; i++)
3945  {
3946  priv_ctx->texcrd_output[i] = texcoords[i];
3947  }
3948  priv_ctx->color_output[0] = "result.color.primary";
3949  priv_ctx->color_output[1] = "result.color.secondary";
3950  priv_ctx->fog_output = "TMP_FOGCOORD";
3951 
3952  /* Map declared regs to builtins. Use "TA" to /dev/null unread output */
3953  for (i = 0; i < shader->output_signature.element_count; ++i)
3954  {
3955  const struct wined3d_shader_signature_element *output = &shader->output_signature.elements[i];
3956 
3957  if (!output->semantic_name)
3958  continue;
3959 
3961  {
3962  TRACE("o%u is TMP_OUT\n", output->register_idx);
3963  if (!output->semantic_idx)
3964  priv_ctx->vs_output[output->register_idx] = "TMP_OUT";
3965  else
3966  priv_ctx->vs_output[output->register_idx] = "TA";
3967  }
3968  else if (shader_match_semantic(output->semantic_name, WINED3D_DECL_USAGE_PSIZE))
3969  {
3970  TRACE("o%u is result.pointsize\n", output->register_idx);
3971  if (!output->semantic_idx)
3972  priv_ctx->vs_output[output->register_idx] = "result.pointsize";
3973  else
3974  priv_ctx->vs_output[output->register_idx] = "TA";
3975  }
3976  else if (shader_match_semantic(output->semantic_name, WINED3D_DECL_USAGE_COLOR))
3977  {
3978  TRACE("o%u is result.color.?, idx %u\n", output->register_idx, output->semantic_idx);
3979  if (!output->semantic_idx)
3980  priv_ctx->vs_output[output->register_idx] = "result.color.primary";
3981  else if (output->semantic_idx == 1)
3982  priv_ctx->vs_output[output->register_idx] = "result.color.secondary";
3983  else priv_ctx->vs_output[output->register_idx] = "TA";
3984  }
3985  else if (shader_match_semantic(output->semantic_name, WINED3D_DECL_USAGE_TEXCOORD))
3986  {
3987  TRACE("o%u is result.texcoord[%u]\n", output->register_idx, output->semantic_idx);
3988  if (output->semantic_idx >= 8)
3989  priv_ctx->vs_output[output->register_idx] = "TA";
3990  else
3991  priv_ctx->vs_output[output->register_idx] = texcoords[output->semantic_idx];
3992  }
3993  else if (shader_match_semantic(output->semantic_name, WINED3D_DECL_USAGE_FOG))
3994  {
3995  TRACE("o%u is result.fogcoord\n", output->register_idx);
3996  if (output->semantic_idx > 0)
3997  priv_ctx->vs_output[output->register_idx] = "TA";
3998  else
3999  priv_ctx->vs_output[output->register_idx] = "result.fogcoord";
4000  }
4001  else
4002  {
4003  priv_ctx->vs_output[output->register_idx] = "TA";
4004  }
4005  }
4006  return;
4007  }
4008 
4009  TRACE("Pixel shader uses declared varyings\n");
4010 
4011  /* Map builtin to declared. /dev/null the results by default to the TA temp reg */
4012  for(i = 0; i < 8; i++)
4013  {
4014  priv_ctx->texcrd_output[i] = "TA";
4015  }
4016  priv_ctx->color_output[0] = "TA";
4017  priv_ctx->color_output[1] = "TA";
4018  priv_ctx->fog_output = "TA";
4019 
4020  for (i = 0; i < ps_input_sig->element_count; ++i)
4021  {
4022  const struct wined3d_shader_signature_element *input = &ps_input_sig->elements[i];
4023 
4024  if (!input->semantic_name)
4025  continue;
4026 
4027  /* If a declared input register is not written by builtin arguments, don't write to it.
4028  * GL_NV_vertex_program makes sure the input defaults to 0.0, which is correct with D3D
4029  *
4030  * Don't care about POSITION and PSIZE here - this is a builtin vertex shader, position goes
4031  * to TMP_OUT in any case
4032  */
4034  {
4035  if (input->semantic_idx < 8)
4036  priv_ctx->texcrd_output[input->semantic_idx] = decl_idx_to_string[input->register_idx];
4037  }
4038  else if (shader_match_semantic(input->semantic_name, WINED3D_DECL_USAGE_COLOR))
4039  {
4040  if (input->semantic_idx < 2)
4041  priv_ctx->color_output[input->semantic_idx] = decl_idx_to_string[input->register_idx];
4042  }
4043  else if (shader_match_semantic(input->semantic_name, WINED3D_DECL_USAGE_FOG))
4044  {
4045  if (!input->semantic_idx)
4046  priv_ctx->fog_output = decl_idx_to_string[input->register_idx];
4047  }
4048  else
4049  {
4050  continue;
4051  }
4052 
4053  if (!strcmp(decl_idx_to_string[input->register_idx], "result.color.primary")
4054  || !strcmp(decl_idx_to_string[input->register_idx], "result.color.secondary"))
4055  {
4056  compiled->need_color_unclamp = TRUE;
4057  }
4058  }
4059 
4060  /* Map declared to declared */
4061  for (i = 0; i <