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[3][4];
 281 typedef FLOAT D3DMATRIX33[3][3];
 282 typedef FLOAT D3DMATRIX23[2][3];
 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, D3DMATRIX34 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, D3DMATRIX43 mat) {
 317   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
 318   d->y = mat[1][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[0][2] * s0->z;
 329   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][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, D3DMATRIX23 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) {
 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->w;
 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", 4, 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 easily 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 as VS_ARB using one temporary 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 operation */
 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_output_param_swizzle(const DWORD param, int is_color, char *hwLine) {
 891     /** operand output */
 892     if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 893       strcat(hwLine, ".");
 894       if (param & D3DSP_WRITEMASK_0) { strcat(hwLine, "x"); }
 895       if (param & D3DSP_WRITEMASK_1) { strcat(hwLine, "y"); }
 896       if (param & D3DSP_WRITEMASK_2) { strcat(hwLine, "z"); }
 897       if (param & D3DSP_WRITEMASK_3) { strcat(hwLine, "w"); }
 898     }
 899 }
 900
 901 inline static void vshader_program_add_input_param_swizzle(const DWORD param, int is_color, char *hwLine) {
 902     static const char swizzle_reg_chars_color_fix[] = "zyxw";
 903     static const char swizzle_reg_chars[] = "xyzw";
 904     const char* swizzle_regs = NULL;
 905     char  tmpReg[255];
 906
 907     /** operand input */
 908     DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 909     DWORD swizzle_x = swizzle & 0x03;
 910     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 911     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 912     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 913
 914     if (is_color) {
 915       swizzle_regs = swizzle_reg_chars_color_fix;
 916     } else {
 917       swizzle_regs = swizzle_reg_chars;
 918     }
 919
 920     /**
 921      * swizzle bits fields:
 922      *  WWZZYYXX
 923      */
 924     if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) { /* D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 925       if (is_color) {
 926         sprintf(tmpReg, ".%c%c%c%c",
 927                 swizzle_regs[swizzle_x],
 928                 swizzle_regs[swizzle_y],
 929                 swizzle_regs[swizzle_z],
 930                 swizzle_regs[swizzle_w]);
 931         strcat(hwLine, tmpReg);
 932       }
 933       return ;
 934     }
 935     if (swizzle_x == swizzle_y &&
 936         swizzle_x == swizzle_z &&
 937         swizzle_x == swizzle_w)
 938     {
 939       sprintf(tmpReg, ".%c", swizzle_regs[swizzle_x]);
 940       strcat(hwLine, tmpReg);
 941     } else {
 942       sprintf(tmpReg, ".%c%c%c%c",
 943               swizzle_regs[swizzle_x],
 944               swizzle_regs[swizzle_y],
 945               swizzle_regs[swizzle_z],
 946               swizzle_regs[swizzle_w]);
 947       strcat(hwLine, tmpReg);
 948     }
 949 }
 950
 951 inline static void vshader_program_add_param(IWineD3DVertexShaderImpl *This, const DWORD param, BOOL is_input, char *hwLine) {
 952   /* oPos, oFog and oPts in D3D */
 953   static const char* hwrastout_reg_names[] = { "result.position", "result.fogcoord", "result.pointsize" };
 954
 955   DWORD reg = param & 0x00001FFF;
 956   DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
 957   char  tmpReg[255];
 958   BOOL is_color = FALSE;
 959
 960   if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) {
 961       strcat(hwLine, " -");
 962   } else {
 963       strcat(hwLine, " ");
 964   }
 965
 966   switch (regtype) {
 967   case D3DSPR_TEMP:
 968     sprintf(tmpReg, "T%lu", reg);
 969     strcat(hwLine, tmpReg);
 970     break;
 971   case D3DSPR_INPUT:
 972     if (reg == This->arrayUsageMap[WINED3DSHADERDECLUSAGE_DIFFUSE]
 973         || reg == This->arrayUsageMap[WINED3DSHADERDECLUSAGE_SPECULAR]) {
 974         is_color = TRUE;
 975     }
 976     /* if the attributes come in as named dcl's then use a named vertex (called namedVertexN) */
 977     if (This->namedArrays) {
 978         sprintf(tmpReg, "namedVertex%lu", reg);
 979     } else {
 980     /* otherwise the input is on a numbered attribute so use opengl numbered attributes */
 981         sprintf(tmpReg, "vertex.attrib[%lu]", reg);
 982     }
 983     strcat(hwLine, tmpReg);
 984     break;
 985   case D3DSPR_CONST:
 986     /* FIXME: some constants are named so we need a constants map*/
 987     if (This->constantsUsedBitmap[reg] == VS_CONSTANT_CONSTANT) {
 988         if (param & D3DVS_ADDRMODE_RELATIVE) {
 989             FIXME("Relative addressing not expected for a named constant %lu\n", reg);
 990         }
 991         sprintf(tmpReg, "const%lu", reg);
 992     } else {
 993         sprintf(tmpReg, "C[%s%lu]", (param & D3DVS_ADDRMODE_RELATIVE) ? "A0.x + " : "", reg);
 994     }
 995     strcat(hwLine, tmpReg);
 996     break;
 997   case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 998     sprintf(tmpReg, "A%lu", reg);
 999     strcat(hwLine, tmpReg);
1000     break;
1001   case D3DSPR_RASTOUT:
1002     sprintf(tmpReg, "%s", hwrastout_reg_names[reg]);
1003     strcat(hwLine, tmpReg);
1004     break;
1005   case D3DSPR_ATTROUT:
1006     if (reg==0) {
1007        strcat(hwLine, "result.color.primary");
1008     } else {
1009        strcat(hwLine, "result.color.secondary");
1010     }
1011     break;
1012   case D3DSPR_TEXCRDOUT:
1013     sprintf(tmpReg, "result.texcoord[%lu]", reg);
1014     strcat(hwLine, tmpReg);
1015     break;
1016   default:
1017     FIXME("Unknown reg type %ld %ld\n", regtype, reg);
1018     break;
1019   }
1020
1021   if (!is_input) {
1022     vshader_program_add_output_param_swizzle(param, is_color, hwLine);
1023   } else {
1024     vshader_program_add_input_param_swizzle(param, is_color, hwLine);
1025   }
1026 }
1027
1028 DWORD MacroExpansion[4*4];
1029
1030 int ExpandMxMacro(DWORD macro_opcode, const DWORD* args) {
1031   int i;
1032   int nComponents = 0;
1033   DWORD opcode =0;
1034   switch(macro_opcode) {
1035     case D3DSIO_M4x4:
1036       nComponents = 4;
1037       opcode = D3DSIO_DP4;
1038       break;
1039     case D3DSIO_M4x3:
1040       nComponents = 3;
1041       opcode = D3DSIO_DP4;
1042       break;
1043     case D3DSIO_M3x4:
1044       nComponents = 4;
1045       opcode = D3DSIO_DP3;
1046       break;
1047     case D3DSIO_M3x3:
1048       nComponents = 3;
1049       opcode = D3DSIO_DP3;
1050       break;
1051     case D3DSIO_M3x2:
1052       nComponents = 2;
1053       opcode = D3DSIO_DP3;
1054       break;
1055     default:
1056       break;
1057   }
1058   for (i = 0; i < nComponents; i++) {
1059     MacroExpansion[i*4+0] = opcode;
1060     MacroExpansion[i*4+1] = ((*args) & ~D3DSP_WRITEMASK_ALL)|(D3DSP_WRITEMASK_0<<i);
1061     MacroExpansion[i*4+2] = *(args+1);
1062     MacroExpansion[i*4+3] = (*(args+2))+i;
1063   }
1064   return nComponents;
1065 }
1066
1067 /**
1068  * Function parser ...
1069  */
1070
1071 inline static VOID IWineD3DVertexShaderImpl_GenerateProgramArbHW(IWineD3DVertexShader *iface, CONST DWORD* pFunction) {
1072     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1073     const DWORD* pToken = pFunction;
1074     const DWORD* pSavedToken = NULL;
1075     const SHADER_OPCODE* curOpcode = NULL;
1076     int nRemInstr = -1;
1077     DWORD i;
1078     unsigned lineNum = 0;
1079     char *pgmStr = NULL;
1080     char  tmpLine[255];
1081     DWORD nUseAddressRegister = 0;
1082     DWORD nUseTempRegister = 0;
1083     DWORD regtype;
1084     DWORD reg;
1085     BOOL tmpsUsed[32];
1086 #if 0 /* TODO: loope register (just another address register ) */
1087     BOOL hasLoops = FALSE;
1088 #endif
1089
1090 #define PGMSIZE 65535
1091 /* Keep a running length for pgmStr so that we don't have to caculate strlen every time we concatanate */
1092     int pgmLength = 0;
1093
1094 #if 0 /* FIXME: Use the buffer that is held by the device, this is ok since fixups will be skipped for software shaders
1095         it also requires entering a critical section but cuts down the runtime footprint of wined3d and any memory fragmentation that may occur... */
1096     if (This->device->fixupVertexBufferSize < PGMSIZE) {
1097         HeapFree(GetProcessHeap(), 0, This->fixupVertexBuffer);
1098         This->fixupVertexBuffer = HeapAlloc(GetProcessHeap() , 0, PGMSIZE);
1099         This->fixupVertexBufferSize = PGMSIZE;
1100         This->fixupVertexBuffer[0] = 0;
1101     }
1102     pgmStr = This->device->fixupVertexBuffer;
1103 #endif
1104 #define PNSTRCAT(_pgmStr, _tmpLine) { \
1105         int _tmpLineLen = strlen(_tmpLine); \
1106         if(_tmpLineLen + pgmLength > PGMSIZE) { \
1107             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); \
1108         } else { \
1109            memcpy(_pgmStr + pgmLength, _tmpLine, _tmpLineLen); \
1110         } \
1111         pgmLength += _tmpLineLen; \
1112         }
1113
1114     pgmStr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 65535); /* 64kb should be enough */
1115     /* Initialise the shader */
1116     This->namedArrays = FALSE;
1117     This->declaredArrays = FALSE;
1118     for (i = 0; i < WINED3DSHADERDECLUSAGE_MAX_USAGE; i++) {
1119         This->arrayUsageMap[i] = -1;
1120     }
1121     /* set all the tmpsUsed to not used */
1122     memset(tmpsUsed, FALSE , sizeof(tmpsUsed));
1123
1124     /* 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 */
1125     This->highestConstant = -1;
1126
1127
1128   /**
1129    * First pass to determine what we need to declare:
1130    *  - Temporary variables
1131    *  - Address variables
1132    */
1133     if (NULL != pToken) {
1134         while (D3DVS_END() != *pToken) {
1135             if (vshader_is_version_token(*pToken)) {
1136             /** skip version */
1137             ++pToken;
1138             continue;
1139             }
1140             if (vshader_is_comment_token(*pToken)) { /** comment */
1141                 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
1142                 ++pToken;
1143                 pToken += comment_len;
1144                 continue;
1145             }
1146             curOpcode = vshader_program_get_opcode(*pToken);
1147             ++pToken;
1148             /* TODO: dcl's */
1149             /* TODO: Consts */
1150
1151             if (NULL == curOpcode) {
1152                 while (*pToken & 0x80000000) {
1153                     FIXME("unrecognized opcode: %08lx\n", *pToken);
1154                     /* skip unrecognized opcode */
1155                     ++pToken;
1156                 }
1157             } else {
1158                 if (curOpcode->opcode == D3DSIO_DCL){
1159                     INT usage = *pToken++;
1160                     INT arrayNo = (*pToken++ & 0x00001FFF);
1161                     switch(usage & 0xFFFF) {
1162                     case D3DDECLUSAGE_POSITION:
1163                         if((usage & 0xF0000) >> 16 == 0) { /* tween data */
1164                             TRACE("Setting position to %d\n", arrayNo);
1165                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITION]     = arrayNo;
1166                             This->namedArrays = TRUE;
1167                         } else {
1168                             /* TODO: position indexes go from 0-8!!*/
1169                             TRACE("Setting position 2 to %d because usage = %d\n", arrayNo, (usage & 0xF0000) >> 16);
1170                             /* robots uses positions up to 8, the position arrays are just packed.*/
1171                             if ((usage & 0xF0000) >> 16 > 1) {
1172                                 TRACE("Loaded for position %d (greater than 2)\n", (usage & 0xF0000) >> 16);
1173                             }
1174                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITION2 + ((usage & 0xF0000) >> 16) -1] = arrayNo;
1175                             This->declaredArrays = TRUE;
1176                         }
1177                     break;
1178                     case D3DDECLUSAGE_BLENDINDICES:
1179                         /* not supported by openGL */
1180                         TRACE("Setting BLENDINDICES to %d\n", arrayNo);
1181                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_BLENDINDICES] = arrayNo;
1182                         This->declaredArrays = TRUE;
1183                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended BLENDINDICES\n");
1184                     break;
1185                     case D3DDECLUSAGE_BLENDWEIGHT:
1186                          TRACE("Setting BLENDWEIGHT to %d\n", arrayNo);
1187                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_BLENDWEIGHT]  = arrayNo;
1188                         This->namedArrays = TRUE;
1189                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended blend weights\n");
1190                     break;
1191                     case D3DDECLUSAGE_NORMAL:
1192                         if((usage & 0xF0000) >> 16 == 0) { /* tween data */
1193                             TRACE("Setting normal to %d\n", arrayNo);
1194                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_NORMAL]   = arrayNo;
1195                             This->namedArrays = TRUE;
1196                         } else {
1197                             TRACE("Setting normal 2 to %d because usage = %d\n", arrayNo, (usage & 0xF0000) >> 16);
1198                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_NORMAL2]   = arrayNo;
1199                             This->declaredArrays = TRUE;
1200                         }
1201                     break;
1202                     case D3DDECLUSAGE_PSIZE:
1203                         TRACE("Setting PSIZE to %d\n", arrayNo);
1204                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_PSIZE]        = arrayNo;
1205                         This->namedArrays = TRUE;
1206                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended PSIZE\n");
1207                     break;
1208                     case D3DDECLUSAGE_COLOR:
1209                         if((usage & 0xF0000) >> 16 == 0)  {
1210                             TRACE("Setting DIFFUSE to %d\n", arrayNo);
1211                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_DIFFUSE]  = arrayNo;
1212                             This->namedArrays = TRUE;
1213                         } else {
1214                             TRACE("Setting SPECULAR to %d\n", arrayNo);
1215                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_SPECULAR] = arrayNo;
1216                             This->namedArrays = TRUE;
1217                         }
1218                     break;
1219                     case D3DDECLUSAGE_TEXCOORD:
1220                         This->namedArrays = TRUE;
1221                         /* only 7 texture coords have been designed for, so run a quick sanity check */
1222                         if ((usage & 0xF0000) >> 16 > 7) {
1223                             FIXME("(%p) : Program uses texture coordinate %d but only 0-7 have been implemented\n", This, (usage & 0xF0000) >> 16);
1224                         } else {
1225                             TRACE("Setting TEXCOORD %d  to %d\n", ((usage & 0xF0000) >> 16), arrayNo);
1226                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_TEXCOORD0 + ((usage & 0xF0000) >> 16)] = arrayNo;
1227                         }
1228                     break;
1229                     /* The following aren't supported by openGL,
1230                         if we get them then everything needs to be mapped to numbered attributes instead of named ones.
1231                         this should be caught in the first pass */
1232                     case D3DDECLUSAGE_TANGENT:
1233                         TRACE("Setting TANGENT to %d\n", arrayNo);
1234                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_TANGENT]      = arrayNo;
1235                         This->declaredArrays = TRUE;
1236                     break;
1237                     case D3DDECLUSAGE_BINORMAL:
1238                         TRACE("Setting BINORMAL to %d\n", arrayNo);
1239                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_BINORMAL]     = arrayNo;
1240                         This->declaredArrays = TRUE;
1241                     break;
1242                     case D3DDECLUSAGE_TESSFACTOR:
1243                         TRACE("Setting TESSFACTOR to %d\n", arrayNo);
1244                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_TESSFACTOR]   = arrayNo;
1245                         This->declaredArrays = TRUE;
1246                     break;
1247                     case D3DDECLUSAGE_POSITIONT:
1248                         if((usage & 0xF0000) >> 16 == 0) { /* tween data */
1249                             FIXME("Setting positiont to %d\n", arrayNo);
1250                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITIONT] = arrayNo;
1251                             This->namedArrays = TRUE;
1252                         } else {
1253                             FIXME("Setting positiont 2 to %d because usage = %d\n", arrayNo, (usage & 0xF0000) >> 16);
1254                             This->arrayUsageMap[WINED3DSHADERDECLUSAGE_POSITIONT2] = arrayNo;
1255                             This->declaredArrays = TRUE;
1256                         if ((usage & 0xF0000) >> 16 != 0) FIXME("Extended positiont\n");
1257                         }
1258                     break;
1259                     case D3DDECLUSAGE_FOG:
1260                         /* supported by OpenGL */
1261                         TRACE("Setting FOG to %d\n", arrayNo);
1262                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_FOG]          = arrayNo;
1263                         This->namedArrays = TRUE;
1264                     break;
1265                     case D3DDECLUSAGE_DEPTH:
1266                         TRACE("Setting DEPTH to %d\n", arrayNo);
1267                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_DEPTH]        = arrayNo;
1268                         This->declaredArrays = TRUE;
1269                     break;
1270                     case D3DDECLUSAGE_SAMPLE:
1271                         TRACE("Setting SAMPLE to %d\n", arrayNo);
1272                         This->arrayUsageMap[WINED3DSHADERDECLUSAGE_SAMPLE]       = arrayNo;
1273                         This->declaredArrays = TRUE;
1274                     break;
1275                     default:
1276                     FIXME("Unrecognised dcl %08x", usage & 0xFFFF);
1277                     }
1278                 } else if(curOpcode->opcode == D3DSIO_DEF) {
1279                             This->constantsUsedBitmap[*pToken & 0xFF] = VS_CONSTANT_CONSTANT;
1280                             FIXME("Constant %ld\n", *pToken & 0xFF);
1281                             ++pToken;
1282                             ++pToken;
1283                             ++pToken;
1284                             ++pToken;
1285                             ++pToken;
1286
1287                 } else {
1288                     /* Check to see if and tmp or addressing redisters are used */
1289                     if (curOpcode->num_params > 0) {
1290                         regtype = ((((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT));
1291                         reg = ((*pToken)  & 0x00001FFF);
1292                         if (D3DSPR_ADDR == regtype && nUseAddressRegister <= reg) nUseAddressRegister = reg + 1;
1293                         if (D3DSPR_TEMP == regtype){
1294                             tmpsUsed[reg] = TRUE;
1295                             if(nUseTempRegister    <= reg) nUseTempRegister    = reg + 1;
1296                         }
1297                         ++pToken;
1298                         for (i = 1; i < curOpcode->num_params; ++i) {
1299                             regtype = ((((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT));
1300                             reg = ((*pToken)  & 0x00001FFF);
1301                             if (D3DSPR_ADDR == regtype && nUseAddressRegister <= reg) nUseAddressRegister = reg + 1;
1302                             if (D3DSPR_TEMP == regtype){
1303                                 tmpsUsed[reg] = TRUE;
1304                                 if(nUseTempRegister    <= reg) nUseTempRegister    = reg + 1;
1305                             }
1306                             ++pToken;
1307                         }
1308                     }
1309                 }
1310 #if 1 /* TODO: if the shaders uses calls or loops then we need to convert the shader into glsl */
1311                 if (curOpcode->glname == GLNAME_REQUIRE_GLSL) {
1312                     FIXME("This shader requires gl shader language support\n");
1313 #if 0
1314                     This->shaderLanguage = GLSHADER_GLSL;
1315 #endif
1316                 }
1317 #endif
1318             }
1319         }
1320     }
1321 #if 1
1322 #define VSHADER_ALWAYS_NUMBERED
1323 #endif
1324
1325 #ifdef VSHADER_ALWAYS_NUMBERED /* handy for debugging using numbered arrays instead of named arrays */
1326     /* TODO: using numbered arrays for software shaders makes things easier */
1327     This->declaredArrays = TRUE;
1328 #endif
1329
1330     /* named arrays and declared arrays are mutually exclusive */
1331     if (This->declaredArrays) {
1332         This->namedArrays = FALSE;
1333     }
1334     /* TODO: validate
1335         nUseAddressRegister < = GL_MAX_PROGRAM_ADDRESS_REGISTERS_AR
1336         nUseTempRegister    <=  GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
1337     */
1338
1339   /** second pass, now generate */
1340   pToken = pFunction;
1341
1342   if (NULL != pToken) {
1343     while (1) {
1344       tmpLine[0] = 0;
1345       if ((nRemInstr >= 0) && (--nRemInstr == -1))
1346             /* Macro is finished, continue normal path */
1347             pToken = pSavedToken;
1348       if (D3DVS_END() == *pToken)
1349             break;
1350
1351       if (vshader_is_version_token(*pToken)) { /** version */
1352         /* Extract version *10 into integer value (ie. 1.0 == 10, 1.1==11 etc */
1353         int version = (((*pToken >> 8) & 0x0F) * 10) + (*pToken & 0x0F);
1354         int numTemps;
1355         int numConstants;
1356
1357         TRACE("found version token vs.%lu.%lu;\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
1358
1359         /* Each release of vertex shaders has had different numbers of temp registers */
1360         switch (version) {
1361         case 10:
1362         case 11: numTemps=12;
1363                  numConstants=96;/* min(GL_LIMITS(constants),96) */
1364                  strcpy(tmpLine, "!!ARBvp1.0\n");
1365                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1366                  break;
1367         /* FIXME: if there are no calls or loops then use ARBvp1 otherwise use GLSL instead
1368            TODO: see if there are any operations in vs2/3 that aren't supported by ARBvp
1369             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)*/
1370         case 20: numTemps=12; /* min(GL_LIMITS(temps),12) */
1371                  numConstants=96; /* min(GL_LIMITS(constants),256) */
1372                  strcpy(tmpLine, "!!ARBvp1.0\n");
1373                  FIXME("No work done yet to support vs2.0 in hw\n");
1374                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1375                  break;
1376         case 21: numTemps=12; /* min(GL_LIMITS(temps),12) */
1377                  numConstants=96; /* min(GL_LIMITS(constants),256) */
1378                  strcpy(tmpLine, "!!ARBvp1.0\n");
1379                  FIXME("No work done yet to support vs2.1 in hw\n");
1380                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1381                  break;
1382         case 30: numTemps=32; /* min(GL_LIMITS(temps),32) */
1383                  numConstants=96;/* min(GL_LIMITS(constants),256) */
1384                  strcpy(tmpLine, "!!ARBvp3.0\n");
1385                  FIXME("No work done yet to support vs3.0 in hw\n");
1386                  TRACE("GL HW (%u) : %s", pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1387                  break;
1388         default:
1389                  numTemps=12;/* min(GL_LIMITS(temps),12) */
1390                  numConstants=96;/* min(GL_LIMITS(constants),96) */
1391                  strcpy(tmpLine, "!!ARBvp1.0\n");
1392                  FIXME("Unrecognized vertex shader version %d!\n", version);
1393         }
1394         PNSTRCAT(pgmStr, tmpLine);
1395
1396         ++lineNum;
1397
1398         /* This should be a bitmap so that only temp registers that are used are declared. */
1399         for (i = 0; i < nUseTempRegister /* we should check numTemps here */ ; i++) {
1400             if (tmpsUsed[i]) { /* only write out the temps if they are actually in use */
1401                 sprintf(tmpLine, "TEMP T%ld;\n", i);
1402                 ++lineNum;
1403                 TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1404                 PNSTRCAT(pgmStr, tmpLine);
1405
1406             }
1407         }
1408         /* TODO: loop register counts as an address register */
1409         for (i = 0; i < nUseAddressRegister; i++) {
1410             sprintf(tmpLine, "ADDRESS A%ld;\n", i);
1411             ++lineNum;
1412             TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1413                 PNSTRCAT(pgmStr, tmpLine);
1414
1415         }
1416         /* Due to the dynamic constants binding mechanism, we need to declare
1417         * all the constants for relative addressing. */
1418         /* Mesa supports only 95 constants for VS1.X although we should have at least 96. */
1419         if (GL_VEND(MESA) || GL_VEND(WINE)) {
1420             numConstants = 95;
1421         }
1422         /* FIXME: We should  be counting the number of constants in the first pass and then validating that many are supported
1423                 Looking at some of the shaders in use by applications we'd need to create a list of all used env variables
1424         */
1425         sprintf(tmpLine, "PARAM C[%d] = { program.env[0..%d] };\n", numConstants, numConstants - 1);
1426         TRACE("GL HW (%u,%u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1427         PNSTRCAT(pgmStr, tmpLine);
1428
1429         ++lineNum;
1430
1431         ++pToken;
1432         continue;
1433         }
1434         if (vshader_is_comment_token(*pToken)) { /** comment */
1435             DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
1436             ++pToken;
1437             FIXME("#%s\n", (char*)pToken);
1438             pToken += comment_len;
1439             continue;
1440       }
1441
1442       curOpcode = vshader_program_get_opcode(*pToken);
1443       ++pToken;
1444       if (NULL == curOpcode) {
1445         /* unknown current opcode ... (shouldn't be any!) */
1446         while (*pToken & 0x80000000) {
1447             FIXME("unrecognized opcode: %08lx\n", *pToken);
1448             ++pToken;
1449         }
1450       } else if (GLNAME_REQUIRE_GLSL == curOpcode->glname) {
1451             /* if the token isn't supported by this cross compiler then skip it and its parameters */
1452
1453             FIXME("Token %s requires greater functionality than Vertex_Progarm_ARB supports\n", curOpcode->name);
1454             pToken += curOpcode->num_params;
1455       } else {
1456         /* Build opcode for GL vertex_program */
1457         switch (curOpcode->opcode) {
1458         case D3DSIO_NOP:
1459             continue;
1460         case D3DSIO_MOV:
1461             /* Address registers must be loaded with the ARL instruction */
1462             if ((((*pToken) & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT) == D3DSPR_ADDR) {
1463                 if (((*pToken) & 0x00001FFF) < nUseAddressRegister) {
1464                     strcpy(tmpLine, "ARL");
1465                     break;
1466                 } else
1467                 FIXME("(%p) Try to load A%ld an undeclared address register!\n", This, ((*pToken) & 0x00001FFF));
1468             }
1469             /* fall through */
1470         case D3DSIO_ADD:
1471         case D3DSIO_SUB:
1472         case D3DSIO_MAD:
1473         case D3DSIO_MUL:
1474         case D3DSIO_RCP:
1475         case D3DSIO_RSQ:
1476         case D3DSIO_DP3:
1477         case D3DSIO_DP4:
1478         case D3DSIO_MIN:
1479         case D3DSIO_MAX:
1480         case D3DSIO_SLT:
1481         case D3DSIO_SGE:
1482         case D3DSIO_LIT:
1483         case D3DSIO_DST:
1484         case D3DSIO_FRC:
1485         case D3DSIO_EXPP:
1486         case D3DSIO_LOGP:
1487         case D3DSIO_EXP:
1488         case D3DSIO_LOG:
1489             strcpy(tmpLine, curOpcode->glname);
1490             break;
1491         case D3DSIO_M4x4:
1492         case D3DSIO_M4x3:
1493         case D3DSIO_M3x4:
1494         case D3DSIO_M3x3:
1495         case D3DSIO_M3x2:
1496             /* Expand the macro and get nusprintf(tmpLine,mber of generated instruction */
1497             nRemInstr = ExpandMxMacro(curOpcode->opcode, pToken);
1498             /* Save point to next instruction */
1499             pSavedToken = pToken + 3;
1500             /* Execute expanded macro */
1501             pToken = MacroExpansion;
1502             continue;
1503         /* dcl and def are handeled in the first pass */
1504         case D3DSIO_DCL:
1505             if (This->namedArrays) {
1506                 const char* attribName = "undefined";
1507                 switch(*pToken & 0xFFFF) {
1508                     case D3DDECLUSAGE_POSITION:
1509                     attribName = "vertex.position";
1510                     break;
1511                     case D3DDECLUSAGE_BLENDINDICES:
1512                     /* not supported by openGL */
1513                     attribName = "vertex.blend";
1514                     break;
1515                     case D3DDECLUSAGE_BLENDWEIGHT:
1516                     attribName = "vertex.weight";
1517                     break;
1518                     case D3DDECLUSAGE_NORMAL:
1519                     attribName = "vertex.normal";
1520                     break;
1521                     case D3DDECLUSAGE_PSIZE:
1522                     attribName = "vertex.psize";
1523                     break;
1524                     case D3DDECLUSAGE_COLOR:
1525                     if((*pToken & 0xF0000) >> 16 == 0)  {
1526                         attribName = "vertex.color";
1527                     } else {
1528                         attribName = "vertex.color.secondary";
1529                     }
1530                     break;
1531                     case D3DDECLUSAGE_TEXCOORD:
1532                     {
1533                         char tmpChar[100];
1534                         tmpChar[0] = 0;
1535                         sprintf(tmpChar,"vertex.texcoord[%lu]",(*pToken & 0xF0000) >> 16);
1536                         attribName = tmpChar;
1537                         break;
1538                     }
1539                     /* The following aren't directly supported by openGL, so shouldn't come up using namedarrays. */
1540                     case D3DDECLUSAGE_TANGENT:
1541                     attribName = "vertex.tangent";
1542                     break;
1543                     case D3DDECLUSAGE_BINORMAL:
1544                     attribName = "vertex.binormal";
1545                     break;
1546                     case D3DDECLUSAGE_TESSFACTOR:
1547                     attribName = "vertex.tessfactor";
1548                     break;
1549                     case D3DDECLUSAGE_POSITIONT:
1550                     attribName = "vertex.possitionT";
1551                     break;
1552                     case D3DDECLUSAGE_FOG:
1553                     attribName = "vertex.fogcoord";
1554                     break;
1555                     case D3DDECLUSAGE_DEPTH:
1556                     attribName = "vertex.depth";
1557                     break;
1558                     case D3DDECLUSAGE_SAMPLE:
1559                     attribName = "vertex.sample";
1560                     break;
1561                     default:
1562                     FIXME("Unrecognised dcl %08lx", *pToken & 0xFFFF);
1563                 }
1564                 {
1565                     char tmpChar[80];
1566                     ++pToken;
1567                     sprintf(tmpLine, "ATTRIB ");
1568                     vshader_program_add_param(This, *pToken, FALSE, tmpLine);
1569                     sprintf(tmpChar," = %s", attribName);
1570                     strcat(tmpLine, tmpChar);
1571                     strcat(tmpLine,";\n");
1572                     ++lineNum;
1573                     if (This->namedArrays) {
1574                         TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine);
1575                         PNSTRCAT(pgmStr, tmpLine);
1576
1577                     } else {
1578                         TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine);
1579                     }
1580                 }
1581             } else {
1582                 /* eat the token so it doesn't generate a warning */
1583                 ++pToken;
1584             }
1585             ++pToken;
1586             continue;
1587         case D3DSIO_DEF:
1588             {
1589             char tmpChar[80];
1590             sprintf(tmpLine, "PARAM const%lu = {", *pToken & 0xFF);
1591             ++pToken;
1592             sprintf(tmpChar,"%f ,", *(float *)pToken);
1593             strcat(tmpLine, tmpChar);
1594             ++pToken;
1595             sprintf(tmpChar,"%f ,", *(float *)pToken);
1596             strcat(tmpLine, tmpChar);
1597             ++pToken;
1598             sprintf(tmpChar,"%f ,", *(float *)pToken);
1599             strcat(tmpLine, tmpChar);
1600             ++pToken;
1601             sprintf(tmpChar,"%f}", *(float *)pToken);
1602             strcat(tmpLine, tmpChar);
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             ++pToken;
1610             continue;
1611             }
1612         default:
1613             if (curOpcode->glname == GLNAME_REQUIRE_GLSL) {
1614                 FIXME("Opcode %s requires Gl Shader languange 1.0\n", curOpcode->name);
1615             } else {
1616                 FIXME("Can't handle opcode %s in hwShader\n", curOpcode->name);
1617             }
1618         }
1619         if (curOpcode->num_params > 0) {
1620             vshader_program_add_param(This, *pToken, FALSE, tmpLine);
1621
1622             ++pToken;
1623             for (i = 1; i < curOpcode->num_params; ++i) {
1624                 strcat(tmpLine, ",");
1625                 vshader_program_add_param(This, *pToken, TRUE, tmpLine);
1626                 ++pToken;
1627             }
1628         }
1629         strcat(tmpLine,";\n");
1630         ++lineNum;
1631         TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1632         PNSTRCAT(pgmStr, tmpLine);
1633
1634       }
1635     }
1636     strcpy(tmpLine, "END\n");
1637     ++lineNum;
1638     TRACE("GL HW (%u, %u) : %s", lineNum, pgmLength, tmpLine); /* Don't add \n to this line as already in tmpLine */
1639     PNSTRCAT(pgmStr, tmpLine);
1640
1641   }
1642   /* finally null terminate the pgmStr*/
1643   pgmStr[pgmLength] = 0;
1644
1645   /* Check that Vertex Shaders are supported */
1646   if (GL_SUPPORT(ARB_VERTEX_PROGRAM)) {
1647       /*  Create the hw shader */
1648       /* TODO: change to resource.glObjectHandel or something like that */
1649       GL_EXTCALL(glGenProgramsARB(1, &This->prgId));
1650       TRACE("Creating a hw vertex shader, prg=%d\n", This->prgId);
1651       GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, This->prgId));
1652
1653       /* Create the program and check for errors */
1654       GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(pgmStr)/*pgmLength*/, pgmStr));
1655       if (glGetError() == GL_INVALID_OPERATION) {
1656           GLint errPos;
1657           glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
1658           FIXME("HW VertexShader Error at position %d: %s\n",
1659                 errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
1660           This->prgId = -1;
1661       }
1662   }
1663 #if 1 /* if were using the data buffer of device then we don't need to free it */
1664   HeapFree(GetProcessHeap(), 0, pgmStr);
1665 #endif
1666 #undef PNSTRCAT
1667 }
1668
1669 BOOL IWineD3DVertexShaderImpl_ExecuteHAL(IWineD3DVertexShader* iface, WINEVSHADERINPUTDATA* input, WINEVSHADEROUTPUTDATA* output) {
1670   /**
1671    * TODO: use the NV_vertex_program (or 1_1) extension
1672    *  and specifics vendors (ARB_vertex_program??) variants for it
1673    */
1674   return TRUE;
1675 }
1676
1677 HRESULT WINAPI IWineD3DVertexShaderImpl_ExecuteSW(IWineD3DVertexShader* iface, WINEVSHADERINPUTDATA* input, WINEVSHADEROUTPUTDATA* output) {
1678     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1679
1680     /** Vertex Shader Temporary Registers */
1681     WINED3DSHADERVECTOR R[12];
1682       /*D3DSHADERSCALAR A0;*/
1683     WINED3DSHADERVECTOR A[1];
1684     /** temporary Vector for modifier management */
1685     WINED3DSHADERVECTOR d;
1686     WINED3DSHADERVECTOR s[3];
1687     /** parser datas */
1688     const DWORD* pToken = This->function;
1689     const SHADER_OPCODE* curOpcode = NULL;
1690     /** functions parameters */
1691     WINED3DSHADERVECTOR* p[4];
1692     WINED3DSHADERVECTOR* p_send[4];
1693     DWORD i;
1694
1695     /** init temporary register */
1696     memset(R, 0, 12 * sizeof(WINED3DSHADERVECTOR));
1697
1698     /* vshader_program_parse(vshader); */
1699 #if 0 /* Must not be 1 in cvs */
1700     TRACE("Input:\n");
1701     TRACE_VSVECTOR(This->data->C[0]);
1702     TRACE_VSVECTOR(This->data->C[1]);
1703     TRACE_VSVECTOR(This->data->C[2]);
1704     TRACE_VSVECTOR(This->data->C[3]);
1705     TRACE_VSVECTOR(This->data->C[4]);
1706     TRACE_VSVECTOR(This->data->C[5]);
1707     TRACE_VSVECTOR(This->data->C[6]);
1708     TRACE_VSVECTOR(This->data->C[7]);
1709     TRACE_VSVECTOR(This->data->C[8]);
1710     TRACE_VSVECTOR(This->data->C[64]);
1711     TRACE_VSVECTOR(input->V[D3DVSDE_POSITION]);
1712     TRACE_VSVECTOR(input->V[D3DVSDE_BLENDWEIGHT]);
1713     TRACE_VSVECTOR(input->V[D3DVSDE_BLENDINDICES]);
1714     TRACE_VSVECTOR(input->V[D3DVSDE_NORMAL]);
1715     TRACE_VSVECTOR(input->V[D3DVSDE_PSIZE]);
1716     TRACE_VSVECTOR(input->V[D3DVSDE_DIFFUSE]);
1717     TRACE_VSVECTOR(input->V[D3DVSDE_SPECULAR]);
1718     TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD0]);
1719     TRACE_VSVECTOR(input->V[D3DVSDE_TEXCOORD1]);
1720 #endif
1721
1722     TRACE_VSVECTOR(vshader->data->C[64]);
1723     /* TODO: Run through all the tokens and find and labels, if, endifs, loops etc...., and make a labels list */
1724
1725     /* the first dword is the version tag */
1726     /* TODO: parse it */
1727
1728     if (vshader_is_version_token(*pToken)) { /** version */
1729         ++pToken;
1730     }
1731     while (D3DVS_END() != *pToken) {
1732         if (vshader_is_comment_token(*pToken)) { /** comment */
1733             DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
1734             ++pToken;
1735             pToken += comment_len;
1736             continue ;
1737         }
1738         curOpcode = vshader_program_get_opcode(*pToken);
1739         ++pToken;
1740         if (NULL == curOpcode) {
1741             i = 0;
1742             /* unknown current opcode ... */
1743             /* TODO: Think of a name for 0x80000000 and replace its use with a constant */
1744             while (*pToken & 0x80000000) {
1745                 if (i == 0) {
1746                     FIXME("unrecognized opcode: pos=%d token=%08lX\n", (pToken - 1) - This->function, *(pToken - 1));
1747                 }
1748                 FIXME("unrecognized opcode param: pos=%d token=%08lX what=", pToken - This->function, *pToken);
1749                 vshader_program_dump_param(*pToken, i);
1750                 TRACE("\n");
1751                 ++i;
1752                 ++pToken;
1753             }
1754             /* return FALSE; */
1755         } else {
1756             if (curOpcode->num_params > 0) {
1757                 /* TRACE(">> execting opcode: pos=%d opcode_name=%s token=%08lX\n", pToken - vshader->function, curOpcode->name, *pToken); */
1758                 for (i = 0; i < curOpcode->num_params; ++i) {
1759                     DWORD reg = pToken[i] & 0x00001FFF;
1760                     DWORD regtype = ((pToken[i] & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
1761
1762                     switch (regtype << D3DSP_REGTYPE_SHIFT) {
1763                     case D3DSPR_TEMP:
1764                         /* TRACE("p[%d]=R[%d]\n", i, reg); */
1765                         p[i] = &R[reg];
1766                         break;
1767                     case D3DSPR_INPUT:
1768                         /* TRACE("p[%d]=V[%s]\n", i, VertexShaderDeclRegister[reg]); */
1769                         p[i] = &input->V[reg];
1770                         break;
1771                     case D3DSPR_CONST:
1772                         if (pToken[i] & D3DVS_ADDRMODE_RELATIVE) {
1773                             p[i] = &This->data->C[(DWORD) A[0].x + reg];
1774                         } else {
1775                             p[i] = &This->data->C[reg];
1776                         }
1777                         break;
1778                     case D3DSPR_ADDR: /* case D3DSPR_TEXTURE: */
1779                         if (0 != reg) {
1780                             ERR("cannot handle address registers != a0, forcing use of a0\n");
1781                             reg = 0;
1782                         }
1783                         /* TRACE("p[%d]=A[%d]\n", i, reg); */
1784                         p[i] = &A[reg];
1785                         break;
1786                     case D3DSPR_RASTOUT:
1787                         switch (reg) {
1788                         case D3DSRO_POSITION:
1789                             p[i] = &output->oPos;
1790                             break;
1791                         case D3DSRO_FOG:
1792                             p[i] = &output->oFog;
1793                             break;
1794                         case D3DSRO_POINT_SIZE:
1795                             p[i] = &output->oPts;
1796                             break;
1797                         }
1798                         break;
1799                     case D3DSPR_ATTROUT:
1800                         /* TRACE("p[%d]=oD[%d]\n", i, reg); */
1801                         p[i] = &output->oD[reg];
1802                         break;
1803                     case D3DSPR_TEXCRDOUT:
1804                         /* TRACE("p[%d]=oT[%d]\n", i, reg); */
1805                         p[i] = &output->oT[reg];
1806                         break;
1807                     /* TODO Decls and defs */
1808 #if 0
1809                     case D3DSPR_DCL:
1810                     case D3DSPR_DEF:
1811 #endif
1812                     default:
1813                         break;
1814                     }
1815
1816                     if (i > 0) { /* input reg */
1817                         DWORD swizzle = (pToken[i] & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
1818                         UINT isNegative = ((pToken[i] & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG);
1819
1820                         if (!isNegative && (D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) {
1821                             /* TRACE("p[%d] not swizzled\n", i); */
1822                             p_send[i] = p[i];
1823                         } else {
1824                             DWORD swizzle_x = swizzle & 0x03;
1825                             DWORD swizzle_y = (swizzle >> 2) & 0x03;
1826                             DWORD swizzle_z = (swizzle >> 4) & 0x03;
1827                             DWORD swizzle_w = (swizzle >> 6) & 0x03;
1828                             /* TRACE("p[%d] swizzled\n", i); */
1829                             float* tt = (float*) p[i];
1830                             s[i].x = (isNegative) ? -tt[swizzle_x] : tt[swizzle_x];
1831                             s[i].y = (isNegative) ? -tt[swizzle_y] : tt[swizzle_y];
1832                             s[i].z = (isNegative) ? -tt[swizzle_z] : tt[swizzle_z];
1833                             s[i].w = (isNegative) ? -tt[swizzle_w] : tt[swizzle_w];
1834                             p_send[i] = &s[i];
1835                         }
1836                     } else { /* output reg */
1837                         if ((pToken[i] & D3DSP_WRITEMASK_ALL) == D3DSP_WRITEMASK_ALL) {
1838                             p_send[i] = p[i];
1839                         } else {
1840                             p_send[i] = &d; /* to be post-processed for modifiers management */
1841                         }
1842                     }
1843                 }
1844             }
1845
1846             switch (curOpcode->num_params) {
1847             case 0:
1848                 curOpcode->soft_fct();
1849                 break;
1850             case 1:
1851                 curOpcode->soft_fct(p_send[0]);
1852             break;
1853             case 2:
1854                 curOpcode->soft_fct(p_send[0], p_send[1]);
1855                 break;
1856             case 3:
1857                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2]);
1858                 break;
1859             case 4:
1860                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3]);
1861                 break;
1862             case 5:
1863                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4]);
1864                 break;
1865             case 6:
1866                 curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4], p_send[5]);
1867                 break;
1868             default:
1869                 ERR("%s too many params: %u\n", curOpcode->name, curOpcode->num_params);
1870             }
1871
1872             /* check if output reg modifier post-process */
1873             if (curOpcode->num_params > 0 && (pToken[0] & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
1874                 if (pToken[0] & D3DSP_WRITEMASK_0) p[0]->x = d.x;
1875                 if (pToken[0] & D3DSP_WRITEMASK_1) p[0]->y = d.y;
1876                 if (pToken[0] & D3DSP_WRITEMASK_2) p[0]->z = d.z;
1877                 if (pToken[0] & D3DSP_WRITEMASK_3) p[0]->w = d.w;
1878             }
1879 #if 0
1880             TRACE_VSVECTOR(output->oPos);
1881             TRACE_VSVECTOR(output->oD[0]);
1882             TRACE_VSVECTOR(output->oD[1]);
1883             TRACE_VSVECTOR(output->oT[0]);
1884             TRACE_VSVECTOR(output->oT[1]);
1885             TRACE_VSVECTOR(R[0]);
1886             TRACE_VSVECTOR(R[1]);
1887             TRACE_VSVECTOR(R[2]);
1888             TRACE_VSVECTOR(R[3]);
1889             TRACE_VSVECTOR(R[4]);
1890             TRACE_VSVECTOR(R[5]);
1891 #endif
1892
1893             /* to next opcode token */
1894             pToken += curOpcode->num_params;
1895         }
1896 #if 0
1897         TRACE("End of current instruction:\n");
1898         TRACE_VSVECTOR(output->oPos);
1899         TRACE_VSVECTOR(output->oD[0]);
1900         TRACE_VSVECTOR(output->oD[1]);
1901         TRACE_VSVECTOR(output->oT[0]);
1902         TRACE_VSVECTOR(output->oT[1]);
1903         TRACE_VSVECTOR(R[0]);
1904         TRACE_VSVECTOR(R[1]);
1905         TRACE_VSVECTOR(R[2]);
1906         TRACE_VSVECTOR(R[3]);
1907         TRACE_VSVECTOR(R[4]);
1908         TRACE_VSVECTOR(R[5]);
1909 #endif
1910     }
1911 #if 0 /* Must not be 1 in cvs */
1912     TRACE("Output:\n");
1913     TRACE_VSVECTOR(output->oPos);
1914     TRACE_VSVECTOR(output->oD[0]);
1915     TRACE_VSVECTOR(output->oD[1]);
1916     TRACE_VSVECTOR(output->oT[0]);
1917     TRACE_VSVECTOR(output->oT[1]);
1918 #endif
1919     return D3D_OK;
1920 }
1921
1922 HRESULT WINAPI IWineD3DVertexShaderImpl_SetConstantF(IWineD3DVertexShader *iface, UINT StartRegister, CONST FLOAT *pConstantData, UINT Vector4fCount) {
1923     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1924     FIXME("(%p) : stub\n", This);
1925     return D3D_OK;
1926 }
1927
1928 HRESULT WINAPI IWineD3DVertexShaderImpl_GetConstantF(IWineD3DVertexShader *iface, UINT StartRegister, FLOAT *pConstantData, UINT Vector4fCount) {
1929     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1930     FIXME("(%p) : stub\n", This);
1931     return D3D_OK;
1932 }
1933
1934 HRESULT WINAPI IWineD3DVertexShaderImpl_SetConstantI(IWineD3DVertexShader *iface, UINT StartRegister, CONST int *pConstantData, UINT Vector4iCount) {
1935     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1936     if (StartRegister + Vector4iCount > WINED3D_VSHADER_MAX_CONSTANTS) {
1937         ERR("(%p) : SetVertexShaderConstantI C[%u] invalid\n", This, StartRegister);
1938         return D3DERR_INVALIDCALL;
1939     }
1940     if (NULL == pConstantData) {
1941         return D3DERR_INVALIDCALL;
1942     }
1943     FIXME("(%p) : stub\n", This);
1944     return D3D_OK;
1945 }
1946
1947 HRESULT WINAPI IWineD3DVertexShaderImpl_GetConstantI(IWineD3DVertexShader *iface, UINT StartRegister, int *pConstantData, UINT Vector4iCount) {
1948     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1949     TRACE("(%p) : C[%u] count=%u\n", This, StartRegister, Vector4iCount);
1950     if (StartRegister + Vector4iCount > WINED3D_VSHADER_MAX_CONSTANTS) {
1951         return D3DERR_INVALIDCALL;
1952     }
1953     if (NULL == pConstantData) {
1954         return D3DERR_INVALIDCALL;
1955     }
1956     FIXME("(%p) : stub\n", This);
1957     return D3D_OK;
1958 }
1959
1960 HRESULT WINAPI IWineD3DVertexShaderImpl_SetConstantB(IWineD3DVertexShader *iface, UINT StartRegister, CONST BOOL *pConstantData, UINT BoolCount) {
1961     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1962     if (StartRegister + BoolCount > WINED3D_VSHADER_MAX_CONSTANTS) {
1963         ERR("(%p) : SetVertexShaderConstantB C[%u] invalid\n", This, StartRegister);
1964         return D3DERR_INVALIDCALL;
1965     }
1966     if (NULL == pConstantData) {
1967         return D3DERR_INVALIDCALL;
1968     }
1969     FIXME("(%p) : stub\n", This);
1970     return D3D_OK;
1971 }
1972
1973 HRESULT WINAPI IWineD3DVertexShaderImpl_GetConstantB(IWineD3DVertexShader *iface, UINT StartRegister, BOOL *pConstantData, UINT BoolCount) {
1974     IWineD3DVertexShaderImpl* This = (IWineD3DVertexShaderImpl *)iface;
1975     FIXME("(%p) : stub\n", This);
1976     return D3D_OK;
1977 }
1978
1979 #endif
1980
1981 /* *******************************************
1982    IWineD3DVertexShader IUnknown parts follow
1983    ******************************************* */
1984 HRESULT WINAPI IWineD3DVertexShaderImpl_QueryInterface(IWineD3DVertexShader *iface, REFIID riid, LPVOID *ppobj)
1985 {
1986     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
1987     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
1988     if (IsEqualGUID(riid, &IID_IUnknown)
1989         || IsEqualGUID(riid, &IID_IWineD3DBase)
1990         || IsEqualGUID(riid, &IID_IWineD3DVertexShader)) {
1991         IUnknown_AddRef(iface);
1992         *ppobj = This;
1993         return D3D_OK;
1994     }
1995     return E_NOINTERFACE;
1996 }
1997
1998 ULONG WINAPI IWineD3DVertexShaderImpl_AddRef(IWineD3DVertexShader *iface) {
1999     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
2000     TRACE("(%p) : AddRef increasing from %ld\n", This, This->ref);
2001     return InterlockedIncrement(&This->ref);
2002 }
2003
2004 ULONG WINAPI IWineD3DVertexShaderImpl_Release(IWineD3DVertexShader *iface) {
2005     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
2006     ULONG ref;
2007     TRACE("(%p) : Releasing from %ld\n", This, This->ref);
2008     ref = InterlockedDecrement(&This->ref);
2009     if (ref == 0) {
2010         if (This->vertexDeclaration) IWineD3DVertexDeclaration_Release(This->vertexDeclaration);
2011         HeapFree(GetProcessHeap(), 0, This);
2012     }
2013     return ref;
2014 }
2015
2016 /* *******************************************
2017    IWineD3DVertexShader IWineD3DVertexShader parts follow
2018    ******************************************* */
2019
2020 HRESULT WINAPI IWineD3DVertexShaderImpl_GetParent(IWineD3DVertexShader *iface, IUnknown** parent){
2021     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
2022
2023     *parent = This->parent;
2024     IUnknown_AddRef(*parent);
2025     TRACE("(%p) : returning %p\n", This, *parent);
2026     return D3D_OK;
2027 }
2028
2029 HRESULT WINAPI IWineD3DVertexShaderImpl_GetDevice(IWineD3DVertexShader* iface, IWineD3DDevice **pDevice){
2030     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
2031     IWineD3DDevice_AddRef((IWineD3DDevice *)This->wineD3DDevice);
2032     *pDevice = (IWineD3DDevice *)This->wineD3DDevice;
2033     TRACE("(%p) returning %p\n", This, *pDevice);
2034     return D3D_OK;
2035 }
2036
2037 HRESULT WINAPI IWineD3DVertexShaderImpl_GetFunction(IWineD3DVertexShader* impl, VOID* pData, UINT* pSizeOfData) {
2038     IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)impl;
2039     FIXME("(%p) : pData(%p), pSizeOfData(%p)\n", This, pData, pSizeOfData);
2040
2041     if (NULL == pData) {
2042         *pSizeOfData = This->functionLength;
2043         return D3D_OK;
2044     }
2045     if (*pSizeOfData < This->functionLength) {
2046         *pSizeOfData = This->functionLength;
2047         return D3DERR_MOREDATA;
2048     }
2049     if (NULL == This->function) { /* no function defined */
2050         TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
2051         (*(DWORD **) pData) = NULL;
2052     } else {
2053         if(This->functionLength == 0){
2054
2055         }
2056         TRACE("(%p) : GetFunction copying to %p\n", This, pData);
2057         memcpy(pData, This->function, This->functionLength);
2058     }
2059     return D3D_OK;
2060 }
2061
2062 HRESULT WINAPI IWineD3DVertexShaderImpl_SetFunction(IWineD3DVertexShader *iface, CONST DWORD *pFunction) {
2063     IWineD3DVertexShaderImpl *This =(IWineD3DVertexShaderImpl *)iface;
2064     const DWORD* pToken = pFunction;
2065     const SHADER_OPCODE* curOpcode = NULL;
2066     DWORD len = 0;
2067     DWORD i;
2068     TRACE("(%p) : Parsing programme\n", This);
2069
2070     if (NULL != pToken) {
2071         while (D3DVS_END() != *pToken) {
2072             if (vshader_is_version_token(*pToken)) { /** version */
2073                 TRACE("vs_%lu_%lu\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
2074                 ++pToken;
2075                 ++len;
2076                 continue;
2077             }
2078             if (vshader_is_comment_token(*pToken)) { /** comment */
2079                 DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
2080                 ++pToken;
2081                 TRACE("//%s\n", (char*)pToken);
2082                 pToken += comment_len;
2083                 len += comment_len + 1;
2084                 continue;
2085             }
2086             curOpcode = vshader_program_get_opcode(*pToken);
2087             ++pToken;
2088             ++len;
2089             if (NULL == curOpcode) {
2090                 /* TODO: Think of a good name for 0x80000000 and replace it with a constant */
2091                 while (*pToken & 0x80000000) {
2092                     /* unknown current opcode ... */
2093                     FIXME("unrecognized opcode: %08lx", *pToken);
2094                     ++pToken;
2095                     ++len;
2096                     TRACE("\n");
2097                 }
2098
2099             } else {
2100                 if (curOpcode->opcode == D3DSIO_DCL) {
2101                     TRACE("dcl_");
2102                     switch(*pToken & 0xFFFF) {
2103                         case D3DDECLUSAGE_POSITION:
2104                         TRACE("%s%ld ", "position",(*pToken & 0xF0000) >> 16);
2105                         break;
2106                         case D3DDECLUSAGE_BLENDINDICES:
2107                         TRACE("%s ", "blend");
2108                         break;
2109                         case D3DDECLUSAGE_BLENDWEIGHT:
2110                         TRACE("%s ", "weight");
2111                         break;
2112                         case D3DDECLUSAGE_NORMAL:
2113                         TRACE("%s%ld ", "normal",(*pToken & 0xF0000) >> 16);
2114                         break;
2115                         case D3DDECLUSAGE_PSIZE:
2116                         TRACE("%s ", "psize");
2117                         break;
2118                         case D3DDECLUSAGE_COLOR:
2119                         if((*pToken & 0xF0000) >> 16 == 0)  {
2120                             TRACE("%s ", "color");
2121                         } else {
2122                             TRACE("%s ", "specular");
2123                         }
2124                         break;
2125                         case D3DDECLUSAGE_TEXCOORD:
2126                         TRACE("%s%ld ", "texture", (*pToken & 0xF0000) >> 16);
2127                         break;
2128                         case D3DDECLUSAGE_TANGENT:
2129                         TRACE("%s ", "tangent");
2130                         break;
2131                         case D3DDECLUSAGE_BINORMAL:
2132                         TRACE("%s ", "binormal");
2133                         break;
2134                         case D3DDECLUSAGE_TESSFACTOR:
2135                         TRACE("%s ", "tessfactor");
2136                         break;
2137                         case D3DDECLUSAGE_POSITIONT:
2138                         TRACE("%s%ld ", "positionT",(*pToken & 0xF0000) >> 16);
2139                         break;
2140                         case D3DDECLUSAGE_FOG:
2141                         TRACE("%s ", "fog");
2142                         break;
2143                         case D3DDECLUSAGE_DEPTH:
2144                         TRACE("%s ", "depth");
2145                         break;
2146                         case D3DDECLUSAGE_SAMPLE:
2147                         TRACE("%s ", "sample");
2148                         break;
2149                         default:
2150                         FIXME("Unrecognised dcl %08lx", *pToken & 0xFFFF);
2151                     }
2152                     ++pToken;
2153                     ++len;
2154                     vshader_program_dump_vs_param(*pToken, 0);
2155                     ++pToken;
2156                     ++len;
2157                 } else
2158                     if (curOpcode->opcode == D3DSIO_DEF) {
2159                         TRACE("def c%lu = ", *pToken & 0xFF);
2160                         ++pToken;
2161                         ++len;
2162                         TRACE("%f ,", *(float *)pToken);
2163                         ++pToken;
2164                         ++len;
2165                         TRACE("%f ,", *(float *)pToken);
2166                         ++pToken;
2167                         ++len;
2168                         TRACE("%f ,", *(float *)pToken);
2169                         ++pToken;
2170                         ++len;
2171                         TRACE("%f", *(float *)pToken);
2172                         ++pToken;
2173                         ++len;
2174                 } else {
2175                     TRACE("%s ", curOpcode->name);
2176                     if (curOpcode->num_params > 0) {
2177                         vshader_program_dump_vs_param(*pToken, 0);
2178                         ++pToken;
2179                         ++len;
2180                         for (i = 1; i < curOpcode->num_params; ++i) {
2181                             TRACE(", ");
2182                             vshader_program_dump_vs_param(*pToken, 1);
2183                             ++pToken;
2184                             ++len;
2185                         }
2186                     }
2187                 }
2188                 TRACE("\n");
2189             }
2190         }
2191         This->functionLength = (len + 1) * sizeof(DWORD);
2192     } else {
2193         This->functionLength = 1; /* no Function defined use fixed function vertex processing */
2194     }
2195
2196     /* Generate HW shader in needed */
2197     if (NULL != pFunction  && wined3d_settings.vs_mode == VS_HW) {
2198 #if 1
2199         IWineD3DVertexShaderImpl_GenerateProgramArbHW(iface, pFunction);
2200 #endif
2201     }
2202
2203     /* copy the function ... because it will certainly be released by application */
2204     if (NULL != pFunction) {
2205         This->function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->functionLength);
2206         memcpy((void *)This->function, pFunction, This->functionLength);
2207     } else {
2208         This->function = NULL;
2209     }
2210     return D3D_OK;
2211 }
2212
2213 const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl =
2214 {
2215     /*** IUnknown methods ***/
2216     IWineD3DVertexShaderImpl_QueryInterface,
2217     IWineD3DVertexShaderImpl_AddRef,
2218     IWineD3DVertexShaderImpl_Release,
2219     /*** IWineD3DVertexShader methods ***/
2220     IWineD3DVertexShaderImpl_GetParent,
2221     IWineD3DVertexShaderImpl_GetDevice,
2222     IWineD3DVertexShaderImpl_GetFunction,
2223     IWineD3DVertexShaderImpl_SetFunction
2224 };