git.oblomov.eu Git - wine/blob - dlls/wined3d/arb_program_shader.c

   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  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  26  */
  27
  28 #include "config.h"
  29
  30 #include <math.h>
  31 #include <stdio.h>
  32
  33 #include "wined3d_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  36
  37 #define GLINFO_LOCATION      (*gl_info)
  38
  39 /********************************************************
  40  * ARB_[vertex/fragment]_program helper functions follow
  41  ********************************************************/
  42
  43 /**
  44  * Loads floating point constants into the currently set ARB_vertex/fragment_program.
  45  * When constant_list == NULL, it will load all the constants.
  46  *
  47  * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
  48  *  or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
  49  */
  50 static void shader_arb_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_Info *gl_info, GLuint target_type,
  51         unsigned int max_constants, float* constants, struct list *constant_list) {
  52     constant_entry *constant;
  53     local_constant* lconst;
  54     int i;
  55
  56     if (!constant_list) {
  57         if (TRACE_ON(d3d_shader)) {
  58             for (i = 0; i < max_constants; ++i) {
  59                 TRACE("Loading constants %i: %f, %f, %f, %f\n", i,
  60                         constants[i * 4 + 0], constants[i * 4 + 1],
  61                         constants[i * 4 + 2], constants[i * 4 + 3]);
  62             }
  63         }
  64         for (i = 0; i < max_constants; ++i) {
  65             GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4)));
  66         }
  67         checkGLcall("glProgramEnvParameter4fvARB()");
  68     } else {
  69         if (TRACE_ON(d3d_shader)) {
  70             LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) {
  71                 i = constant->idx;
  72                 TRACE("Loading constants %i: %f, %f, %f, %f\n", i,
  73                         constants[i * 4 + 0], constants[i * 4 + 1],
  74                         constants[i * 4 + 2], constants[i * 4 + 3]);
  75             }
  76         }
  77         LIST_FOR_EACH_ENTRY(constant, constant_list, constant_entry, entry) {
  78             i = constant->idx;
  79             GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, i, constants + (i * 4)));
  80         }
  81         checkGLcall("glProgramEnvParameter4fvARB()");
  82     }
  83
  84     /* Load immediate constants */
  85     if (TRACE_ON(d3d_shader)) {
  86         LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
  87             GLfloat* values = (GLfloat*)lconst->value;
  88             TRACE("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
  89                     values[0], values[1], values[2], values[3]);
  90         }
  91     }
  92     LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
  93         GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, lconst->idx, (GLfloat*)lconst->value));
  94     }
  95     checkGLcall("glProgramEnvParameter4fvARB()");
  96 }
  97
  98 /**
  99  * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
 100  *
 101  * We only support float constants in ARB at the moment, so don't
 102  * worry about the Integers or Booleans
 103  */
 104 void shader_arb_load_constants(
 105     IWineD3DDevice* device,
 106     char usePixelShader,
 107     char useVertexShader) {
 108
 109     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
 110     IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
 111     WineD3D_GL_Info *gl_info = &((IWineD3DImpl*)deviceImpl->wineD3D)->gl_info;
 112
 113     if (useVertexShader) {
 114         IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
 115         IWineD3DVertexShaderImpl* vshader_impl = (IWineD3DVertexShaderImpl*) stateBlock->vertexShader;
 116         IWineD3DVertexDeclarationImpl* vertexDeclaration =
 117             (IWineD3DVertexDeclarationImpl*) vshader_impl->vertexDeclaration;
 118
 119         if (NULL != vertexDeclaration && NULL != vertexDeclaration->constants) {
 120             /* Load DirectX 8 float constants for vertex shader */
 121             shader_arb_load_constantsF(vshader, gl_info, GL_VERTEX_PROGRAM_ARB,
 122                                        GL_LIMITS(vshader_constantsF),
 123                                        vertexDeclaration->constants, NULL);
 124         }
 125
 126         /* Load DirectX 9 float constants for vertex shader */
 127         shader_arb_load_constantsF(vshader, gl_info, GL_VERTEX_PROGRAM_ARB,
 128                                    GL_LIMITS(vshader_constantsF),
 129                                    stateBlock->vertexShaderConstantF,
 130                                    &stateBlock->set_vconstantsF);
 131
 132         /* Upload the position fixup */
 133         GL_EXTCALL(glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, ARB_SHADER_PRIVCONST_POS, deviceImpl->posFixup));
 134     }
 135
 136     if (usePixelShader) {
 137
 138         IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
 139
 140         /* Load DirectX 9 float constants for pixel shader */
 141         shader_arb_load_constantsF(pshader, gl_info, GL_FRAGMENT_PROGRAM_ARB,
 142                                    GL_LIMITS(pshader_constantsF),
 143                                    stateBlock->pixelShaderConstantF,
 144                                    &stateBlock->set_pconstantsF);
 145     }
 146 }
 147
 148 /* Generate the variable & register declarations for the ARB_vertex_program output target */
 149 void shader_generate_arb_declarations(
 150     IWineD3DBaseShader *iface,
 151     shader_reg_maps* reg_maps,
 152     SHADER_BUFFER* buffer,
 153     WineD3D_GL_Info* gl_info) {
 154
 155     IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
 156     DWORD i;
 157     char pshader = shader_is_pshader_version(This->baseShader.hex_version);
 158     unsigned max_constantsF = min(This->baseShader.limits.constant_float,
 159             (pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
 160
 161     /* Temporary Output register */
 162     shader_addline(buffer, "TEMP TMP_OUT;\n");
 163
 164     for(i = 0; i < This->baseShader.limits.temporary; i++) {
 165         if (reg_maps->temporary[i])
 166             shader_addline(buffer, "TEMP R%u;\n", i);
 167     }
 168
 169     for (i = 0; i < This->baseShader.limits.address; i++) {
 170         if (reg_maps->address[i])
 171             shader_addline(buffer, "ADDRESS A%d;\n", i);
 172     }
 173
 174     for(i = 0; i < This->baseShader.limits.texcoord; i++) {
 175         if (reg_maps->texcoord[i])
 176             shader_addline(buffer,"TEMP T%u;\n", i);
 177     }
 178
 179     /* Texture coordinate registers must be pre-loaded */
 180     for (i = 0; i < This->baseShader.limits.texcoord; i++) {
 181         if (reg_maps->texcoord[i])
 182             shader_addline(buffer, "MOV T%u, fragment.texcoord[%u];\n", i, i);
 183     }
 184
 185     /* Need to PARAM the environment parameters (constants) so we can use relative addressing */
 186     shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
 187                    max_constantsF, max_constantsF - 1);
 188 }
 189
 190 static const char * const shift_tab[] = {
 191     "dummy",     /*  0 (none) */
 192     "coefmul.x", /*  1 (x2)   */
 193     "coefmul.y", /*  2 (x4)   */
 194     "coefmul.z", /*  3 (x8)   */
 195     "coefmul.w", /*  4 (x16)  */
 196     "dummy",     /*  5 (x32)  */
 197     "dummy",     /*  6 (x64)  */
 198     "dummy",     /*  7 (x128) */
 199     "dummy",     /*  8 (d256) */
 200     "dummy",     /*  9 (d128) */
 201     "dummy",     /* 10 (d64)  */
 202     "dummy",     /* 11 (d32)  */
 203     "coefdiv.w", /* 12 (d16)  */
 204     "coefdiv.z", /* 13 (d8)   */
 205     "coefdiv.y", /* 14 (d4)   */
 206     "coefdiv.x"  /* 15 (d2)   */
 207 };
 208
 209 static void shader_arb_get_write_mask(const DWORD param, char *write_mask) {
 210     char *ptr = write_mask;
 211
 212     if ((param & WINED3DSP_WRITEMASK_ALL) != WINED3DSP_WRITEMASK_ALL) {
 213         *ptr++ = '.';
 214         if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
 215         if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
 216         if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
 217         if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
 218     }
 219
 220     *ptr = '\0';
 221 }
 222
 223 static void shader_arb_get_swizzle(const DWORD param, BOOL fixup, char *swizzle_str) {
 224     /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
 225      * but addressed as "rgba". To fix this we need to swap the register's x
 226      * and z components. */
 227     const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
 228     char *ptr = swizzle_str;
 229
 230     /* swizzle bits fields: wwzzyyxx */
 231     DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
 232     DWORD swizzle_x = swizzle & 0x03;
 233     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 234     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 235     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 236
 237     /* If the swizzle is the default swizzle (ie, "xyzw"), we don't need to
 238      * generate a swizzle string. Unless we need to our own swizzling. */
 239     if ((WINED3DSP_NOSWIZZLE >> WINED3DSP_SWIZZLE_SHIFT) != swizzle || fixup) {
 240         *ptr++ = '.';
 241         if (swizzle_x == swizzle_y && swizzle_x == swizzle_z && swizzle_x == swizzle_w) {
 242             *ptr++ = swizzle_chars[swizzle_x];
 243         } else {
 244             *ptr++ = swizzle_chars[swizzle_x];
 245             *ptr++ = swizzle_chars[swizzle_y];
 246             *ptr++ = swizzle_chars[swizzle_z];
 247             *ptr++ = swizzle_chars[swizzle_w];
 248         }
 249     }
 250
 251     *ptr = '\0';
 252 }
 253
 254 static void pshader_get_register_name(
 255     const DWORD param, char* regstr) {
 256
 257     DWORD reg = param & WINED3DSP_REGNUM_MASK;
 258     DWORD regtype = shader_get_regtype(param);
 259
 260     switch (regtype) {
 261     case WINED3DSPR_TEMP:
 262         sprintf(regstr, "R%u", reg);
 263     break;
 264     case WINED3DSPR_INPUT:
 265         if (reg==0) {
 266             strcpy(regstr, "fragment.color.primary");
 267         } else {
 268             strcpy(regstr, "fragment.color.secondary");
 269         }
 270     break;
 271     case WINED3DSPR_CONST:
 272         sprintf(regstr, "C[%u]", reg);
 273     break;
 274     case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
 275         sprintf(regstr,"T%u", reg);
 276     break;
 277     case WINED3DSPR_COLOROUT:
 278         if (reg == 0)
 279             sprintf(regstr, "result.color");
 280         else {
 281             /* TODO: See GL_ARB_draw_buffers */
 282             FIXME("Unsupported write to render target %u\n", reg);
 283             sprintf(regstr, "unsupported_register");
 284         }
 285     break;
 286     case WINED3DSPR_DEPTHOUT:
 287         sprintf(regstr, "result.depth");
 288     break;
 289     case WINED3DSPR_ATTROUT:
 290         sprintf(regstr, "oD[%u]", reg);
 291     break;
 292     case WINED3DSPR_TEXCRDOUT:
 293         sprintf(regstr, "oT[%u]", reg);
 294     break;
 295     default:
 296         FIXME("Unhandled register name Type(%d)\n", regtype);
 297         sprintf(regstr, "unrecognized_register");
 298     break;
 299     }
 300 }
 301
 302 /* TODO: merge with pixel shader */
 303 static void vshader_program_add_param(SHADER_OPCODE_ARG *arg, const DWORD param, BOOL is_input, char *hwLine) {
 304
 305   IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl*) arg->shader;
 306
 307   /* oPos, oFog and oPts in D3D */
 308   static const char * const hwrastout_reg_names[] = { "TMP_OUT", "TMP_FOG", "result.pointsize" };
 309
 310   DWORD reg = param & WINED3DSP_REGNUM_MASK;
 311   DWORD regtype = shader_get_regtype(param);
 312   char  tmpReg[255];
 313   BOOL is_color = FALSE;
 314
 315   if ((param & WINED3DSP_SRCMOD_MASK) == WINED3DSPSM_NEG) {
 316       strcat(hwLine, " -");
 317   } else {
 318       strcat(hwLine, " ");
 319   }
 320
 321   switch (regtype) {
 322   case WINED3DSPR_TEMP:
 323     sprintf(tmpReg, "R%u", reg);
 324     strcat(hwLine, tmpReg);
 325     break;
 326   case WINED3DSPR_INPUT:
 327
 328     if (vshader_input_is_color((IWineD3DVertexShader*) This, reg))
 329         is_color = TRUE;
 330
 331     sprintf(tmpReg, "vertex.attrib[%u]", reg);
 332     strcat(hwLine, tmpReg);
 333     break;
 334   case WINED3DSPR_CONST:
 335     sprintf(tmpReg, "C[%s%u]", (param & WINED3DSHADER_ADDRMODE_RELATIVE) ? "A0.x + " : "", reg);
 336     strcat(hwLine, tmpReg);
 337     break;
 338   case WINED3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 339     sprintf(tmpReg, "A%u", reg);
 340     strcat(hwLine, tmpReg);
 341     break;
 342   case WINED3DSPR_RASTOUT:
 343     sprintf(tmpReg, "%s", hwrastout_reg_names[reg]);
 344     strcat(hwLine, tmpReg);
 345     break;
 346   case WINED3DSPR_ATTROUT:
 347     if (reg==0) {
 348        strcat(hwLine, "result.color.primary");
 349     } else {
 350        strcat(hwLine, "result.color.secondary");
 351     }
 352     break;
 353   case WINED3DSPR_TEXCRDOUT:
 354     sprintf(tmpReg, "result.texcoord[%u]", reg);
 355     strcat(hwLine, tmpReg);
 356     break;
 357   default:
 358     FIXME("Unknown reg type %d %d\n", regtype, reg);
 359     strcat(hwLine, "unrecognized_register");
 360     break;
 361   }
 362
 363   if (!is_input) {
 364     char write_mask[6];
 365     shader_arb_get_write_mask(param, write_mask);
 366     strcat(hwLine, write_mask);
 367   } else {
 368     char swizzle[6];
 369     shader_arb_get_swizzle(param, is_color, swizzle);
 370     strcat(hwLine, swizzle);
 371   }
 372 }
 373
 374 static void shader_hw_sample(SHADER_OPCODE_ARG* arg, DWORD sampler_idx, const char *dst_str, const char *coord_reg) {
 375     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 376     IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
 377
 378     SHADER_BUFFER* buffer = arg->buffer;
 379     DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
 380     const char *tex_type;
 381
 382     switch(sampler_type) {
 383         case WINED3DSTT_1D:
 384             tex_type = "1D";
 385             break;
 386
 387         case WINED3DSTT_2D:
 388             tex_type = "2D";
 389             break;
 390
 391         case WINED3DSTT_VOLUME:
 392             tex_type = "3D";
 393             break;
 394
 395         case WINED3DSTT_CUBE:
 396             tex_type = "CUBE";
 397             break;
 398
 399         default:
 400             ERR("Unexpected texture type %d\n", sampler_type);
 401             tex_type = "";
 402     }
 403
 404     if (deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS] & WINED3DTTFF_PROJECTED) {
 405         shader_addline(buffer, "TXP %s, %s, texture[%u], %s;\n", dst_str, coord_reg, sampler_idx, tex_type);
 406     } else {
 407         shader_addline(buffer, "TEX %s, %s, texture[%u], %s;\n", dst_str, coord_reg, sampler_idx, tex_type);
 408     }
 409 }
 410
 411
 412 static void pshader_gen_input_modifier_line (
 413     SHADER_BUFFER* buffer,
 414     const DWORD instr,
 415     int tmpreg,
 416     char *outregstr) {
 417
 418     /* Generate a line that does the input modifier computation and return the input register to use */
 419     char regstr[256];
 420     char swzstr[20];
 421     int insert_line;
 422
 423     /* Assume a new line will be added */
 424     insert_line = 1;
 425
 426     /* Get register name */
 427     pshader_get_register_name(instr, regstr);
 428     shader_arb_get_swizzle(instr, FALSE, swzstr);
 429
 430     switch (instr & WINED3DSP_SRCMOD_MASK) {
 431     case WINED3DSPSM_NONE:
 432         sprintf(outregstr, "%s%s", regstr, swzstr);
 433         insert_line = 0;
 434         break;
 435     case WINED3DSPSM_NEG:
 436         sprintf(outregstr, "-%s%s", regstr, swzstr);
 437         insert_line = 0;
 438         break;
 439     case WINED3DSPSM_BIAS:
 440         shader_addline(buffer, "ADD T%c, %s, -coefdiv.x;\n", 'A' + tmpreg, regstr);
 441         break;
 442     case WINED3DSPSM_BIASNEG:
 443         shader_addline(buffer, "ADD T%c, -%s, coefdiv.x;\n", 'A' + tmpreg, regstr);
 444         break;
 445     case WINED3DSPSM_SIGN:
 446         shader_addline(buffer, "MAD T%c, %s, coefmul.x, -one.x;\n", 'A' + tmpreg, regstr);
 447         break;
 448     case WINED3DSPSM_SIGNNEG:
 449         shader_addline(buffer, "MAD T%c, %s, -coefmul.x, one.x;\n", 'A' + tmpreg, regstr);
 450         break;
 451     case WINED3DSPSM_COMP:
 452         shader_addline(buffer, "SUB T%c, one.x, %s;\n", 'A' + tmpreg, regstr);
 453         break;
 454     case WINED3DSPSM_X2:
 455         shader_addline(buffer, "ADD T%c, %s, %s;\n", 'A' + tmpreg, regstr, regstr);
 456         break;
 457     case WINED3DSPSM_X2NEG:
 458         shader_addline(buffer, "ADD T%c, -%s, -%s;\n", 'A' + tmpreg, regstr, regstr);
 459         break;
 460     case WINED3DSPSM_DZ:
 461         shader_addline(buffer, "RCP T%c, %s.z;\n", 'A' + tmpreg, regstr);
 462         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
 463         break;
 464     case WINED3DSPSM_DW:
 465         shader_addline(buffer, "RCP T%c, %s.w;\n", 'A' + tmpreg, regstr);
 466         shader_addline(buffer, "MUL T%c, %s, T%c;\n", 'A' + tmpreg, regstr, 'A' + tmpreg);
 467         break;
 468     default:
 469         sprintf(outregstr, "%s%s", regstr, swzstr);
 470         insert_line = 0;
 471     }
 472
 473     /* Return modified or original register, with swizzle */
 474     if (insert_line)
 475         sprintf(outregstr, "T%c%s", 'A' + tmpreg, swzstr);
 476 }
 477
 478 inline static void pshader_gen_output_modifier_line(
 479     SHADER_BUFFER* buffer,
 480     int saturate,
 481     char *write_mask,
 482     int shift,
 483     char *regstr) {
 484
 485     /* Generate a line that does the output modifier computation */
 486     shader_addline(buffer, "MUL%s %s%s, %s, %s;\n", saturate ? "_SAT" : "",
 487         regstr, write_mask, regstr, shift_tab[shift]);
 488 }
 489
 490 void pshader_hw_cnd(SHADER_OPCODE_ARG* arg) {
 491
 492     SHADER_BUFFER* buffer = arg->buffer;
 493     char dst_wmask[20];
 494     char dst_name[50];
 495     char src_name[3][50];
 496
 497     /* FIXME: support output modifiers */
 498
 499     /* Handle output register */
 500     pshader_get_register_name(arg->dst, dst_name);
 501     shader_arb_get_write_mask(arg->dst, dst_wmask);
 502     strcat(dst_name, dst_wmask);
 503
 504     /* Generate input register names (with modifiers) */
 505     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src_name[0]);
 506     pshader_gen_input_modifier_line(buffer, arg->src[1], 1, src_name[1]);
 507     pshader_gen_input_modifier_line(buffer, arg->src[2], 2, src_name[2]);
 508
 509     shader_addline(buffer, "ADD TMP, -%s, coefdiv.x;\n", src_name[0]);
 510     shader_addline(buffer, "CMP %s, TMP, %s, %s;\n", dst_name, src_name[1], src_name[2]);
 511 }
 512
 513 void pshader_hw_cmp(SHADER_OPCODE_ARG* arg) {
 514
 515     SHADER_BUFFER* buffer = arg->buffer;
 516     char dst_wmask[20];
 517     char dst_name[50];
 518     char src_name[3][50];
 519
 520     /* FIXME: support output modifiers */
 521
 522     /* Handle output register */
 523     pshader_get_register_name(arg->dst, dst_name);
 524     shader_arb_get_write_mask(arg->dst, dst_wmask);
 525     strcat(dst_name, dst_wmask);
 526
 527     /* Generate input register names (with modifiers) */
 528     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src_name[0]);
 529     pshader_gen_input_modifier_line(buffer, arg->src[1], 1, src_name[1]);
 530     pshader_gen_input_modifier_line(buffer, arg->src[2], 2, src_name[2]);
 531
 532     shader_addline(buffer, "CMP %s, %s, %s, %s;\n", dst_name,
 533         src_name[0], src_name[2], src_name[1]);
 534 }
 535
 536 /* Map the opcode 1-to-1 to the GL code */
 537 void pshader_hw_map2gl(SHADER_OPCODE_ARG* arg) {
 538
 539      CONST SHADER_OPCODE* curOpcode = arg->opcode;
 540      SHADER_BUFFER* buffer = arg->buffer;
 541      DWORD dst = arg->dst;
 542      DWORD* src = arg->src;
 543
 544      unsigned int i;
 545      char tmpLine[256];
 546
 547      /* Output token related */
 548      char output_rname[256];
 549      char output_wmask[20];
 550      BOOL saturate = FALSE;
 551      BOOL centroid = FALSE;
 552      BOOL partialprecision = FALSE;
 553      DWORD shift;
 554
 555      strcpy(tmpLine, curOpcode->glname);
 556
 557      /* Process modifiers */
 558      if (0 != (dst & WINED3DSP_DSTMOD_MASK)) {
 559          DWORD mask = dst & WINED3DSP_DSTMOD_MASK;
 560
 561          saturate = mask & WINED3DSPDM_SATURATE;
 562          centroid = mask & WINED3DSPDM_MSAMPCENTROID;
 563          partialprecision = mask & WINED3DSPDM_PARTIALPRECISION;
 564          mask &= ~(WINED3DSPDM_MSAMPCENTROID | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_SATURATE);
 565          if (mask)
 566             FIXME("Unrecognized modifier(0x%#x)\n", mask >> WINED3DSP_DSTMOD_SHIFT);
 567
 568          if (centroid)
 569              FIXME("Unhandled modifier(0x%#x)\n", mask >> WINED3DSP_DSTMOD_SHIFT);
 570      }
 571      shift = (dst & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
 572
 573       /* Generate input and output registers */
 574       if (curOpcode->num_params > 0) {
 575           char operands[4][100];
 576
 577           /* Generate input register names (with modifiers) */
 578           for (i = 1; i < curOpcode->num_params; ++i)
 579               pshader_gen_input_modifier_line(buffer, src[i-1], i-1, operands[i]);
 580
 581           /* Handle output register */
 582           pshader_get_register_name(dst, output_rname);
 583           strcpy(operands[0], output_rname);
 584           shader_arb_get_write_mask(dst, output_wmask);
 585           strcat(operands[0], output_wmask);
 586
 587           if (saturate && (shift == 0))
 588              strcat(tmpLine, "_SAT");
 589           strcat(tmpLine, " ");
 590           strcat(tmpLine, operands[0]);
 591           for (i = 1; i < curOpcode->num_params; i++) {
 592               strcat(tmpLine, ", ");
 593               strcat(tmpLine, operands[i]);
 594           }
 595           strcat(tmpLine,";\n");
 596           shader_addline(buffer, tmpLine);
 597
 598           /* A shift requires another line. */
 599           if (shift != 0)
 600               pshader_gen_output_modifier_line(buffer, saturate, output_wmask, shift, output_rname);
 601       }
 602 }
 603
 604 void pshader_hw_tex(SHADER_OPCODE_ARG* arg) {
 605
 606     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 607
 608     DWORD dst = arg->dst;
 609     DWORD* src = arg->src;
 610     SHADER_BUFFER* buffer = arg->buffer;
 611     DWORD hex_version = This->baseShader.hex_version;
 612
 613     char reg_dest[40];
 614     char reg_coord[40];
 615     DWORD reg_dest_code;
 616     DWORD reg_sampler_code;
 617
 618     /* All versions have a destination register */
 619     reg_dest_code = dst & WINED3DSP_REGNUM_MASK;
 620     pshader_get_register_name(dst, reg_dest);
 621
 622     /* 1.0-1.3: Use destination register as coordinate source.
 623        1.4+: Use provided coordinate source register. */
 624    if (hex_version < WINED3DPS_VERSION(1,4))
 625       strcpy(reg_coord, reg_dest);
 626    else
 627       pshader_gen_input_modifier_line(buffer, src[0], 0, reg_coord);
 628
 629   /* 1.0-1.4: Use destination register number as texture code.
 630      2.0+: Use provided sampler number as texure code. */
 631   if (hex_version < WINED3DPS_VERSION(2,0))
 632      reg_sampler_code = reg_dest_code;
 633   else
 634      reg_sampler_code = src[1] & WINED3DSP_REGNUM_MASK;
 635
 636   shader_hw_sample(arg, reg_sampler_code, reg_dest, reg_coord);
 637 }
 638
 639 void pshader_hw_texcoord(SHADER_OPCODE_ARG* arg) {
 640
 641     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 642     DWORD dst = arg->dst;
 643     DWORD* src = arg->src;
 644     SHADER_BUFFER* buffer = arg->buffer;
 645     DWORD hex_version = This->baseShader.hex_version;
 646
 647     char tmp[20];
 648     shader_arb_get_write_mask(dst, tmp);
 649     if (hex_version != WINED3DPS_VERSION(1,4)) {
 650         DWORD reg = dst & WINED3DSP_REGNUM_MASK;
 651         shader_addline(buffer, "MOV_SAT T%u%s, fragment.texcoord[%u];\n", reg, tmp, reg);
 652     } else {
 653         DWORD reg1 = dst & WINED3DSP_REGNUM_MASK;
 654         DWORD reg2 = src[0] & WINED3DSP_REGNUM_MASK;
 655         shader_addline(buffer, "MOV R%u%s, fragment.texcoord[%u];\n", reg1, tmp, reg2);
 656    }
 657 }
 658
 659 void pshader_hw_texreg2ar(SHADER_OPCODE_ARG* arg) {
 660
 661      SHADER_BUFFER* buffer = arg->buffer;
 662
 663      DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
 664      DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
 665      char dst_str[8];
 666
 667      sprintf(dst_str, "T%u", reg1);
 668      shader_addline(buffer, "MOV TMP.r, T%u.a;\n", reg2);
 669      shader_addline(buffer, "MOV TMP.g, T%u.r;\n", reg2);
 670      shader_hw_sample(arg, reg1, dst_str, "TMP");
 671 }
 672
 673 void pshader_hw_texreg2gb(SHADER_OPCODE_ARG* arg) {
 674
 675      SHADER_BUFFER* buffer = arg->buffer;
 676
 677      DWORD reg1 = arg->dst & WINED3DSP_REGNUM_MASK;
 678      DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
 679      char dst_str[8];
 680
 681      sprintf(dst_str, "T%u", reg1);
 682      shader_addline(buffer, "MOV TMP.r, T%u.g;\n", reg2);
 683      shader_addline(buffer, "MOV TMP.g, T%u.b;\n", reg2);
 684      shader_hw_sample(arg, reg1, dst_str, "TMP");
 685 }
 686
 687 void pshader_hw_texbem(SHADER_OPCODE_ARG* arg) {
 688
 689      SHADER_BUFFER* buffer = arg->buffer;
 690      DWORD reg1 = arg->dst  & WINED3DSP_REGNUM_MASK;
 691      DWORD reg2 = arg->src[0] & WINED3DSP_REGNUM_MASK;
 692      char dst_str[8];
 693
 694      /* FIXME: Should apply the BUMPMAPENV matrix */
 695      sprintf(dst_str, "T%u", reg1);
 696      shader_addline(buffer, "ADD TMP.rg, fragment.texcoord[%u], T%u;\n", reg1, reg2);
 697      shader_hw_sample(arg, reg1, dst_str, "TMP");
 698 }
 699
 700 void pshader_hw_texm3x2pad(SHADER_OPCODE_ARG* arg) {
 701
 702     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 703     SHADER_BUFFER* buffer = arg->buffer;
 704     char src0_name[50];
 705
 706     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 707     shader_addline(buffer, "DP3 TMP.x, T%u, %s;\n", reg, src0_name);
 708 }
 709
 710 void pshader_hw_texm3x2tex(SHADER_OPCODE_ARG* arg) {
 711
 712     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 713     SHADER_BUFFER* buffer = arg->buffer;
 714     char dst_str[8];
 715     char src0_name[50];
 716
 717     sprintf(dst_str, "T%u", reg);
 718     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 719     shader_addline(buffer, "DP3 TMP.y, T%u, %s;\n", reg, src0_name);
 720     shader_hw_sample(arg, reg, dst_str, "TMP");
 721 }
 722
 723 void pshader_hw_texm3x3pad(SHADER_OPCODE_ARG* arg) {
 724
 725     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 726     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 727     SHADER_BUFFER* buffer = arg->buffer;
 728     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 729     char src0_name[50];
 730
 731     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 732     shader_addline(buffer, "DP3 TMP.%c, T%u, %s;\n", 'x' + current_state->current_row, reg, src0_name);
 733     current_state->texcoord_w[current_state->current_row++] = reg;
 734 }
 735
 736 void pshader_hw_texm3x3tex(SHADER_OPCODE_ARG* arg) {
 737
 738     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 739     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 740     SHADER_BUFFER* buffer = arg->buffer;
 741     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 742     char dst_str[8];
 743     char src0_name[50];
 744
 745     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 746     shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
 747
 748     /* Sample the texture using the calculated coordinates */
 749     sprintf(dst_str, "T%u", reg);
 750     shader_hw_sample(arg, reg, dst_str, "TMP");
 751     current_state->current_row = 0;
 752 }
 753
 754 void pshader_hw_texm3x3vspec(SHADER_OPCODE_ARG* arg) {
 755
 756     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 757     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 758     SHADER_BUFFER* buffer = arg->buffer;
 759     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 760     char dst_str[8];
 761     char src0_name[50];
 762
 763     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 764     shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
 765
 766     /* Construct the eye-ray vector from w coordinates */
 767     shader_addline(buffer, "MOV TMP2.x, fragment.texcoord[%u].w;\n", current_state->texcoord_w[0]);
 768     shader_addline(buffer, "MOV TMP2.y, fragment.texcoord[%u].w;\n", current_state->texcoord_w[1]);
 769     shader_addline(buffer, "MOV TMP2.z, fragment.texcoord[%u].w;\n", reg);
 770
 771     /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
 772     shader_addline(buffer, "DP3 TMP.w, TMP, TMP2;\n");
 773     shader_addline(buffer, "MUL TMP, TMP.w, TMP;\n");
 774     shader_addline(buffer, "MAD TMP, coefmul.x, TMP, -TMP2;\n");
 775
 776     /* Sample the texture using the calculated coordinates */
 777     sprintf(dst_str, "T%u", reg);
 778     shader_hw_sample(arg, reg, dst_str, "TMP");
 779     current_state->current_row = 0;
 780 }
 781
 782 void pshader_hw_texm3x3spec(SHADER_OPCODE_ARG* arg) {
 783
 784     IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
 785     DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
 786     DWORD reg3 = arg->src[1] & WINED3DSP_REGNUM_MASK;
 787     SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
 788     SHADER_BUFFER* buffer = arg->buffer;
 789     char dst_str[8];
 790     char src0_name[50];
 791
 792     pshader_gen_input_modifier_line(buffer, arg->src[0], 0, src0_name);
 793     shader_addline(buffer, "DP3 TMP.z, T%u, %s;\n", reg, src0_name);
 794
 795     /* Calculate reflection vector (Assume normal is normalized): RF = 2*(N.E)*N -E */
 796     shader_addline(buffer, "DP3 TMP.w, TMP, C[%u];\n", reg3);
 797     shader_addline(buffer, "MUL TMP, TMP.w, TMP;\n");
 798     shader_addline(buffer, "MAD TMP, coefmul.x, TMP, -C[%u];\n", reg3);
 799
 800     /* Sample the texture using the calculated coordinates */
 801     sprintf(dst_str, "T%u", reg);
 802     shader_hw_sample(arg, reg, dst_str, "TMP");
 803     current_state->current_row = 0;
 804 }
 805
 806 /** Handles transforming all WINED3DSIO_M?x? opcodes for
 807     Vertex shaders to ARB_vertex_program codes */
 808 void vshader_hw_mnxn(SHADER_OPCODE_ARG* arg) {
 809
 810     int i;
 811     int nComponents = 0;
 812     SHADER_OPCODE_ARG tmpArg;
 813
 814     memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
 815
 816     /* Set constants for the temporary argument */
 817     tmpArg.shader      = arg->shader;
 818     tmpArg.buffer      = arg->buffer;
 819     tmpArg.src[0]      = arg->src[0];
 820     tmpArg.src_addr[0] = arg->src_addr[0];
 821     tmpArg.src_addr[1] = arg->src_addr[1];
 822     tmpArg.reg_maps = arg->reg_maps;
 823
 824     switch(arg->opcode->opcode) {
 825     case WINED3DSIO_M4x4:
 826         nComponents = 4;
 827         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
 828         break;
 829     case WINED3DSIO_M4x3:
 830         nComponents = 3;
 831         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
 832         break;
 833     case WINED3DSIO_M3x4:
 834         nComponents = 4;
 835         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
 836         break;
 837     case WINED3DSIO_M3x3:
 838         nComponents = 3;
 839         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
 840         break;
 841     case WINED3DSIO_M3x2:
 842         nComponents = 2;
 843         tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
 844         break;
 845     default:
 846         break;
 847     }
 848
 849     for (i = 0; i < nComponents; i++) {
 850         tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
 851         tmpArg.src[1] = arg->src[1]+i;
 852         vshader_hw_map2gl(&tmpArg);
 853     }
 854 }
 855
 856 /* TODO: merge with pixel shader */
 857 /* Map the opcode 1-to-1 to the GL code */
 858 void vshader_hw_map2gl(SHADER_OPCODE_ARG* arg) {
 859
 860     CONST SHADER_OPCODE* curOpcode = arg->opcode;
 861     SHADER_BUFFER* buffer = arg->buffer;
 862     DWORD dst = arg->dst;
 863     DWORD* src = arg->src;
 864
 865     DWORD dst_regtype = shader_get_regtype(dst);
 866     char tmpLine[256];
 867     unsigned int i;
 868
 869     if ((curOpcode->opcode == WINED3DSIO_MOV && dst_regtype == WINED3DSPR_ADDR) || curOpcode->opcode == WINED3DSIO_MOVA)
 870         strcpy(tmpLine, "ARL");
 871     else
 872         strcpy(tmpLine, curOpcode->glname);
 873
 874     if (curOpcode->num_params > 0) {
 875         vshader_program_add_param(arg, dst, FALSE, tmpLine);
 876         for (i = 1; i < curOpcode->num_params; ++i) {
 877            strcat(tmpLine, ",");
 878            vshader_program_add_param(arg, src[i-1], TRUE, tmpLine);
 879         }
 880     }
 881    shader_addline(buffer, "%s;\n", tmpLine);
 882 }
 883
 884 static GLuint create_arb_blt_vertex_program(WineD3D_GL_Info *gl_info) {
 885     GLuint program_id = 0;
 886     const char *blt_vprogram =
 887         "!!ARBvp1.0\n"
 888         "PARAM c[1] = { { 1, 0.5 } };\n"
 889         "MOV result.position, vertex.position;\n"
 890         "MOV result.color, c[0].x;\n"
 891         "MAD result.texcoord[0].y, -vertex.position, c[0], c[0];\n"
 892         "MAD result.texcoord[0].x, vertex.position, c[0].y, c[0].y;\n"
 893         "END\n";
 894
 895     GL_EXTCALL(glGenProgramsARB(1, &program_id));
 896     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, program_id));
 897     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_vprogram), blt_vprogram));
 898
 899     if (glGetError() == GL_INVALID_OPERATION) {
 900         GLint pos;
 901         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
 902         FIXME("Vertex program error at position %d: %s\n", pos,
 903             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
 904     }
 905
 906     return program_id;
 907 }
 908
 909 static GLuint create_arb_blt_fragment_program(WineD3D_GL_Info *gl_info) {
 910     GLuint program_id = 0;
 911     const char *blt_fprogram =
 912         "!!ARBfp1.0\n"
 913         "TEMP R0;\n"
 914         "TEX R0.x, fragment.texcoord[0], texture[0], 2D;\n"
 915         "MOV result.depth.z, R0.x;\n"
 916         "END\n";
 917
 918     GL_EXTCALL(glGenProgramsARB(1, &program_id));
 919     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program_id));
 920     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_fprogram), blt_fprogram));
 921
 922     if (glGetError() == GL_INVALID_OPERATION) {
 923         GLint pos;
 924         glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
 925         FIXME("Fragment program error at position %d: %s\n", pos,
 926             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
 927     }
 928
 929     return program_id;
 930 }
 931
 932 static void shader_arb_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
 933     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 934     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
 935
 936     if (useVS) {
 937         TRACE("Using vertex shader\n");
 938
 939         /* Bind the vertex program */
 940         GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB,
 941             ((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.prgId));
 942         checkGLcall("glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vertexShader->prgId);");
 943
 944         /* Enable OpenGL vertex programs */
 945         glEnable(GL_VERTEX_PROGRAM_ARB);
 946         checkGLcall("glEnable(GL_VERTEX_PROGRAM_ARB);");
 947         TRACE("(%p) : Bound vertex program %u and enabled GL_VERTEX_PROGRAM_ARB\n",
 948             This, ((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.prgId);
 949     } else if(GL_SUPPORT(GL_VERTEX_PROGRAM_ARB)) {
 950         glDisable(GL_VERTEX_PROGRAM_ARB);
 951         checkGLcall("glDisable(GL_VERTEX_PROGRAM_ARB)");
 952     }
 953
 954     if (usePS) {
 955         TRACE("Using pixel shader\n");
 956
 957         /* Bind the fragment program */
 958         GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB,
 959             ((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.prgId));
 960         checkGLcall("glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, pixelShader->prgId);");
 961
 962         /* Enable OpenGL fragment programs */
 963         glEnable(GL_FRAGMENT_PROGRAM_ARB);
 964         checkGLcall("glEnable(GL_FRAGMENT_PROGRAM_ARB);");
 965         TRACE("(%p) : Bound fragment program %u and enabled GL_FRAGMENT_PROGRAM_ARB\n",
 966             This, ((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.prgId);
 967     } else if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
 968         glDisable(GL_FRAGMENT_PROGRAM_ARB);
 969         checkGLcall("glDisable(GL_FRAGMENT_PROGRAM_ARB)");
 970     }
 971 }
 972
 973 static void shader_arb_select_depth_blt(IWineD3DDevice *iface) {
 974     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 975     WineD3D_GL_Info *gl_info = &((IWineD3DImpl *)(This->wineD3D))->gl_info;
 976     static GLuint vprogram_id = 0;
 977     static GLuint fprogram_id = 0;
 978
 979     if (!vprogram_id) vprogram_id = create_arb_blt_vertex_program(gl_info);
 980     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vprogram_id));
 981     glEnable(GL_VERTEX_PROGRAM_ARB);
 982
 983     if (!fprogram_id) fprogram_id = create_arb_blt_fragment_program(gl_info);
 984     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fprogram_id));
 985     glEnable(GL_FRAGMENT_PROGRAM_ARB);
 986 }
 987
 988 static void shader_arb_cleanup(BOOL usePS, BOOL useVS) {
 989     if (useVS) glDisable(GL_VERTEX_PROGRAM_ARB);
 990     if (usePS) glDisable(GL_FRAGMENT_PROGRAM_ARB);
 991 }
 992
 993 const shader_backend_t arb_program_shader_backend = {
 994     &shader_arb_select,
 995     &shader_arb_select_depth_blt,
 996     &shader_arb_load_constants,
 997     &shader_arb_cleanup
 998 };