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

   1 /*
   2  * shaders implementation
   3  *
   4  * Copyright 2002-2003 Jason Edmeades
   5  * Copyright 2002-2003 Raphael Junqueira
   6  * Copyright 2005 Oliver Stieber
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <math.h>
  26 #include <stdio.h>
  27
  28 #include "wined3d_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
  31
  32 #define GLINFO_LOCATION ((IWineD3DImpl *)(((IWineD3DDeviceImpl *)This->wineD3DDevice)->wineD3D))->gl_info
  33
  34 /* Shader debugging - Change the following line to enable debugging of software
  35       vertex shaders                                                             */
  36 #if 0 /* Musxt not be 1 in cvs version */
  37 # define VSTRACE(A) TRACE A
  38 # define TRACE_VSVECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w)
  39 #else
  40 # define VSTRACE(A)
  41 # define TRACE_VSVECTOR(name)
  42 #endif
  43
  44 #if 1 /* FIXME : Needs sorting when vshader code moved in properly */
  45
  46 /**
  47  * DirectX9 SDK download
  48  *  http://msdn.microsoft.com/library/default.asp?url=/downloads/list/directx.asp
  49  *
  50  * Exploring D3DX
  51  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx07162002.asp
  52  *
  53  * Using Vertex Shaders
  54  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx02192001.asp
  55  *
  56  * Dx9 New
  57  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/whatsnew.asp
  58  *
  59  * Dx9 Shaders
  60  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/VertexShader2_0.asp
  61  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/Instructions/Instructions.asp
  62  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexDeclaration/VertexDeclaration.asp
  63  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader3_0/VertexShader3_0.asp
  64  *
  65  * Dx9 D3DX
  66  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/advancedtopics/VertexPipe/matrixstack/matrixstack.asp
  67  *
  68  * FVF
  69  *  http://msdn.microsoft.com/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexFormats/vformats.asp
  70  *
  71  * NVIDIA: DX8 Vertex Shader to NV Vertex Program
  72  *  http://developer.nvidia.com/view.asp?IO=vstovp
  73  *
  74  * NVIDIA: Memory Management with VAR
  75  *  http://developer.nvidia.com/view.asp?IO=var_memory_management
  76  */
  77
  78 /* TODO: Vertex and Pixel shaders are almost identicle, the only exception being the way that some of the data is looked up or the availablity of some of the data i.e. some instructions are only valid for pshaders and some for vshaders
  79 because of this the bulk of the software pipeline can be shared between pixel and vertex shaders... and it wouldn't supprise me if the programes can be cross compiled using a large body body shared code */
  80
  81 typedef void (*shader_fct_t)();
  82
  83 typedef struct SHADER_OPCODE {
  84   unsigned int  opcode;
  85   const char*   name;
  86   const char*   glname;
  87   CONST UINT    num_params;
  88   shader_fct_t  soft_fct;
  89   DWORD         min_version;
  90   DWORD         max_version;
  91 } SHADER_OPCODE;
  92
  93 #define GLNAME_REQUIRE_GLSL  ((const char *)1)
  94
  95 /*******************************
  96  * vshader functions software VM
  97  */
  98
  99 void vshader_add(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 100   d->x = s0->x + s1->x;
 101   d->y = s0->y + s1->y;
 102   d->z = s0->z + s1->z;
 103   d->w = s0->w + s1->w;
 104   VSTRACE(("executing add: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 105                  s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 106 }
 107
 108 void vshader_dp3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 109   d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z;
 110   VSTRACE(("executing dp3: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 111                  s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 112 }
 113
 114 void vshader_dp4(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 115   d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z + s0->w * s1->w;
 116   VSTRACE(("executing dp4: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 117           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 118 }
 119
 120 void vshader_dst(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 121   d->x = 1.0f;
 122   d->y = s0->y * s1->y;
 123   d->z = s0->z;
 124   d->w = s1->w;
 125   VSTRACE(("executing dst: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 126           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 127 }
 128
 129 void vshader_expp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 130   union {
 131     float f;
 132     DWORD d;
 133   } tmp;
 134
 135   tmp.f = floorf(s0->w);
 136   d->x  = powf(2.0f, tmp.f);
 137   d->y  = s0->w - tmp.f;
 138   tmp.f = powf(2.0f, s0->w);
 139   tmp.d &= 0xFFFFFF00U;
 140   d->z  = tmp.f;
 141   d->w  = 1.0f;
 142   VSTRACE(("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 143                 s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 144 }
 145
 146 void vshader_lit(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 147   d->x = 1.0f;
 148   d->y = (0.0f < s0->x) ? s0->x : 0.0f;
 149   d->z = (0.0f < s0->x && 0.0f < s0->y) ? powf(s0->y, s0->w) : 0.0f;
 150   d->w = 1.0f;
 151   VSTRACE(("executing lit: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 152                  s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 153 }
 154
 155 void vshader_logp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 156   float tmp_f = fabsf(s0->w);
 157   d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE_VAL;
 158   VSTRACE(("executing logp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 159                  s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 160 }
 161
 162 void vshader_mad(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2) {
 163   d->x = s0->x * s1->x + s2->x;
 164   d->y = s0->y * s1->y + s2->y;
 165   d->z = s0->z * s1->z + s2->z;
 166   d->w = s0->w * s1->w + s2->w;
 167   VSTRACE(("executing mad: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) s2=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 168           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, s2->x, s2->y, s2->z, s2->w, d->x, d->y, d->z, d->w));
 169 }
 170
 171 void vshader_max(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 172   d->x = (s0->x >= s1->x) ? s0->x : s1->x;
 173   d->y = (s0->y >= s1->y) ? s0->y : s1->y;
 174   d->z = (s0->z >= s1->z) ? s0->z : s1->z;
 175   d->w = (s0->w >= s1->w) ? s0->w : s1->w;
 176   VSTRACE(("executing max: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 177           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 178 }
 179
 180 void vshader_min(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 181   d->x = (s0->x < s1->x) ? s0->x : s1->x;
 182   d->y = (s0->y < s1->y) ? s0->y : s1->y;
 183   d->z = (s0->z < s1->z) ? s0->z : s1->z;
 184   d->w = (s0->w < s1->w) ? s0->w : s1->w;
 185   VSTRACE(("executing min: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 186           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 187 }
 188
 189 void vshader_mov(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 190   d->x = s0->x;
 191   d->y = s0->y;
 192   d->z = s0->z;
 193   d->w = s0->w;
 194   VSTRACE(("executing mov: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 195           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 196 }
 197
 198 void vshader_mul(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 199   d->x = s0->x * s1->x;
 200   d->y = s0->y * s1->y;
 201   d->z = s0->z * s1->z;
 202   d->w = s0->w * s1->w;
 203   VSTRACE(("executing mul: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 204           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 205 }
 206
 207 void vshader_nop(void) {
 208     /* NOPPPP ahhh too easy ;) */
 209     VSTRACE(("executing nop\n"));
 210 }
 211
 212 void vshader_rcp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 213   d->x = d->y = d->z = d->w = (0.0f == s0->w) ? HUGE_VAL : 1.0f / s0->w;
 214   VSTRACE(("executing rcp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 215           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 216 }
 217
 218 void vshader_rsq(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 219   float tmp_f = fabsf(s0->w);
 220   d->x = d->y = d->z = d->w = (0.0f == tmp_f) ? HUGE_VAL : ((1.0f != tmp_f) ? 1.0f / sqrtf(tmp_f) : 1.0f);
 221   VSTRACE(("executing rsq: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 222           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 223 }
 224
 225 void vshader_sge(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 226   d->x = (s0->x >= s1->x) ? 1.0f : 0.0f;
 227   d->y = (s0->y >= s1->y) ? 1.0f : 0.0f;
 228   d->z = (s0->z >= s1->z) ? 1.0f : 0.0f;
 229   d->w = (s0->w >= s1->w) ? 1.0f : 0.0f;
 230   VSTRACE(("executing sge: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 231           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 232 }
 233
 234 void vshader_slt(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 235   d->x = (s0->x < s1->x) ? 1.0f : 0.0f;
 236   d->y = (s0->y < s1->y) ? 1.0f : 0.0f;
 237   d->z = (s0->z < s1->z) ? 1.0f : 0.0f;
 238   d->w = (s0->w < s1->w) ? 1.0f : 0.0f;
 239   VSTRACE(("executing slt: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 240           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 241 }
 242
 243 void vshader_sub(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 244   d->x = s0->x - s1->x;
 245   d->y = s0->y - s1->y;
 246   d->z = s0->z - s1->z;
 247   d->w = s0->w - s1->w;
 248   VSTRACE(("executing sub: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 249           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 250 }
 251
 252 /**
 253  * Version 1.1 specific
 254  */
 255
 256 void vshader_exp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 257   d->x = d->y = d->z = d->w = powf(2.0f, s0->w);
 258   VSTRACE(("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 259           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 260 }
 261
 262 void vshader_log(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 263   float tmp_f = fabsf(s0->w);
 264   d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE_VAL;
 265   VSTRACE(("executing log: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 266           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 267 }
 268
 269 void vshader_frc(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 270   d->x = s0->x - floorf(s0->x);
 271   d->y = s0->y - floorf(s0->y);
 272   d->z = 0.0f;
 273   d->w = 1.0f;
 274   VSTRACE(("executing frc: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 275           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 276 }
 277
 278 typedef FLOAT D3DMATRIX44[4][4];
 279 typedef FLOAT D3DMATRIX43[4][3];
 280 typedef FLOAT D3DMATRIX34[4][4];
 281 typedef FLOAT D3DMATRIX33[4][3];
 282 typedef FLOAT D3DMATRIX32[4][2];
 283
 284 void vshader_m4x4(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, /*WINED3DSHADERVECTOR* mat1*/ D3DMATRIX44 mat) {
 285   /*
 286    * Buggy CODE: here only if cast not work for copy/paste
 287   WINED3DSHADERVECTOR* mat2 = mat1 + 1;
 288   WINED3DSHADERVECTOR* mat3 = mat1 + 2;
 289   WINED3DSHADERVECTOR* mat4 = mat1 + 3;
 290   d->x = mat1->x * s0->x + mat2->x * s0->y + mat3->x * s0->z + mat4->x * s0->w;
 291   d->y = mat1->y * s0->x + mat2->y * s0->y + mat3->y * s0->z + mat4->y * s0->w;
 292   d->z = mat1->z * s0->x + mat2->z * s0->y + mat3->z * s0->z + mat4->z * s0->w;
 293   d->w = mat1->w * s0->x + mat2->w * s0->y + mat3->w * s0->z + mat4->w * s0->w;
 294   */
 295   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
 296   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
 297   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
 298   d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z + mat[3][3] * s0->w;
 299   VSTRACE(("executing m4x4(1): mat=(%f, %f, %f, %f)    s0=(%f)     d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], mat[0][3], s0->x, d->x));
 300   VSTRACE(("executing m4x4(2): mat=(%f, %f, %f, %f)       (%f)       (%f) \n", mat[1][0], mat[1][1], mat[1][2], mat[1][3], s0->y, d->y));
 301   VSTRACE(("executing m4x4(3): mat=(%f, %f, %f, %f) X     (%f)  =    (%f) \n", mat[2][0], mat[2][1], mat[2][2], mat[2][3], s0->z, d->z));
 302   VSTRACE(("executing m4x4(4): mat=(%f, %f, %f, %f)       (%f)       (%f) \n", mat[3][0], mat[3][1], mat[3][2], mat[3][3], s0->w, d->w));
 303 }
 304
 305 void vshader_m4x3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX43 mat) {
 306   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
 307   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
 308   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
 309   d->w = 1.0f;
 310   VSTRACE(("executing m4x3(1): mat=(%f, %f, %f, %f)    s0=(%f)     d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], mat[0][3], s0->x, d->x));
 311   VSTRACE(("executing m4x3(2): mat=(%f, %f, %f, %f)       (%f)       (%f) \n", mat[1][0], mat[1][1], mat[1][2], mat[1][3], s0->y, d->y));
 312   VSTRACE(("executing m4x3(3): mat=(%f, %f, %f, %f) X     (%f)  =    (%f) \n", mat[2][0], mat[2][1], mat[2][2], mat[2][3], s0->z, d->z));
 313   VSTRACE(("executing m4x3(4):                            (%f)       (%f) \n", s0->w, d->w));
 314 }
 315
 316 void vshader_m3x4(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX34 mat) {
 317   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
 318   d->y = mat[2][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
 319   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
 320   d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z;
 321   VSTRACE(("executing m3x4(1): mat=(%f, %f, %f)    s0=(%f)     d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], s0->x, d->x));
 322   VSTRACE(("executing m3x4(2): mat=(%f, %f, %f)       (%f)       (%f) \n", mat[1][0], mat[1][1], mat[1][2], s0->y, d->y));
 323   VSTRACE(("executing m3x4(3): mat=(%f, %f, %f) X     (%f)  =    (%f) \n", mat[2][0], mat[2][1], mat[2][2], s0->z, d->z));
 324   VSTRACE(("executing m3x4(4): mat=(%f, %f, %f)       (%f)       (%f) \n", mat[3][0], mat[3][1], mat[3][2], s0->w, d->w));
 325 }
 326
 327 void vshader_m3x3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX33 mat) {
 328   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[2][2] * s0->z;
 329   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[2][2] * s0->z;
 330   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
 331   d->w = 1.0f;
 332   VSTRACE(("executing m3x3(1): mat=(%f, %f, %f)    s0=(%f)     d=(%f) \n", mat[0][0], mat[0][1], mat[0][2], s0->x, d->x));
 333   VSTRACE(("executing m3x3(2): mat=(%f, %f, %f)       (%f)       (%f) \n", mat[1][0], mat[1][1], mat[1][2], s0->y, d->y));
 334   VSTRACE(("executing m3x3(3): mat=(%f, %f, %f) X     (%f)  =    (%f) \n", mat[2][0], mat[2][1], mat[2][2], s0->z, d->z));
 335   VSTRACE(("executing m3x3(4):                                       (%f) \n", d->w));
 336 }
 337
 338 void vshader_m3x2(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, D3DMATRIX32 mat) {
 339   FIXME("check\n");
 340   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
 341   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
 342   d->z = 0.0f;
 343   d->w = 1.0f;
 344 }
 345
 346 /**
 347  * Version 2.0 specific
 348  */
 349 void vshader_lrp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2, WINED3DSHADERVECTOR* s3) {
 350   d->x = s0->x * (s1->x - s2->x) + s2->x;
 351   d->y = s0->y * (s1->y - s2->y) + s2->y;
 352   d->z = s0->z * (s1->z - s2->z) + s2->z;
 353   d->w = s0->w * (s1->w - s2->w) + s2->x;
 354 }
 355
 356 void vshader_crs(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 357   d->x = s0->y * s1->z - s0->z * s1->y;
 358   d->y = s0->z * s1->x - s0->x * s1->z;
 359   d->z = s0->x * s1->y - s0->y * s1->x;
 360   d->w = 0.9f; /* w is undefined, so set it to something safeish */
 361
 362   VSTRACE(("executing crs: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 363              s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w));
 364 }
 365
 366 void vshader_abs(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 367
 368   d->x = fabsf(s0->x);
 369   d->y = fabsf(s0->y);
 370   d->z = fabsf(s0->z);
 371   d->w = fabsf(s0->w);
 372   VSTRACE(("executing abs: s0=(%f, %f, %f, %f)  => d=(%f, %f, %f, %f)\n",
 373              s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w));
 374 }
 375
 376     /* Stubs */
 377 void vshader_texcoord(WINED3DSHADERVECTOR* d) {
 378     FIXME(" : Stub\n");
 379 }
 380
 381 void vshader_texkill(WINED3DSHADERVECTOR* d) {
 382     FIXME(" : Stub\n");
 383 }
 384
 385 void vshader_tex(WINED3DSHADERVECTOR* d) {
 386     FIXME(" : Stub\n");
 387 }
 388 void vshader_texld(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 389     FIXME(" : Stub\n");
 390 }
 391
 392 void vshader_texbem(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 393     FIXME(" : Stub\n");
 394 }
 395
 396 void vshader_texbeml(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 397     FIXME(" : Stub\n");
 398 }
 399
 400 void vshader_texreg2ar(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 401     FIXME(" : Stub\n");
 402 }
 403
 404 void vshader_texreg2gb(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 405     FIXME(" : Stub\n");
 406 }
 407
 408 void vshader_texm3x2pad(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 409     FIXME(" : Stub\n");
 410 }
 411
 412 void vshader_texm3x2tex(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 413     FIXME(" : Stub\n");
 414 }
 415
 416 void vshader_texm3x3pad(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 417     FIXME(" : Stub\n");
 418 }
 419
 420 void vshader_texm3x3tex(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 421     FIXME(" : Stub\n");
 422 }
 423
 424 void vshader_texm3x3diff(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 425     FIXME(" : Stub\n");
 426 }
 427
 428 void vshader_texm3x3spec(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 429     FIXME(" : Stub\n");
 430 }
 431
 432 void vshader_texm3x3vspec(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 433     FIXME(" : Stub\n");
 434 }
 435
 436 void vshader_cnd(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2) {
 437     FIXME(" : Stub\n");
 438 }
 439
 440 /* Def is C[n] = {n.nf, n.nf, n.nf, n.nf} */
 441 void vshader_def(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2, WINED3DSHADERVECTOR* s3) {
 442     FIXME(" : Stub\n");
 443 }
 444
 445 void vshader_texreg2rgb(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 446     FIXME(" : Stub\n");
 447 }
 448
 449 void vshader_texdp3tex(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 450     FIXME(" : Stub\n");
 451 }
 452
 453 void vshader_texm3x2depth(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 454     FIXME(" : Stub\n");
 455 }
 456
 457 void vshader_texdp3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 458     FIXME(" : Stub\n");
 459 }
 460
 461 void vshader_texm3x3(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 462     FIXME(" : Stub\n");
 463 }
 464
 465 void vshader_texdepth(WINED3DSHADERVECTOR* d) {
 466     FIXME(" : Stub\n");
 467 }
 468
 469 void vshader_cmp(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1, WINED3DSHADERVECTOR* s2) {
 470     FIXME(" : Stub\n");
 471 }
 472
 473 void vshader_bem(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 474     FIXME(" : Stub\n");
 475 }
 476
 477 void vshader_call(WINED3DSHADERVECTOR* d) {
 478     FIXME(" : Stub\n");
 479 }
 480
 481 void vshader_callnz(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 482     FIXME(" : Stub\n");
 483 }
 484
 485 void vshader_loop(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 486     FIXME(" : Stub\n");
 487 }
 488
 489 void vshader_ret(WINED3DSHADERVECTOR* d) {
 490     FIXME(" : Stub\n");
 491 }
 492
 493 void vshader_endloop(WINED3DSHADERVECTOR* d) {
 494     FIXME(" : Stub\n");
 495 }
 496
 497 void vshader_dcl(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 498     FIXME(" : Stub\n");
 499 }
 500
 501 void vshader_pow(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0, WINED3DSHADERVECTOR* s1) {
 502     FIXME(" : Stub\n");
 503 }
 504
 505 void vshader_sng(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 506     FIXME(" : Stub\n");
 507 }
 508
 509 void vshader_nrm(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 510     FIXME(" : Stub\n");
 511 }
 512
 513 void vshader_sincos(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 514     FIXME(" : Stub\n");
 515 }
 516
 517 void vshader_rep(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 518     FIXME(" : Stub\n");
 519 }
 520
 521 void vshader_endrep(void) {
 522     FIXME(" : Stub\n");
 523 }
 524
 525 void vshader_if(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 526     FIXME(" : Stub\n");
 527 }
 528
 529 void vshader_ifc(WINED3DSHADERVECTOR* d, WINED3DSHADERVECTOR* s0) {
 530     FIXME(" : Stub\n");
 531 }
 532
 533 void vshader_else(WINED3DSHADERVECTOR* d) {
 534     FIXME(" : Stub\n");
 535 }
 536
 537 void vshader_label(WINED3DSHADERVECTOR* d) {
 538     FIXME(" : Stub\n");
 539 }
 540
 541 void vshader_endif(WINED3DSHADERVECTOR* d) {
 542     FIXME(" : Stub\n");
 543 }
 544
 545 void vshader_break(WINED3DSHADERVECTOR* d) {
 546     FIXME(" : Stub\n");
 547 }
 548
 549 void vshader_breakc(WINED3DSHADERVECTOR* d) {
 550     FIXME(" : Stub\n");
 551 }
 552
 553 void vshader_mova(WINED3DSHADERVECTOR* d) {
 554     FIXME(" : Stub\n");
 555 }
 556
 557 void vshader_defb(WINED3DSHADERVECTOR* d) {
 558     FIXME(" : Stub\n");
 559 }
 560
 561 void vshader_defi(WINED3DSHADERVECTOR* d) {
 562     FIXME(" : Stub\n");
 563 }
 564
 565 void vshader_dp2add(WINED3DSHADERVECTOR* d) {
 566     FIXME(" : Stub\n");
 567 }
 568
 569 void vshader_dsx(WINED3DSHADERVECTOR* d) {
 570     FIXME(" : Stub\n");
 571 }
 572
 573 void vshader_dsy(WINED3DSHADERVECTOR* d) {
 574     FIXME(" : Stub\n");
 575 }
 576
 577 void vshader_texldd(WINED3DSHADERVECTOR* d) {
 578     FIXME(" : Stub\n");
 579 }
 580
 581 void vshader_setp(WINED3DSHADERVECTOR* d) {
 582     FIXME(" : Stub\n");
 583 }
 584
 585 void vshader_texldl(WINED3DSHADERVECTOR* d) {
 586     FIXME(" : Stub\n");
 587 }
 588
 589 void vshader_breakp(WINED3DSHADERVECTOR* d) {
 590     FIXME(" : Stub\n");
 591 }
 592
 593
 594 /**
 595  * log, exp, frc, m*x* seems to be macros ins ... to see
 596  */
 597 static CONST SHADER_OPCODE vshader_ins [] = {
 598     {D3DSIO_NOP,  "nop", "NOP", 0, vshader_nop, 0, 0},
 599     {D3DSIO_MOV,  "mov", "MOV", 2, vshader_mov, 0, 0},
 600     {D3DSIO_ADD,  "add", "ADD", 3, vshader_add, 0, 0},
 601     {D3DSIO_SUB,  "sub", "SUB", 3, vshader_sub, 0, 0},
 602     {D3DSIO_MAD,  "mad", "MAD", 4, vshader_mad, 0, 0},
 603     {D3DSIO_MUL,  "mul", "MUL", 3, vshader_mul, 0, 0},
 604     {D3DSIO_RCP,  "rcp", "RCP",  2, vshader_rcp, 0, 0},
 605     {D3DSIO_RSQ,  "rsq",  "RSQ", 2, vshader_rsq, 0, 0},
 606     {D3DSIO_DP3,  "dp3",  "DP3", 3, vshader_dp3, 0, 0},
 607     {D3DSIO_DP4,  "dp4",  "DP4", 3, vshader_dp4, 0, 0},
 608     {D3DSIO_MIN,  "min",  "MIN", 3, vshader_min, 0, 0},
 609     {D3DSIO_MAX,  "max",  "MAX", 3, vshader_max, 0, 0},
 610     {D3DSIO_SLT,  "slt",  "SLT", 3, vshader_slt, 0, 0},
 611     {D3DSIO_SGE,  "sge",  "SGE", 3, vshader_sge, 0, 0},
 612     {D3DSIO_ABS,  "abs",  "ABS", 2, vshader_abs, 0, 0},
 613     {D3DSIO_EXP,  "exp",  "EX2", 2, vshader_exp, 0, 0},
 614     {D3DSIO_LOG,  "log",  "LG2", 2, vshader_log, 0, 0},
 615     {D3DSIO_LIT,  "lit",  "LIT", 2, vshader_lit, 0, 0},
 616     {D3DSIO_DST,  "dst",  "DST", 3, vshader_dst, 0, 0},
 617     {D3DSIO_LRP,  "lrp",  "LRP", 5, vshader_lrp, 0, 0},
 618     {D3DSIO_FRC,  "frc",  "FRC", 2, vshader_frc, 0, 0},
 619     {D3DSIO_M4x4, "m4x4", "undefined", 3, vshader_m4x4, 0, 0},
 620     {D3DSIO_M4x3, "m4x3", "undefined", 3, vshader_m4x3, 0, 0},
 621     {D3DSIO_M3x4, "m3x4", "undefined", 3, vshader_m3x4, 0, 0},
 622     {D3DSIO_M3x3, "m3x3", "undefined", 3, vshader_m3x3, 0, 0},
 623     {D3DSIO_M3x2, "m3x2", "undefined", 3, vshader_m3x2, 0, 0},
 624     /** FIXME: use direct access so add the others opcodes as stubs */
 625     /* NOTE: gl function is currently NULL for calls and loops because they are not yet supported
 626         They can be easly managed in software by introducing a call/loop stack and should be possible to implement in glsl ol NV_shader's */
 627     {D3DSIO_CALL,     "call",     GLNAME_REQUIRE_GLSL,   1, vshader_call,    0, 0},
 628     {D3DSIO_CALLNZ,   "callnz",   GLNAME_REQUIRE_GLSL,   2, vshader_callnz,  0, 0},
 629     {D3DSIO_LOOP,     "loop",     GLNAME_REQUIRE_GLSL,   2, vshader_loop,    0, 0},
 630     {D3DSIO_RET,      "ret",      GLNAME_REQUIRE_GLSL,   0, vshader_ret,     0, 0},
 631     {D3DSIO_ENDLOOP,  "endloop",  GLNAME_REQUIRE_GLSL,   0, vshader_endloop, 0, 0},
 632     {D3DSIO_LABEL,    "label",    GLNAME_REQUIRE_GLSL,   1, vshader_label,   0, 0},
 633     /* DCL is a specil operation */
 634     {D3DSIO_DCL,      "dcl",      NULL,   1, vshader_dcl,     0, 0},
 635     {D3DSIO_POW,      "pow",      "POW",  3, vshader_pow,     0, 0},
 636     {D3DSIO_CRS,      "crs",      "XPS",  3, vshader_crs,     0, 0},
 637     /* TODO: sng can possibly be performed as
 638         RCP tmp, vec
 639         MUL out, tmp, vec*/
 640     {D3DSIO_SGN,      "sng",      NULL,   2, vshader_sng,     0, 0},
 641     /* TODO: xyz normalise can be performed is VS_ARB using one tempory register,
 642         DP3 tmp , vec, vec;
 643         RSQ tmp, tmp.x;
 644         MUL vec.xyz, vec, tmp;
 645     but I think this is better because it accounts for w properly.
 646         DP3 tmp , vec, vec;
 647         RSQ tmp, tmp.x;
 648         MUL vec, vec, tmp;
 649
 650     */
 651     {D3DSIO_NRM,      "nrm",      NULL,   2, vshader_nrm,     0, 0},
 652     {D3DSIO_SINCOS,   "sincos",   NULL,   2, vshader_sincos,  0, 0},
 653     {D3DSIO_REP ,     "rep",      GLNAME_REQUIRE_GLSL,   2, vshader_rep,     0, 0},
 654     {D3DSIO_ENDREP,   "endrep",   GLNAME_REQUIRE_GLSL,   0, vshader_endrep,  0, 0},
 655     {D3DSIO_IF,       "if",       GLNAME_REQUIRE_GLSL,   2, vshader_if,      0, 0},
 656     {D3DSIO_IFC,      "ifc",      GLNAME_REQUIRE_GLSL,   2, vshader_ifc,     0, 0},
 657     {D3DSIO_ELSE,     "else",     GLNAME_REQUIRE_GLSL,   2, vshader_else,    0, 0},
 658     {D3DSIO_ENDIF,    "endif",    GLNAME_REQUIRE_GLSL,   2, vshader_endif,   0, 0},
 659     {D3DSIO_BREAK,    "break",    GLNAME_REQUIRE_GLSL,   2, vshader_break,   0, 0},
 660     {D3DSIO_BREAKC,   "breakc",   GLNAME_REQUIRE_GLSL,   2, vshader_breakc,  0, 0},
 661     {D3DSIO_MOVA,     "mova",     GLNAME_REQUIRE_GLSL,   2, vshader_mova,    0, 0},
 662     {D3DSIO_DEFB,     "defb",     GLNAME_REQUIRE_GLSL,   2, vshader_defb,    0, 0},
 663     {D3DSIO_DEFI,     "defi",     GLNAME_REQUIRE_GLSL,   2, vshader_defi,    0, 0},
 664
 665     {D3DSIO_TEXCOORD, "texcoord", GLNAME_REQUIRE_GLSL,   1, vshader_texcoord,    D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 666     {D3DSIO_TEXCOORD, "texcrd",   GLNAME_REQUIRE_GLSL,   2, vshader_texcoord,    D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
 667     {D3DSIO_TEXKILL,  "texkill",  GLNAME_REQUIRE_GLSL,   1, vshader_texkill,     D3DPS_VERSION(1,0), D3DPS_VERSION(1,4)},
 668     {D3DSIO_TEX,      "tex",      GLNAME_REQUIRE_GLSL,   1, vshader_tex,         D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 669     {D3DSIO_TEX,      "texld",    GLNAME_REQUIRE_GLSL,   2, vshader_texld,       D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
 670     {D3DSIO_TEXBEM,   "texbem",   GLNAME_REQUIRE_GLSL,   2, vshader_texbem,      D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 671     {D3DSIO_TEXBEML,  "texbeml",  GLNAME_REQUIRE_GLSL,   2, vshader_texbeml,     D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 672     {D3DSIO_TEXREG2AR,"texreg2ar",GLNAME_REQUIRE_GLSL,   2, vshader_texreg2ar,   D3DPS_VERSION(1,1), D3DPS_VERSION(1,3)},
 673     {D3DSIO_TEXREG2GB,"texreg2gb",GLNAME_REQUIRE_GLSL,   2, vshader_texreg2gb,   D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
 674     {D3DSIO_TEXM3x2PAD,   "texm3x2pad",   GLNAME_REQUIRE_GLSL,   2, vshader_texm3x2pad,   D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 675     {D3DSIO_TEXM3x2TEX,   "texm3x2tex",   GLNAME_REQUIRE_GLSL,   2, vshader_texm3x2tex,   D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 676     {D3DSIO_TEXM3x3DIFF,  "texm3x3diff",  GLNAME_REQUIRE_GLSL,   2, vshader_texm3x3diff,  D3DPS_VERSION(0,0), D3DPS_VERSION(0,0)},
 677     {D3DSIO_TEXM3x3SPEC,  "texm3x3spec",  GLNAME_REQUIRE_GLSL,   3, vshader_texm3x3spec,  D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 678     {D3DSIO_TEXM3x3VSPEC, "texm3x3vspe",  GLNAME_REQUIRE_GLSL,   2, vshader_texm3x3vspec, D3DPS_VERSION(1,0), D3DPS_VERSION(1,3)},
 679
 680     {D3DSIO_EXPP,     "expp",     "EXP", 2, vshader_expp, 0, 0},
 681     {D3DSIO_LOGP,     "logp",     "LOG", 2, vshader_logp, 0, 0},
 682     {D3DSIO_CND,      "cnd",      GLNAME_REQUIRE_GLSL,   4, vshader_cnd,         D3DPS_VERSION(1,1), D3DPS_VERSION(1,4)},
 683     /* def is a special opperation */
 684     {D3DSIO_DEF,      "def",      NULL,   5, vshader_def,         D3DPS_VERSION(1,0), D3DPS_VERSION(3,0)},
 685     {D3DSIO_TEXREG2RGB,   "texreg2rgb",   GLNAME_REQUIRE_GLSL,   2, vshader_texreg2rgb,  D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
 686     {D3DSIO_TEXDP3TEX,    "texdp3tex",    GLNAME_REQUIRE_GLSL,   2, vshader_texdp3tex,   D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
 687     {D3DSIO_TEXM3x2DEPTH, "texm3x2depth", GLNAME_REQUIRE_GLSL,   2, vshader_texm3x2depth,D3DPS_VERSION(1,3), D3DPS_VERSION(1,3)},
 688     {D3DSIO_TEXDP3,       "texdp3", GLNAME_REQUIRE_GLSL,  2, vshader_texdp3,     D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
 689     {D3DSIO_TEXM3x3,      "texm3x3", GLNAME_REQUIRE_GLSL, 2, vshader_texm3x3,    D3DPS_VERSION(1,2), D3DPS_VERSION(1,3)},
 690     {D3DSIO_TEXDEPTH,     "texdepth", GLNAME_REQUIRE_GLSL,1, vshader_texdepth,   D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
 691     {D3DSIO_CMP,      "cmp",      GLNAME_REQUIRE_GLSL,   4, vshader_cmp,     D3DPS_VERSION(1,1), D3DPS_VERSION(3,0)},
 692     {D3DSIO_BEM,      "bem",      GLNAME_REQUIRE_GLSL,   3, vshader_bem,     D3DPS_VERSION(1,4), D3DPS_VERSION(1,4)},
 693     /* TODO: dp2add can be made out of multiple instuctions */
 694     {D3DSIO_DP2ADD,   "dp2add",   GLNAME_REQUIRE_GLSL,   2, vshader_dp2add,  0, 0},
 695     {D3DSIO_DSX,      "dsx",      GLNAME_REQUIRE_GLSL,   2, vshader_dsx,     0, 0},
 696     {D3DSIO_DSY,      "dsy",      GLNAME_REQUIRE_GLSL,   2, vshader_dsy,     0, 0},
 697     {D3DSIO_TEXLDD,   "texldd",   GLNAME_REQUIRE_GLSL,   2, vshader_texldd,  0, 0},
 698     {D3DSIO_SETP,     "setp",     GLNAME_REQUIRE_GLSL,   2, vshader_setp,    0, 0},
 699     {D3DSIO_TEXLDL,   "texdl",    GLNAME_REQUIRE_GLSL,   2, vshader_texldl,  0, 0},
 700     {D3DSIO_BREAKP,   "breakp",   GLNAME_REQUIRE_GLSL,   2, vshader_breakp,  0, 0},
 701     {D3DSIO_PHASE,    "phase",    GLNAME_REQUIRE_GLSL,   0, vshader_nop,     0, 0},
 702     {0,               NULL,       NULL,   0, NULL,            0, 0}
 703 };
 704
 705
 706 inline static const SHADER_OPCODE* vshader_program_get_opcode(const DWORD code) {
 707     DWORD i = 0;
 708     /** TODO: use dichotomic search or hash table */
 709     while (NULL != vshader_ins[i].name) {
 710         if ((code & D3DSI_OPCODE_MASK) == vshader_ins[i].opcode) {
 711             return &vshader_ins[i];
 712         }
 713         ++i;
 714     }
 715     FIXME("Unsupported opcode %lx\n",code);
 716     return NULL;
 717 }
 718
 719 inline static void vshader_program_dump_param(const DWORD param, int input) {
 720   static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
 721   static const char swizzle_reg_chars[] = "xyzw";
 722
 723   DWORD reg = param & 0x00001FFF;
 724   DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
 725
 726   if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) TRACE("-");
 727
 728   switch (regtype) {
 729   case D3DSPR_TEMP:
 730     TRACE("R[%lu]", reg);
 731     break;
 732   case D3DSPR_INPUT:
 733     TRACE("v%lu", reg);
 734     break;
 735   case D3DSPR_CONST:
 736     TRACE("C[%s%lu]", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 737     break;
 738   case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 739     TRACE("a[%lu]", reg);
 740     break;
 741   case D3DSPR_RASTOUT:
 742     TRACE("%s", rastout_reg_names[reg]);
 743     break;
 744   case D3DSPR_ATTROUT:
 745     TRACE("oD[%lu]", reg);
 746     break;
 747   case D3DSPR_TEXCRDOUT:
 748     TRACE("oT[%lu]", reg);
 749     break;
 750   default:
 751     FIXME("Unknown %lu %u reg %lu\n",regtype,  D3DSPR_ATTROUT, reg);
 752     break;
 753   }
 754
 755   if (!input) {
 756     /** operand output */
 757     if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 758       if (param & D3DSP_WRITEMASK_0) TRACE(".x");
 759       if (param & D3DSP_WRITEMASK_1) TRACE(".y");
 760       if (param & D3DSP_WRITEMASK_2) TRACE(".z");
 761       if (param & D3DSP_WRITEMASK_3) TRACE(".w");
 762     }
 763   } else {
 764     /** operand input */
 765     DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 766     DWORD swizzle_x = swizzle & 0x03;
 767     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 768     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 769     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 770     /**
 771      * swizzle bits fields:
 772      *  WWZZYYXX
 773      */
 774     if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 775       if (swizzle_x == swizzle_y &&
 776             swizzle_x == swizzle_z &&
 777             swizzle_x == swizzle_w) {
 778                 TRACE(".%c", swizzle_reg_chars[swizzle_x]);
 779             } else {
 780                 TRACE(".%c%c%c%c",
 781                     swizzle_reg_chars[swizzle_x],
 782                     swizzle_reg_chars[swizzle_y],
 783                     swizzle_reg_chars[swizzle_z],
 784                     swizzle_reg_chars[swizzle_w]);
 785       }
 786     }
 787   }
 788 }
 789
 790 inline static void vshader_program_dump_vs_param(const DWORD param, int input) {
 791   static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
 792   static const char swizzle_reg_chars[] = "xyzw";
 793    /* the unknown mask is for bits not yet accounted for by any other mask... */
 794 #define UNKNOWN_MASK 0xC000
 795
 796    /* for registeres about 7 we have to add on bits 11 and 12 to get the correct register */
 797 #define EXTENDED_REG 0x1800
 798
 799   DWORD reg = param & D3DSP_REGNUM_MASK; /* 0x00001FFF;  isn't this D3DSP_REGNUM_MASK? */
 800   DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT) | ((param & EXTENDED_REG) >> 8);
 801
 802   if(param & UNKNOWN_MASK) { /* if this register has any of the unknown bits set then report them*/
 803       FIXME("Unknown bits set regtype %lx , %lx, UK(%lx)\n", regtype, (param & EXTENDED_REG), param & UNKNOWN_MASK);
 804   }
 805
 806   if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) TRACE("-");
 807
 808   switch (regtype /*<< D3DSP_REGTYPE_SHIFT*/) {
 809   case D3DSPR_TEMP:
 810     TRACE("r%lu", reg);
 811     break;
 812   case D3DSPR_INPUT:
 813     TRACE("v%lu", reg);
 814     break;
 815   case D3DSPR_CONST:
 816     TRACE("c%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 817     break;
 818   case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 819     TRACE("a%lu", reg);
 820     break;
 821   case D3DSPR_RASTOUT:
 822     TRACE("%s", rastout_reg_names[reg]);
 823     break;
 824   case D3DSPR_ATTROUT:
 825     TRACE("oD%lu", reg);
 826     break;
 827   case D3DSPR_TEXCRDOUT:
 828     TRACE("oT%lu", reg);
 829     break;
 830   case D3DSPR_CONSTINT:
 831     TRACE("i%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 832     break;
 833   case D3DSPR_CONSTBOOL:
 834     TRACE("b%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 835     break;
 836   case D3DSPR_LABEL:
 837     TRACE("l%lu", reg);
 838     break;
 839   case D3DSPR_LOOP:
 840     TRACE("aL%s%lu", (param & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 841     break;
 842   default:
 843     FIXME("Unknown %lu reg %lu\n",regtype, reg);
 844     break;
 845   }
 846
 847   if (!input) {
 848     /** operand output */
 849     if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 850       if (param & D3DSP_WRITEMASK_0) TRACE(".x");
 851       if (param & D3DSP_WRITEMASK_1) TRACE(".y");
 852       if (param & D3DSP_WRITEMASK_2) TRACE(".z");
 853       if (param & D3DSP_WRITEMASK_3) TRACE(".w");
 854     }
 855   } else {
 856     /** operand input */
 857     DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 858     DWORD swizzle_x = swizzle & 0x03;
 859     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 860     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 861     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 862     /**
 863      * swizzle bits fields:
 864      *  WWZZYYXX
 865      */
 866     if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 867       if (swizzle_x == swizzle_y &&
 868         swizzle_x == swizzle_z &&
 869         swizzle_x == swizzle_w) {
 870             TRACE(".%c", swizzle_reg_chars[swizzle_x]);
 871       } else {
 872         TRACE(".%c%c%c%c",
 873         swizzle_reg_chars[swizzle_x],
 874         swizzle_reg_chars[swizzle_y],
 875         swizzle_reg_chars[swizzle_z],
 876         swizzle_reg_chars[swizzle_w]);
 877       }
 878     }
 879   }
 880 }
 881
 882 inline static BOOL vshader_is_version_token(DWORD token) {
 883   return 0xFFFE0000 == (token & 0xFFFE0000);
 884 }
 885
 886 inline static BOOL vshader_is_comment_token(DWORD token) {
 887   return D3DSIO_COMMENT == (token & D3DSI_OPCODE_MASK);
 888 }
 889
 890 inline static void vshader_program_add_param(const DWORD param, int input, char *hwLine, BOOL namedArrays, CHAR constantsUsedBitmap[]) {
 891   /*static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" }; */
 892   static const char* hwrastout_reg_names[] = { "result.position", "result.fogcoord", "result.pointsize" };
 893   static const char swizzle_reg_chars[] = "xyzw";
 894
 895   DWORD reg = param & 0x00001FFF;
 896   DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
 897   char  tmpReg[255];
 898
 899   if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) {
 900       strcat(hwLine, " -");
 901   } else {
 902       strcat(hwLine, " ");
 903   }
 904
 905   switch (regtype) {
 906   case D3DSPR_TEMP:
 907     sprintf(tmpReg, "T%lu", reg);
 908     strcat(hwLine, tmpReg);
 909     break;
 910   case D3DSPR_INPUT:
 911     /* if the attributes come in as named dcl's then use a named vertex (called namedVertexN) */
 912     if (namedArrays) {
 913         sprintf(tmpReg, "namedVertex%lu", reg);
 914     } else {
 915     /* otherwise the input is on a numbered attribute so use opengl numbered attributes */
 916         sprintf(tmpReg, "vertex.attrib[%lu]", reg);
 917     }
 918     strcat(hwLine, tmpReg);
 919     break;
 920   case D3DSPR_CONST:
 921     /* FIXME: some constants are named so we need a constants map*/
 922     if (constantsUsedBitmap[reg] == VS_CONSTANT_CONSTANT) {
 923         if (param & D3DVS_ADDRMODE_RELATIVE) {
 924             FIXME("Relitive addressing not expected for a named constant %lu\n", reg);
 925         }
 926         sprintf(tmpReg, "const%lu", reg);
 927     } else {
 928         sprintf(tmpReg, "C[%s%lu]", (param & D3DVS_ADDRMODE_RELATIVE) ? "A0.x + " : "", reg);
 929     }
 930     strcat(hwLine, tmpReg);
 931     break;
 932   case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 933     sprintf(tmpReg, "A%lu", reg);
 934     strcat(hwLine, tmpReg);
 935     break;
 936   case D3DSPR_RASTOUT:
 937     sprintf(tmpReg, "%s", hwrastout_reg_names[reg]);
 938     strcat(hwLine, tmpReg);
 939     break;
 940   case D3DSPR_ATTROUT:
 941     if (reg==0) {
 942        strcat(hwLine, "result.color.primary");
 943     } else {
 944        strcat(hwLine, "result.color.secondary");
 945     }
 946     break;
 947   case D3DSPR_TEXCRDOUT:
 948     sprintf(tmpReg, "result.texcoord[%lu]", reg);
 949     strcat(hwLine, tmpReg);
 950     break;
 951   default:
 952     FIXME("Unknown reg type %ld %ld\n", regtype, reg);
 953     break;
 954   }
 955
 956   if (!input) {
 957     /** operand output */
 958     if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 959       strcat(hwLine, ".");
 960       if (param & D3DSP_WRITEMASK_0) {
 961           strcat(hwLine, "x");
 962       }
 963       if (param & D3DSP_WRITEMASK_1) {
 964           strcat(hwLine, "y");
 965       }
 966       if (param & D3DSP_WRITEMASK_2) {
 967           strcat(hwLine, "z");
 968       }
 969       if (param & D3DSP_WRITEMASK_3) {
 970           strcat(hwLine, "w");
 971       }
 972     }
 973   } else {
 974     /** operand input */
 975     DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 976     DWORD swizzle_x = swizzle & 0x03;
 977     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 978     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 979     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 980     /**
 981      * swizzle bits fields:
 982      *  WWZZYYXX
 983      */
 984     if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 985       if (swizzle_x == swizzle_y &&
 986         swizzle_x == swizzle_z &&
 987         swizzle_x == swizzle_w)
 988       {
 989         sprintf(tmpReg, ".%c", swizzle_reg_chars[swizzle_x]);
 990         strcat(hwLine, tmpReg);
 991       } else {
 992         sprintf(tmpReg, ".%c%c%c%c",
 993         swizzle_reg_chars[swizzle_x],
 994         swizzle_reg_chars[swizzle_y],
 995         swizzle_reg_chars[swizzle_z],
 996         swizzle_reg_chars[swizzle_w]);
 997         strcat(hwLine, tmpReg);
 998       }
 999     }
1000   }
1001 }
1002
1003 DWORD MacroExpansion[4*4];
1004
1005 int ExpandMxMacro(DWORD macro_opcode, const DWORD* args) {
1006   int i;
1007   int nComponents = 0;
1008   DWORD opcode =0;
1009   switch(macro_opcode) {
1010     case D3DSIO_M4x4:
1011       nComponents = 4;
1012       opcode = D3DSIO_DP4;
1013       break;
1014     case D3DSIO_M4x3:
1015       nComponents = 3;
1016       opcode = D3DSIO_DP4;
1017       break;
1018     case D3DSIO_M3x4:
1019       nComponents = 4;
1020       opcode = D3DSIO_DP3;
1021       break;
1022     case D3DSIO_M3x3:
1023       nComponents = 3;
1024       opcode = D3DSIO_DP3;
1025       break;
1026     case D3DSIO_M3x2:
1027       nComponents = 2;
1028       opcode = D3DSIO_DP3;
1029       break;
1030     default:
1031       break;
1032   }
1033   for (i = 0; i < nComponents; i++) {
1034     MacroExpansion[i*4+0] = opcode;
1035     MacroExpansion[i*4+1] = ((*args) & ~D3DSP_WRITEMASK_ALL)|(D3DSP_WRITEMASK_0<<i);
1036     MacroExpansion[i*4+2] = *(args+1);
1037     MacroExpansion[i*4+3] = (*(args+2))+i;
1038   }
1039   return nComponents;
1040 }
1041
1042 /**
1043  * Function parser ...
1044  */
1045
1046 inline static VOID IWineD3DVertexShaderImpl_GenerateProgramArbHW(IWineD3DVertexShader *iface, CONST DWORD* pFunction) {
1047     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1048     const DWORD* pToken = pFunction;
1049     const DWORD* pSavedToken = NULL;
1050     const SHADER_OPCODE* curOpcode = NULL;
1051     int nRemInstr = -1;
1052     DWORD i;
1053     unsigned lineNum = 0;
1054     char *pgmStr = NULL;
1055     char  tmpLine[255];
1056     DWORD nUseAddressRegister = 0;
1057     DWORD nUseTempRegister = 0;
1058     DWORD regtype;
1059     DWORD reg;
1060     BOOL tmpsUsed[32];
1061 #if 0 /* TODO: loope register (just another address register ) */
1062     BOOL hasLoops = FALSE;
1063 #endif
1064
1065 #define PGMSIZE 65535
1066 /* Keep a running length for pgmStr so that we don't have to caculate strlen every time we concatanate */
1067     int pgmLength = 0;
1068
1069 #if 0 /* FIXME: Use the buffer that is held by the device, this is ok since fixups will be skipped for software shaders
1070         it also requires entering a critical section but cuts down the runtime footprint of wined3d and any memory fragmentation that may occure... */
1071     if (This->device->fixupVertexBufferSize < PGMSIZE) {
1072         HeapFree(GetProcessHeap(), 0, This->fixupVertexBuffer);
1073         This->fixupVertexBuffer = HeapAlloc(GetProcessHeap() , 0, PGMSIZE);
1074         This->fixupVertexBufferSize = PGMSIZE;
1075         This->fixupVertexBuffer[0] = 0;
1076     }
1077     pgmStr = This->device->fixupVertexBuffer;
1078 #endif
1079 #define PNSTRCAT(_pgmStr, _tmpLine) { \
1080         int _tmpLineLen = strlen(_tmpLine); \
1081         if(_tmpLineLen + pgmLength > PGMSIZE) { \
1082             ERR("The buffer allocated for the vertex program string pgmStr is too small at %d bytes, at least %d bytes in total are required.\n", PGMSIZE, _tmpLineLen + pgmLength); \
1083         } else { \
1084            memcpy(_pgmStr + pgmLength, _tmpLine, _tmpLineLen); \
1085         } \
1086         pgmLength += _tmpLineLen; \
1087         }
1088
1089     pgmStr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 65535); /* 64kb should be enough */
1090     /* Initilise the shader */
1091     This->namedArrays = FALSE;
1092     This->declaredArrays = FALSE;
1093     for (i = 0; i < WINED3DSHADERDECLUSAGE_MAX_USAGE; i++) {
1094         This->arrayUsageMap[i] = -1;
1095     }
1096     /* set all the tmpsUsed to not used */
1097     memset(tmpsUsed, FALSE , sizeof(tmpsUsed));
1098
1099     /* TODO: renumbering of attributes if the values are higher than the highest supported attribute but the total number of attributes is less than the highest supported attribute */
1100     This->highestConstant = -1;
1101
1102
1103   /**
1104    * First pass to determine what we need to declare:
1105    *  - Temporary variables
1106    *  - Address variables
1107    */
1108     if (NULL != pToken) {
1109         while (D3DVS_END() != *pToken) {
1110             if (vshader_is_version_token(*pToken)) {
1111             /** skip version */
1112             ++pToken;
1113             continue;
1114             }
1115             if (vshader_is_comment_token(*pToken)) { /** comment */
1116                 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
1117                 ++pToken;
1118                 pToken += comment_len;
1119                 continue;
1120             }
1121             curOpcode = vshader_program_get_opcode(*pToken);
1122             ++pToken;
1123             /* TODO: dcl's */
1124             /* TODO: Consts */
1125
1126             if (NULL == curOpcode) {
1127                 while (*pToken & 0x80000000) {
1128                     TRACE("unrecognized opcode: %08lx\n", *pToken);
1129                     /* skip unrecognized opcode */
1130                     ++pToken;
1131                 }
1132             } else {
1133                 if (curOpcode->opcode == D3DSIO_DCL){
1134                     INT usage = *pToken++;
1135                     INT arrayNo = (*pToken++ & 0x00001FFF);
1136                     switch(usage & 0xFFFF) {
1137                     case D3DDECLUSAGE_POSITION:
1138                         if((usage & 0xF0000) >> 16 == 0) { /* tween data */
1139                             TRACE("Setting position to %d\n", arrayNo);
1140                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITION]     = arrayNo;
1141                             This->namedArrays = TRUE;
1142                         } else {
1143                             /* TODO: position indexes go fro 0-8!!*/
1144                             TRACE("Setting position 2 to %d because usage = %d\n", arrayNo, (usage & 0xF0000) >> 16);
1145                             /* robots uses positions upto 8, the position arrays are just packed.*/
1146                             if ((usage & 0xF0000) >> 16 > 1) {
1147                                 TRACE("Loaded for position %d (greater than 2)\n", (usage & 0xF0000) >> 16);
1148                             }
1149                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITION2 + ((usage & 0xF0000) >> 16) -1] = arrayNo;
1150                             This->declaredArrays = TRUE;
1151                         }
1152                     break;
1153                     case D3DDECLUSAGE_BLENDINDICES:
1154                         /* not supported by openGL */
1155                         TRACE("Setting BLENDINDICES to %d\n", arrayNo);
1156                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_BLENDINDICES] = arrayNo;
1157                         This->declaredArrays = TRUE;
1158                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended BLENDINDICES\n");
1159                     break;
1160                     case D3DDECLUSAGE_BLENDWEIGHT:
1161                          TRACE("Setting BLENDWEIGHT to %d\n", arrayNo);
1162                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_BLENDWEIGHT]  = arrayNo;
1163                         This->namedArrays = TRUE;
1164                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended blend weights\n");
1165                     break;
1166                     case D3DDECLUSAGE_NORMAL:
1167                         if((usage & 0xF0000) >> 16 == 0) { /* tween data */
1168                             TRACE("Setting normal to %d\n", arrayNo);
1169                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_NORMAL]   = arrayNo;
1170                             This->namedArrays = TRUE;
1171                         } else {
1172                             TRACE("Setting normal 2 to %d because usage = %d\n", arrayNo, (usage & 0xF0000) >> 16);
1173                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_NORMAL2]   = arrayNo;
1174                             This->declaredArrays = TRUE;
1175                         }
1176                     break;
1177                     case D3DDECLUSAGE_PSIZE:
1178                         TRACE("Setting PSIZE to %d\n", arrayNo);
1179                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_PSIZE]        = arrayNo;
1180                         This->namedArrays = TRUE;
1181                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended PSIZE\n");
1182                     break;
1183                     case D3DDECLUSAGE_COLOR:
1184                         if((usage & 0xF0000) >> 16 == 0)  {
1185                             TRACE("Setting DIFFUSE to %d\n", arrayNo);
1186                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_DIFFUSE]  = arrayNo;
1187                             This->namedArrays = TRUE;
1188                         } else {
1189                             TRACE("Setting SPECULAR to %d\n", arrayNo);
1190                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_SPECULAR] = arrayNo;
1191                             This->namedArrays = TRUE;
1192                         }
1193                     break;
1194                     case D3DDECLUSAGE_TEXCOORD:
1195                         This->namedArrays = TRUE;
1196                         /* only 7 texture coords have been designed for, so run a quick sanity check */
1197                         if ((usage & 0xF0000) >> 16 > 7) {
1198                             FIXME("(%p) : Program uses texture coordinate %d but only 0-7 have been implemented\n", This, (usage & 0xF0000) >> 16);
1199                         } else {
1200                             TRACE("Setting TEXCOORD %d  to %d\n", ((usage & 0xF0000) >> 16), arrayNo);
1201                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_TEXCOORD0 + ((usage & 0xF0000) >> 16)] = arrayNo;
1202                         }
1203                     break;
1204                     /* The following aren't supported by openGL,
1205                         if we get them then everything needs to be mapped to numbered attributes instead of named ones.
1206                         this should be caught in the first pass */
1207                     case D3DDECLUSAGE_TANGENT:
1208                         TRACE("Setting TANGENT to %d\n", arrayNo);
1209                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_TANGENT]      = arrayNo;
1210                         This->declaredArrays = TRUE;
1211                     break;
1212                     case D3DDECLUSAGE_BINORMAL:
1213                         TRACE("Setting BINORMAL to %d\n", arrayNo);
1214                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_BINORMAL]     = arrayNo;
1215                         This->declaredArrays = TRUE;
1216                     break;
1217                     case D3DDECLUSAGE_TESSFACTOR:
1218                         TRACE("Setting TESSFACTOR to %d\n", arrayNo);
1219                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_TESSFACTOR]   = arrayNo;
1220                         This->declaredArrays = TRUE;
1221                     break;
1222                     case D3DDECLUSAGE_POSITIONT:
1223                         if((usage & 0xF0000) >> 16 == 0) { /* tween data */
1224                             FIXME("Setting positiont to %d\n", arrayNo);
1225                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITIONT] = arrayNo;
1226                             This->namedArrays = TRUE;
1227                         } else {
1228                             FIXME("Setting positiont 2 to %d because usage = %d\n", arrayNo, (usage & 0xF0000) >> 16);
1229                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITIONT2] = arrayNo;
1230                             This->declaredArrays = TRUE;
1231                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended positiont\n");
1232                         }
1233                     break;
1234                     case D3DDECLUSAGE_FOG:
1235                         /* supported by OpenGL */
1236                         TRACE("Setting FOG to %d\n", arrayNo);
1237                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_FOG]          = arrayNo;
1238                         This->namedArrays = TRUE;
1239                     break;
1240                     case D3DDECLUSAGE_DEPTH:
1241                         TRACE("Setting DEPTH to %d\n", arrayNo);
1242                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_DEPTH]        = arrayNo;
1243                         This->declaredArrays = TRUE;
1244                     break;
1245                     case D3DDECLUSAGE_SAMPLE:
1246                         TRACE("Setting SAMPLE to %d\n", arrayNo);
1247                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_SAMPLE]       = arrayNo;
1248                         This->declaredArrays = TRUE;
1249                     break;
1250                     default:
1251                     FIXME("Unrecognised dcl %08x", usage & 0xFFFF);
1252                     }
1253                 } else if(curOpcode->opcode == D3DSIO_DEF) {
1254                             This->constantsUsedBitmap[*pToken & 0xFF] = VS_CONSTANT_CONSTANT;
1255                             FIXME("Constant %ld\n", *pToken & 0xFF);
1256                             ++pToken;
1257                             ++pToken;
1258                             ++pToken;
1259                             ++pToken;
1260                             ++pToken;
1261
1262                 } else {
1263                     /* Check to see if and tmp or addressing redisters are used */
1264                     if (curOpcode->num_params > 0) {
1265                         regtype = ((((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT));
1266                         reg = ((*pToken)  & 0x00001FFF);
1267                         if (D3DSPR_ADDR == regtype && nUseAddressRegister <= reg) nUseAddressRegister = reg + 1;
1268                         if (D3DSPR_TEMP == regtype){
1269                             tmpsUsed[reg] = TRUE;
1270                             if(nUseTempRegister    <= reg) nUseTempRegister    = reg + 1;
1271                         }
1272                         ++pToken;
1273                         for (i = 1; i < curOpcode->num_params; ++i) {
1274                             regtype = ((((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT));
1275                             reg = ((*pToken)  & 0x00001FFF);
1276                             if (D3DSPR_ADDR == regtype && nUseAddressRegister <= reg) nUseAddressRegister = reg + 1;
1277                             if (D3DSPR_TEMP == regtype){
1278                                 tmpsUsed[reg] = TRUE;
1279                                 if(nUseTempRegister    <= reg) nUseTempRegister    = reg + 1;
1280                             }
1281                             ++pToken;
1282                         }
1283                     }
1284                 }
1285 #if 1 /* TODO: if the shaders uses calls or loops then we need to convert the shader into glsl */
1286                 if (curOpcode->glname == GLNAME_REQUIRE_GLSL) {
1287                     FIXME("This shader requires gl shader language support\n");
1288 #if 0
1289                     This->shaderLanguage = GLSHADER_GLSL;
1290 #endif
1291                 }
1292 #endif
1293             }
1294         }
1295     }
1296 #if 1
1297 #define VSHADER_ALWAYS_NUMBERED
1298 #endif
1299
1300 #ifdef VSHADER_ALWAYS_NUMBERED /* handy for debugging using numbered arrays instead of named arrays */
1301     /* TODO: using numbered arrays for software shaders makes things easier */
1302     This->declaredArrays = TRUE;
1303 #endif
1304
1305     /* named arrays and declared arrays are mutually exclusive */
1306     if (This->declaredArrays) {
1307         This->namedArrays = FALSE;
1308     }
1309     /* TODO: validate
1310         nUseAddressRegister < = GL_MAX_PROGRAM_ADDRESS_REGISTERS_AR
1311         nUseTempRegister    <=  GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
1312     */
1313
1314   /** second pass, now generate */
1315   pToken = pFunction;
1316
1317   if (NULL != pToken) {
1318     while (1) {
1319       tmpLine[0] = 0;
1320       if ((nRemInstr >= 0) && (--nRemInstr == -1))
1321             /* Macro is finished, continue normal path */
1322             pToken = pSavedToken;
1323       if (D3DVS_END() == *pToken)
1324             break;
1325
1326       if (vshader_is_version_token(*pToken)) { /** version */
1327         /* Extract version *10 into integer value (ie. 1.0 == 10, 1.1==11 etc */
1328         int version = (((*pToken >> 8) & 0x0F) * 10) + (*pToken & 0x0F);
1329         int numTemps;
1330         int numConstants;
1331
1332         TRACE("found version token vs.%lu.%lu;\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
1333
1334         /* Each release of vertex shaders has had different numbers of temp registers */
1335         switch (version) {
1336         case 10:
1337         case 11: numTemps=12;
1338                  numConstants=96;/* min(GL_LIMITS(constants),96) */
1339                  strcpy(tmpLine, "!!ARBvp1.0\n");
1340                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1341                  break;
1342         /* FIXME: if there are no calls or loops then use ARBvp1 otherwise use GLSL instead
1343            TODO: see if there are any operations in vs2/3 that aren't supported by ARBvp
1344             TODO: only map the maximum possible number of constants supported by openGL and not the maximum required by d3d (even better only map the used constants)*/
1345         case 20: numTemps=12; /* min(GL_LIMITS(temps),12) */
1346                  numConstants=96; /* min(GL_LIMITS(constants),256) */
1347                  strcpy(tmpLine, "!!ARBvp1.0\n");
1348                  FIXME("No work done yet to support vs2.0 in hw\n");
1349                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1350                  break;
1351         case 21: numTemps=12; /* min(GL_LIMITS(temps),12) */
1352                  numConstants=96; /* min(GL_LIMITS(constants),256) */
1353                  strcpy(tmpLine, "!!ARBvp1.0\n");
1354                  FIXME("No work done yet to support vs2.1 in hw\n");
1355                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1356                  break;
1357         case 30: numTemps=32; /* min(GL_LIMITS(temps),32) */
1358                  numConstants=96;/* min(GL_LIMITS(constants),256) */
1359                  strcpy(tmpLine, "!!ARBvp3.0\n");
1360                  FIXME("No work done yet to support vs3.0 in hw\n");
1361                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1362                  break;
1363         default:
1364                  numTemps=12;/* min(GL_LIMITS(temps),12) */
1365                  numConstants=96;/* min(GL_LIMITS(constants),96) */
1366                  strcpy(tmpLine, "!!ARBvp1.0\n");
1367                  FIXME("Unrecognized vertex shader version %d!\n", version);
1368         }
1369         PNSTRCAT(pgmStr, tmpLine);
1370
1371         ++lineNum;
1372
1373         /* This should be a bitmap so that only temp registers that are used are declared. */
1374         for (i = 0; i < nUseTempRegister /* we should check numTemps here */ ; i++) {
1375             if (tmpsUsed[i]) { /* only write out the temps if they are actually in use */
1376                 sprintf(tmpLine, "TEMP T%ld;\n", i);
1377                 ++lineNum;
1378                 TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1379                 PNSTRCAT(pgmStr, tmpLine);
1380
1381             }
1382         }
1383         /* TODO: loop register counts as an addres register */
1384         for (i = 0; i < nUseAddressRegister; i++) {
1385             sprintf(tmpLine, "ADDRESS A%ld;\n", i);
1386             ++lineNum;
1387             TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1388                 PNSTRCAT(pgmStr, tmpLine);
1389
1390         }
1391         /* Due to the dynamic constants binding mechanism, we need to declare
1392         * all the constants for relative addressing. */
1393         /* Mesa supports only 95 constants for VS1.X although we should have at least 96. */
1394         if (GL_VEND(MESA) || GL_VEND(WINE)) {
1395             numConstants = 95;
1396         }
1397         /* FIXME: We should  be counting the number of constants in the first pass and then validating that many are supported
1398                 Looking at some of the shaders inuse by applications we'd need to create a list of all used env variables
1399         */
1400         sprintf(tmpLine, "PARAM C[%d] = { program.env[0..%d] };\n", numConstants, numConstants - 1);
1401         TRACE("GL HW (%u,%u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1402         PNSTRCAT(pgmStr, tmpLine);
1403
1404         ++lineNum;
1405
1406         ++pToken;
1407         continue;
1408         }
1409         if (vshader_is_comment_token(*pToken)) { /** comment */
1410             DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
1411             ++pToken;
1412             FIXME("#%s\n", (char*)pToken);
1413             pToken += comment_len;
1414             continue;
1415       }
1416
1417       curOpcode = vshader_program_get_opcode(*pToken);
1418       ++pToken;
1419       if (NULL == curOpcode) {
1420         /* unkown current opcode ... (shouldn't be any!) */
1421         while (*pToken & 0x80000000) {
1422             TRACE("unrecognized opcode: %08lx\n", *pToken);
1423             ++pToken;
1424         }
1425       } else if (GLNAME_REQUIRE_GLSL == curOpcode->glname) {
1426             /* if the token isn't supported by this cross compiler then skip it and it's parameters */
1427
1428             FIXME("Token %s requires greater functionality than Vertex_Progarm_ARB supports\n", curOpcode->name);
1429             pToken += curOpcode->num_params;
1430       } else {
1431         /* Build opcode for GL vertex_program */
1432         switch (curOpcode->opcode) {
1433         case D3DSIO_NOP:
1434             continue;
1435         case D3DSIO_MOV:
1436             /* Address registers must be loaded with the ARL instruction */
1437             if ((((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT) == D3DSPR_ADDR) {
1438                 if (((*pToken) & 0x00001FFF) < nUseAddressRegister) {
1439                     strcpy(tmpLine, "ARL");
1440                     break;
1441                 } else
1442                 FIXME("(%p) Try to load A%ld an undeclared address register!\n", This, ((*pToken) & 0x00001FFF));
1443             }
1444             /* fall through */
1445         case D3DSIO_ADD:
1446         case D3DSIO_SUB:
1447         case D3DSIO_MAD:
1448         case D3DSIO_MUL:
1449         case D3DSIO_RCP:
1450         case D3DSIO_RSQ:
1451         case D3DSIO_DP3:
1452         case D3DSIO_DP4:
1453         case D3DSIO_MIN:
1454         case D3DSIO_MAX:
1455         case D3DSIO_SLT:
1456         case D3DSIO_SGE:
1457         case D3DSIO_LIT:
1458         case D3DSIO_DST:
1459         case D3DSIO_FRC:
1460         case D3DSIO_EXPP:
1461         case D3DSIO_LOGP:
1462         case D3DSIO_EXP:
1463         case D3DSIO_LOG:
1464             strcpy(tmpLine, curOpcode->glname);
1465             break;
1466         case D3DSIO_M4x4:
1467         case D3DSIO_M4x3:
1468         case D3DSIO_M3x4:
1469         case D3DSIO_M3x3:
1470         case D3DSIO_M3x2:
1471             /* Expand the macro and get nusprintf(tmpLine,mber of generated instruction */
1472             nRemInstr = ExpandMxMacro(curOpcode->opcode, pToken);
1473             /* Save point to next instruction */
1474             pSavedToken = pToken + 3;
1475             /* Execute expanded macro */
1476             pToken = MacroExpansion;
1477             continue;
1478         /* dcl and def are handeled in the first pass */
1479         case D3DSIO_DCL:
1480             if (This->namedArrays) {
1481                 const char* attribName = "undefined";
1482                 switch(*pToken & 0xFFFF) {
1483                     case D3DDECLUSAGE_POSITION:
1484                     attribName = "vertex.position";
1485                     break;
1486                     case D3DDECLUSAGE_BLENDINDICES:
1487                     /* not supported by openGL */
1488                     attribName = "vertex.blend";
1489                     break;
1490                     case D3DDECLUSAGE_BLENDWEIGHT:
1491                     attribName = "vertex.weight";
1492                     break;
1493                     case D3DDECLUSAGE_NORMAL:
1494                     attribName = "vertex.normal";
1495                     break;
1496                     case D3DDECLUSAGE_PSIZE:
1497                     attribName = "vertex.psize";
1498                     break;
1499                     case D3DDECLUSAGE_COLOR:
1500                     if((*pToken & 0xF0000) >> 16 == 0)  {
1501                         attribName = "vertex.color";
1502                     } else {
1503                         attribName = "vertex.color.secondary";
1504                     }
1505                     break;
1506                     case D3DDECLUSAGE_TEXCOORD:
1507                     {
1508                         char tmpChar[100];
1509                         tmpChar[0] = 0;
1510                         sprintf(tmpChar,"vertex.texcoord[%lu]",(*pToken & 0xF0000) >> 16);
1511                         attribName = tmpChar;
1512                         break;
1513                     }
1514                     /* The following aren't directly supported by openGL, so shouldn't come up using namedarrays. */
1515                     case D3DDECLUSAGE_TANGENT:
1516                     attribName = "vertex.tangent";
1517                     break;
1518                     case D3DDECLUSAGE_BINORMAL:
1519                     attribName = "vertex.binormal";
1520                     break;
1521                     case D3DDECLUSAGE_TESSFACTOR:
1522                     attribName = "vertex.tessfactor";
1523                     break;
1524                     case D3DDECLUSAGE_POSITIONT:
1525                     attribName = "vertex.possitionT";
1526                     break;
1527                     case D3DDECLUSAGE_FOG:
1528                     attribName = "vertex.fogcoord";
1529                     break;
1530                     case D3DDECLUSAGE_DEPTH:
1531                     attribName = "vertex.depth";
1532                     break;
1533                     case D3DDECLUSAGE_SAMPLE:
1534                     attribName = "vertex.sample";
1535                     break;
1536                     default:
1537                     FIXME("Unrecognised dcl %08lx", *pToken & 0xFFFF);
1538                 }
1539                 {
1540                     char tmpChar[80];
1541                     ++pToken;
1542                     sprintf(tmpLine, "ATTRIB ");
1543                     vshader_program_add_param(*pToken, 0, tmpLine, This->namedArrays, This->constantsUsedBitmap);
1544                     sprintf(tmpChar," = %s", attribName);
1545                     strcat(tmpLine, tmpChar);
1546                     strcat(tmpLine,";\n");
1547                     ++lineNum;
1548                     if (This->namedArrays) {
1549                         TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine);
1550                         PNSTRCAT(pgmStr, tmpLine);
1551
1552                     } else {
1553                         TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine);
1554                     }
1555                 }
1556             } else {
1557                 /* eat the token so it doesn't generate a warning */
1558                 ++pToken;
1559             }
1560             ++pToken;
1561             continue;
1562         case D3DSIO_DEF:
1563             {
1564             char tmpChar[80];
1565             sprintf(tmpLine, "PARAM const%lu = {", *pToken & 0xFF);
1566             ++pToken;
1567             sprintf(tmpChar,"%f ,", *(float *)pToken);
1568             strcat(tmpLine, tmpChar);
1569             ++pToken;
1570             sprintf(tmpChar,"%f ,", *(float *)pToken);
1571             strcat(tmpLine, tmpChar);
1572             ++pToken;
1573             sprintf(tmpChar,"%f ,", *(float *)pToken);
1574             strcat(tmpLine, tmpChar);
1575             ++pToken;
1576             sprintf(tmpChar,"%f}", *(float *)pToken);
1577             strcat(tmpLine, tmpChar);
1578
1579             strcat(tmpLine,";\n");
1580             ++lineNum;
1581             TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1582             PNSTRCAT(pgmStr, tmpLine);
1583
1584             ++pToken;
1585             continue;
1586             }
1587         default:
1588             if (curOpcode->glname == GLNAME_REQUIRE_GLSL) {
1589                 FIXME("Opcode %s requires Gl Shader languange 1.0\n", curOpcode->name);
1590             } else {
1591                 FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
1592             }
1593         }
1594         if (curOpcode->num_params > 0) {
1595             vshader_program_add_param(*pToken, 0, tmpLine, This->namedArrays, This->constantsUsedBitmap);
1596
1597             ++pToken;
1598             for (i = 1; i < curOpcode->num_params; ++i) {
1599                 strcat(tmpLine, ",");
1600                 vshader_program_add_param(*pToken, 1, tmpLine, This->namedArrays, This->constantsUsedBitmap);
1601                 ++pToken;
1602             }
1603         }
1604         strcat(tmpLine,";\n");
1605         ++lineNum;
1606         TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1607         PNSTRCAT(pgmStr, tmpLine);
1608
1609       }
1610     }
1611     strcpy(tmpLine, "END\n");
1612     ++lineNum;
1613     TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1614     PNSTRCAT(pgmStr, tmpLine);
1615
1616   }
1617 /* finally null terminate the pgmStr*/
1618   pgmStr[pgmLength] = 0;
1619   /*  Create the hw shader */
1620     /* TODO: change to resource.glObjectHandel or something like that */
1621   GL_EXTCALL(glGenProgramsARB(1, &This->prgId));
1622   TRACE("Creating a hw vertex shader, prg=%d\n", This->prgId);
1623
1624   GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, This->prgId));
1625
1626
1627   /* Create the program and check for errors */
1628   GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(pgmStr)/*pgmLength*/, pgmStr));
1629   if (glGetError() == GL_INVALID_OPERATION) {
1630     GLint errPos;
1631     glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
1632     FIXME("HW VertexShader Error at position: %d\n%s\n", errPos, glGetString(GL_PROGRAM_ERROR_STRING_ARB));
1633     This->prgId = -1;
1634   }
1635 #if 1 /* if were using the data buffer of device then we don't need to free it */
1636   HeapFree(GetProcessHeap(), 0, pgmStr);
1637 #endif
1638 #undef PNSTRCAT
1639 }
1640
1641 BOOL IWineD3DVertexShaderImpl_ExecuteHAL(IWineD3DVertexShader* iface, WINEVSHADERINPUTDATA* input, WINEVSHADEROUTPUTDATA* output) {
1642   /**
1643    * TODO: use the NV_vertex_program (or 1_1) extension
1644    *  and specifics vendors (ARB_vertex_program??) variants for it
1645    */
1646   return TRUE;
1647 }
1648
1649 HRESULT WINAPI IWineD3DVertexShaderImpl_ExecuteSW(IWineD3DVertexShader* iface, WINEVSHADERINPUTDATA* input, WINEVSHADEROUTPUTDATA* output) {
1650     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1651
1652     /** Vertex Shader Temporary Registers */
1653     WINED3DSHADERVECTOR R[12];
1654       /*D3DSHADERSCALAR A0;*/
1655     WINED3DSHADERVECTOR A[1];
1656     /** temporary Vector for modifier management */
1657     WINED3DSHADERVECTOR d;
1658     WINED3DSHADERVECTOR s[3];
1659     /** parser datas */
1660     const DWORD* pToken = This->function;
1661     const SHADER_OPCODE* curOpcode = NULL;
1662     /** functions parameters */
1663     WINED3DSHADERVECTOR* p[4];
1664     WINED3DSHADERVECTOR* p_send[4];
1665     DWORD i;
1666
1667     /** init temporary register */
1668     memset(R, 0, 12 * sizeof(WINED3DSHADERVECTOR));
1669
1670     /* vshader_program_parse(vshader); */
1671 #if 0 /* Must not be 1 in cvs */
1672     TRACE("Input:\n");
1673     TRACE_VSVECTOR(This->data->C[0]);
1674     TRACE_VSVECTOR(This->data->C[1]);
1675     TRACE_VSVECTOR(This->data->C[2]);
1676     TRACE_VSVECTOR(This->data->C[3]);
1677     TRACE_VSVECTOR(This->data->C[4]);
1678     TRACE_VSVECTOR(This->data->C[5]);
1679     TRACE_VSVECTOR(This->data->C[6]);
1680     TRACE_VSVECTOR(This->data->C[7]);
1681     TRACE_VSVECTOR(This->data->C[8]);
1682     TRACE_VSVECTOR(This->data->C[64]);
1683     TRACE_VSVECTOR(input->V[D3DVSDE_POSITION]);
1684     TRACE_VSVECTOR(input->V[D3DVSDE_BLENDWEIGHT]);
1685     TRACE_VSVECTOR(input->V[D3DVSDE_BLENDINDICES]);
1686     TRACE_VSVECTOR(input->V[D3DVSDE_NORMAL]);
1687     TRACE_VSVECTOR(input->V[D3DVSDE_PSIZE]);
1688     TRACE_VSVECTOR(input->V[D3DVSDE_DIFFUSE]);
1689     TRACE_VSVECTOR(input->V[D3DVSDE_SPECULAR]);
1690     TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD0]);
1691     TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD1]);
1692 #endif
1693
1694     TRACE_VSVECTOR(vshader->data->C[64]);
1695     /* TODO: Run through all the tokens and find and labels, if, endifs, loops etc...., and make a labels list */
1696
1697     /* the first dword is the version tag */
1698     /* TODO: parse it */
1699
1700     if (vshader_is_version_token(*pToken)) { /** version */
1701         ++pToken;
1702     }
1703     while (D3DVS_END() != *pToken) {
1704         if (vshader_is_comment_token(*pToken)) { /** comment */
1705             DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
1706             ++pToken;
1707             pToken += comment_len;
1708             continue ;
1709         }
1710         curOpcode = vshader_program_get_opcode(*pToken);
1711         ++pToken;
1712         if (NULL == curOpcode) {
1713             i = 0;
1714             /* unkown current opcode ... */
1715             /* TODO: Think of a name for 0x80000000 and repalce it's use with a constant */
1716             while (*pToken & 0x80000000) {
1717                 if (i == 0) {
1718                     TRACE("unrecognized opcode: pos=%d token=%08lX\n", (pToken - 1) - This->function, *(pToken - 1));
1719                 }
1720                 TRACE("unrecognized opcode param: pos=%d token=%08lX what=", pToken - This->function, *pToken);
1721                 vshader_program_dump_param(*pToken, i);
1722                 TRACE("\n");
1723                 ++i;
1724                 ++pToken;
1725             }
1726             /* return FALSE; */
1727         } else {
1728             if (curOpcode->num_params > 0) {
1729                 /* TRACE(">> execting opcode: pos=%d opcode_name=%s token=%08lX\n", pToken - vshader->function, curOpcode->name, *pToken); */
1730                 for (i = 0; i < curOpcode->num_params; ++i) {
1731                     DWORD reg = pToken[i] & 0x00001FFF;
1732                     DWORD regtype = ((pToken[i] & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
1733
1734                     switch (regtype << D3DSP_REGTYPE_SHIFT) {
1735                     case D3DSPR_TEMP:
1736                         /* TRACE("p[%d]=R[%d]\n", i, reg); */
1737                         p[i] = &R[reg];
1738                         break;
1739                     case D3DSPR_INPUT:
1740                         /* TRACE("p[%d]=V[%s]\n", i, VertexShaderDeclRegister[reg]); */
1741                         p[i] = &input->V[reg];
1742                         break;
1743                     case D3DSPR_CONST:
1744                         if (pToken[i] & D3DVS_ADDRMODE_RELATIVE) {
1745                             p[i] = &This->data->C[(DWORD) A[0].x + reg];
1746                         } else {
1747                             p[i] = &This->data->C[reg];
1748                         }
1749                         break;
1750                     case D3DSPR_ADDR: /* case D3DSPR_TEXTURE: */
1751                         if (0 != reg) {
1752                             ERR("cannot handle address registers != a0, forcing use of a0\n");
1753                             reg = 0;
1754                         }
1755                         /* TRACE("p[%d]=A[%d]\n", i, reg); */
1756                         p[i] = &A[reg];
1757                         break;
1758                     case D3DSPR_RASTOUT:
1759                         switch (reg) {
1760                         case D3DSRO_POSITION:
1761                             p[i] = &output->oPos;
1762                             break;
1763                         case D3DSRO_FOG:
1764                             p[i] = &output->oFog;
1765                             break;
1766                         case D3DSRO_POINT_SIZE:
1767                             p[i] = &output->oPts;
1768                             break;
1769                         }
1770                         break;
1771                     case D3DSPR_ATTROUT:
1772                         /* TRACE("p[%d]=oD[%d]\n", i, reg); */
1773                         p[i] = &output->oD[reg];
1774                         break;
1775                     case D3DSPR_TEXCRDOUT:
1776                         /* TRACE("p[%d]=oT[%d]\n", i, reg); */
1777                         p[i] = &output->oT[reg];
1778                         break;
1779                     /* TODO Decls and defs */
1780 #if 0
1781                     case D3DSPR_DCL:
1782                     case D3DSPR_DEF:
1783 #endif
1784                     default:
1785                         break;
1786                     }
1787
1788                     if (i > 0) { /* input reg */
1789                         DWORD swizzle = (pToken[i] & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
1790                         UINT isNegative = ((pToken[i] & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG);
1791
1792                         if (!isNegative && (D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) {
1793                             /* TRACE("p[%d] not swizzled\n", i); */
1794                             p_send[i] = p[i];
1795                         } else {
1796                             DWORD swizzle_x = swizzle & 0x03;
1797                             DWORD swizzle_y = (swizzle >> 2) & 0x03;
1798                             DWORD swizzle_z = (swizzle >> 4) & 0x03;
1799                             DWORD swizzle_w = (swizzle >> 6) & 0x03;
1800                             /* TRACE("p[%d] swizzled\n", i); */
1801                             float* tt = (float*) p[i];
1802                             s[i].x = (isNegative) ? -tt[swizzle_x] : tt[swizzle_x];
1803                             s[i].y = (isNegative) ? -tt[swizzle_y] : tt[swizzle_y];
1804                             s[i].z = (isNegative) ? -tt[swizzle_z] : tt[swizzle_z];
1805                             s[i].w = (isNegative) ? -tt[swizzle_w] : tt[swizzle_w];
1806                             p_send[i] = &s[i];
1807                         }
1808                     } else { /* output reg */
1809                         if ((pToken[i] & D3DSP_WRITEMASK_ALL) == D3DSP_WRITEMASK_ALL) {
1810                             p_send[i] = p[i];
1811                         } else {
1812                             p_send[i] = &d; /* to be post-processed for modifiers management */
1813                         }
1814                     }
1815                 }
1816             }
1817
1818             switch (curOpcode->num_params) {
1819             case 0:
1820                 curOpcode->soft_fct();
1821                 break;
1822             case 1:
1823                 curOpcode->soft_fct(p_send[0]);
1824             break;
1825             case 2:
1826                 curOpcode->soft_fct(p_send[0], p_send[1]);
1827                 break;
1828             case 3:
1829                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2]);
1830                 break;
1831             case 4:
1832                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3]);
1833                 break;
1834             case 5:
1835                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4]);
1836                 break;
1837             case 6:
1838                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4], p_send[5]);
1839                 break;
1840             default:
1841                 ERR("%s too many params: %u\n", curOpcode->name, curOpcode->num_params);
1842             }
1843
1844             /* check if output reg modifier post-process */
1845             if (curOpcode->num_params > 0 && (pToken[0] & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
1846                 if (pToken[0] & D3DSP_WRITEMASK_0) p[0]->x = d.x;
1847                 if (pToken[0] & D3DSP_WRITEMASK_1) p[0]->y = d.y;
1848                 if (pToken[0] & D3DSP_WRITEMASK_2) p[0]->z = d.z;
1849                 if (pToken[0] & D3DSP_WRITEMASK_3) p[0]->w = d.w;
1850             }
1851 #if 0
1852             TRACE_VSVECTOR(output->oPos);
1853             TRACE_VSVECTOR(output->oD[0]);
1854             TRACE_VSVECTOR(output->oD[1]);
1855             TRACE_VSVECTOR(output->oT[0]);
1856             TRACE_VSVECTOR(output->oT[1]);
1857             TRACE_VSVECTOR(R[0]);
1858             TRACE_VSVECTOR(R[1]);
1859             TRACE_VSVECTOR(R[2]);
1860             TRACE_VSVECTOR(R[3]);
1861             TRACE_VSVECTOR(R[4]);
1862             TRACE_VSVECTOR(R[5]);
1863 #endif
1864
1865             /* to next opcode token */
1866             pToken += curOpcode->num_params;
1867         }
1868 #if 0
1869         TRACE("End of current instruction:\n");
1870         TRACE_VSVECTOR(output->oPos);
1871         TRACE_VSVECTOR(output->oD[0]);
1872         TRACE_VSVECTOR(output->oD[1]);
1873         TRACE_VSVECTOR(output->oT[0]);
1874         TRACE_VSVECTOR(output->oT[1]);
1875         TRACE_VSVECTOR(R[0]);
1876         TRACE_VSVECTOR(R[1]);
1877         TRACE_VSVECTOR(R[2]);
1878         TRACE_VSVECTOR(R[3]);
1879         TRACE_VSVECTOR(R[4]);
1880         TRACE_VSVECTOR(R[5]);
1881 #endif
1882     }
1883 #if 0 /* Must not be 1 in cvs */
1884     TRACE("Output:\n");
1885     TRACE_VSVECTOR(output->oPos);
1886     TRACE_VSVECTOR(output->oD[0]);
1887     TRACE_VSVECTOR(output->oD[1]);
1888     TRACE_VSVECTOR(output->oT[0]);
1889     TRACE_VSVECTOR(output->oT[1]);
1890 #endif
1891     return D3D_OK;
1892 }
1893
1894 HRESULT WINAPI IWineD3DVertexShaderImpl_SetConstantF(IWineD3DVertexShader *iface, UINT StartRegister, CONST FLOAT *pConstantData, UINT Vector4fCount) {
1895     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1896     FIXME("(%p) : stub\n", This);
1897     return D3D_OK;
1898 }
1899
1900 HRESULT WINAPI IWineD3DVertexShaderImpl_GetConstantF(IWineD3DVertexShader *iface, UINT StartRegister, FLOAT *pConstantData, UINT Vector4fCount) {
1901     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1902     FIXME("(%p) : stub\n", This);
1903     return D3D_OK;
1904 }
1905
1906 HRESULT WINAPI IWineD3DVertexShaderImpl_SetConstantI(IWineD3DVertexShader *iface, UINT StartRegister, CONST int *pConstantData, UINT Vector4iCount) {
1907     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1908     if (StartRegister + Vector4iCount > WINED3D_VSHADER_MAX_CONSTANTS) {
1909         ERR("(%p) : SetVertexShaderConstantI C[%u] invalid\n", This, StartRegister);
1910         return D3DERR_INVALIDCALL;
1911     }
1912     if (NULL == pConstantData) {
1913         return D3DERR_INVALIDCALL;
1914     }
1915     FIXME("(%p) : stub\n", This);
1916     return D3D_OK;
1917 }
1918
1919 HRESULT WINAPI IWineD3DVertexShaderImpl_GetConstantI(IWineD3DVertexShader *iface, UINT StartRegister, int *pConstantData, UINT Vector4iCount) {
1920     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1921     TRACE("(%p) : C[%u] count=%u\n", This, StartRegister, Vector4iCount);
1922     if (StartRegister + Vector4iCount > WINED3D_VSHADER_MAX_CONSTANTS) {
1923         return D3DERR_INVALIDCALL;
1924     }
1925     if (NULL == pConstantData) {
1926         return D3DERR_INVALIDCALL;
1927     }
1928     FIXME("(%p) : stub\n", This);
1929     return D3D_OK;
1930 }
1931
1932 HRESULT WINAPI IWineD3DVertexShaderImpl_SetConstantB(IWineD3DVertexShader *iface, UINT StartRegister, CONST BOOL *pConstantData, UINT BoolCount) {
1933     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1934     if (StartRegister + BoolCount > WINED3D_VSHADER_MAX_CONSTANTS) {
1935         ERR("(%p) : SetVertexShaderConstantB C[%u] invalid\n", This, StartRegister);
1936         return D3DERR_INVALIDCALL;
1937     }
1938     if (NULL == pConstantData) {
1939         return D3DERR_INVALIDCALL;
1940     }
1941     FIXME("(%p) : stub\n", This);
1942     return D3D_OK;
1943 }
1944
1945 HRESULT WINAPI IWineD3DVertexShaderImpl_GetConstantB(IWineD3DVertexShader *iface, UINT StartRegister, BOOL *pConstantData, UINT BoolCount) {
1946     IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl *)iface;
1947     FIXME("(%p) : stub\n", This);
1948     return D3D_OK;
1949 }
1950
1951 #endif
1952
1953 /* *******************************************
1954    IWineD3DVertexShader IUnknown parts follow
1955    ******************************************* */
1956 HRESULT WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj)
1957 {
1958     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1959     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
1960     if (IsEqualGUID(riid, &IID_IUnknown)
1961         || IsEqualGUID(riid, &IID_IWineD3DVertexShader)) {
1962         IUnknown_AddRef(iface);
1963         *ppobj = This;
1964         return D3D_OK;
1965     }
1966     return E_NOINTERFACE;
1967 }
1968
1969 ULONG WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
1970     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1971     TRACE("(%p) : AddRef increasing from %ld\n", This, This->ref);
1972     return InterlockedIncrement(&This->ref);
1973 }
1974
1975 ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
1976     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1977     ULONG ref;
1978     TRACE("(%p) : Releasing from %ld\n", This, This->ref);
1979     ref = InterlockedDecrement(&This->ref);
1980     if (ref == 0) {
1981         HeapFree(GetProcessHeap(), 0, This);
1982     }
1983     return ref;
1984 }
1985
1986 /* *******************************************
1987    IWineD3DVertexShader IWineD3DVertexShader parts follow
1988    ******************************************* */
1989
1990 HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){
1991     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1992
1993     *parent = (IUnknown*)This->parent;
1994     IUnknown_AddRef(*parent);
1995     TRACE("(%p) : returning %p\n", This, *parent);
1996     return D3D_OK;
1997 }
1998
1999 HRESULT WINAPI IWineD3DVertexShaderImpl_GetDevice(IWineD3DVertexShader* iface, IWineD3DDevice **pDevice){
2000     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
2001     IWineD3DDevice_AddRef((IWineD3DDevice *)This->wineD3DDevice);
2002     *pDevice = (IWineD3DDevice *)This->wineD3DDevice;
2003     TRACE("(%p) returning %p\n", This, *pDevice);
2004     return D3D_OK;
2005 }
2006
2007 HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* impl, VOID* pData, UINT* pSizeOfData) {
2008     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)impl;
2009     FIXME("(%p) : pData(%p), pSizeOfData(%p)\n", This, pData, pSizeOfData);
2010
2011     if (NULL == pData) {
2012         *pSizeOfData = This->functionLength;
2013         return D3D_OK;
2014     }
2015     if (*pSizeOfData < This->functionLength) {
2016         *pSizeOfData = This->functionLength;
2017         return D3DERR_MOREDATA;
2018     }
2019     if (NULL == This->function) { /* no function defined */
2020         TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
2021         (*(DWORD **) pData) = NULL;
2022     } else {
2023         if(This->functionLength == 0){
2024
2025         }
2026         TRACE("(%p) : GetFunction copying to %p\n", This, pData);
2027         memcpy(pData, This->function, This->functionLength);
2028     }
2029     return D3D_OK;
2030 }
2031
2032 HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader *iface, CONST DWORD *pFunction) {
2033     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
2034     const DWORD* pToken = pFunction;
2035     const SHADER_OPCODE* curOpcode = NULL;
2036     DWORD len = 0;
2037     DWORD i;
2038     TRACE("(%p) : Parsing programme\n", This);
2039
2040     if (NULL != pToken) {
2041         while (D3DVS_END() != *pToken) {
2042             if (vshader_is_version_token(*pToken)) { /** version */
2043                 TRACE("vs_%lu_%lu\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
2044                 ++pToken;
2045                 ++len;
2046                 continue;
2047             }
2048             if (vshader_is_comment_token(*pToken)) { /** comment */
2049                 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
2050                 ++pToken;
2051                 TRACE("//%s\n", (char*)pToken);
2052                 pToken += comment_len;
2053                 len += comment_len + 1;
2054                 continue;
2055             }
2056             curOpcode = vshader_program_get_opcode(*pToken);
2057             ++pToken;
2058             ++len;
2059             if (NULL == curOpcode) {
2060                 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
2061                 while (*pToken & 0x80000000) {
2062                     /* unkown current opcode ... */
2063                         TRACE("unrecognized opcode: %08lx", *pToken);
2064                     ++pToken;
2065                     ++len;
2066                     TRACE("\n");
2067                 }
2068
2069             } else {
2070                 if (curOpcode->opcode == D3DSIO_DCL) {
2071                     TRACE("dcl_");
2072                     switch(*pToken & 0xFFFF) {
2073                         case D3DDECLUSAGE_POSITION:
2074                         TRACE("%s%ld ", "position",(*pToken & 0xF0000) >> 16);
2075                         break;
2076                         case D3DDECLUSAGE_BLENDINDICES:
2077                         TRACE("%s ", "blend");
2078                         break;
2079                         case D3DDECLUSAGE_BLENDWEIGHT:
2080                         TRACE("%s ", "weight");
2081                         break;
2082                         case D3DDECLUSAGE_NORMAL:
2083                         TRACE("%s%ld ", "normal",(*pToken & 0xF0000) >> 16);
2084                         break;
2085                         case D3DDECLUSAGE_PSIZE:
2086                         TRACE("%s ", "psize");
2087                         break;
2088                         case D3DDECLUSAGE_COLOR:
2089                         if((*pToken & 0xF0000) >> 16 == 0)  {
2090                             TRACE("%s ", "color");
2091                         } else {
2092                             TRACE("%s ", "specular");
2093                         }
2094                         break;
2095                         case D3DDECLUSAGE_TEXCOORD:
2096                         TRACE("%s%ld ", "texture", (*pToken & 0xF0000) >> 16);
2097                         break;
2098                         case D3DDECLUSAGE_TANGENT:
2099                         TRACE("%s ", "tangent");
2100                         break;
2101                         case D3DDECLUSAGE_BINORMAL:
2102                         TRACE("%s ", "binormal");
2103                         break;
2104                         case D3DDECLUSAGE_TESSFACTOR:
2105                         TRACE("%s ", "tessfactor");
2106                         break;
2107                         case D3DDECLUSAGE_POSITIONT:
2108                         TRACE("%s%ld ", "positionT",(*pToken & 0xF0000) >> 16);
2109                         break;
2110                         case D3DDECLUSAGE_FOG:
2111                         TRACE("%s ", "fog");
2112                         break;
2113                         case D3DDECLUSAGE_DEPTH:
2114                         TRACE("%s ", "depth");
2115                         break;
2116                         case D3DDECLUSAGE_SAMPLE:
2117                         TRACE("%s ", "sample");
2118                         break;
2119                         default:
2120                         FIXME("Unrecognised dcl %08lx", *pToken & 0xFFFF);
2121                     }
2122                     ++pToken;
2123                     ++len;
2124                     vshader_program_dump_vs_param(*pToken, 0);
2125                     ++pToken;
2126                     ++len;
2127                 } else
2128                     if (curOpcode->opcode == D3DSIO_DEF) {
2129                         TRACE("def c%lu = ", *pToken & 0xFF);
2130                         ++pToken;
2131                         ++len;
2132                         TRACE("%f ,", *(float *)pToken);
2133                         ++pToken;
2134                         ++len;
2135                         TRACE("%f ,", *(float *)pToken);
2136                         ++pToken;
2137                         ++len;
2138                         TRACE("%f ,", *(float *)pToken);
2139                         ++pToken;
2140                         ++len;
2141                         TRACE("%f", *(float *)pToken);
2142                         ++pToken;
2143                         ++len;
2144                 } else {
2145                     TRACE("%s ", curOpcode->name);
2146                     if (curOpcode->num_params > 0) {
2147                         vshader_program_dump_vs_param(*pToken, 0);
2148                         ++pToken;
2149                         ++len;
2150                         for (i = 1; i < curOpcode->num_params; ++i) {
2151                             TRACE(", ");
2152                             vshader_program_dump_vs_param(*pToken, 1);
2153                             ++pToken;
2154                             ++len;
2155                         }
2156                     }
2157                 }
2158                 TRACE("\n");
2159             }
2160         }
2161         This->functionLength = (len + 1) * sizeof(DWORD);
2162     } else {
2163         This->functionLength = 1; /* no Function defined use fixed function vertex processing */
2164     }
2165
2166     /* Generate HW shader in needed */
2167     if (NULL != pFunction  && wined3d_settings.vs_mode == VS_HW) {
2168 #if 1
2169         IWineD3DVertexShaderImpl_GenerateProgramArbHW(iface, pFunction);
2170 #endif
2171     }
2172
2173     /* copy the function ... because it will certainly be released by application */
2174     if (NULL != pFunction) {
2175         This->function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->functionLength);
2176         memcpy((void *)This->function, pFunction, This->functionLength);
2177     } else {
2178         This->function = NULL;
2179     }
2180     return D3D_OK;
2181 }
2182
2183 const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
2184 {
2185     /*** IUnknown methods ***/
2186     IWineD3DVertexShaderImpl_QueryInterface,
2187     IWineD3DVertexShaderImpl_AddRef,
2188     IWineD3DVertexShaderImpl_Release,
2189     /*** IWineD3DVertexShader methods ***/
2190     IWineD3DVertexShaderImpl_GetParent,
2191     IWineD3DVertexShaderImpl_GetDevice,
2192     IWineD3DVertexShaderImpl_GetFunction,
2193     IWineD3DVertexShaderImpl_SetFunction
2194 };