git.oblomov.eu Git - wine/blob - dlls/d3d8/shader.c

   1 /*
   2  * shaders implementation
   3  *
   4  * Copyright 2002 Raphael Junqueira
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "wingdi.h"
  27 #include "wine/debug.h"
  28
  29 #include <math.h>
  30
  31 #include "d3d8_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  34
  35 /**
  36  * DirectX9 SDK download
  37  *  http://msdn.microsoft.com/library/default.asp?url=/downloads/list/directx.asp
  38  *
  39  * Exploring D3DX
  40  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx07162002.asp
  41  *
  42  * Using Vertex Shaders
  43  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx02192001.asp
  44  *
  45  * Dx9 New
  46  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/whatsnew.asp
  47  *
  48  * Dx9 Shaders
  49  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/VertexShader2_0.asp
  50  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader2_0/Instructions/Instructions.asp
  51  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexDeclaration/VertexDeclaration.asp
  52  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/reference/Shaders/VertexShader3_0/VertexShader3_0.asp
  53  *
  54  * Dx9 D3DX
  55  *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/directx/graphics/programmingguide/advancedtopics/VertexPipe/matrixstack/matrixstack.asp
  56  *
  57  * FVF
  58  *  http://msdn.microsoft.com/library/en-us/directx9_c/directx/graphics/programmingguide/GettingStarted/VertexFormats/vformats.asp
  59  *
  60  * NVIDIA: DX8 Vertex Shader to NV Vertex Program
  61  *  http://developer.nvidia.com/view.asp?IO=vstovp
  62  *
  63  * NVIDIA: Memory Management with VAR
  64  *  http://developer.nvidia.com/view.asp?IO=var_memory_management
  65  */
  66
  67 typedef void (*shader_fct_t)();
  68
  69 typedef struct SHADER_OPCODE {
  70   CONST BYTE    opcode;
  71   const char*   name;
  72   CONST UINT    num_params;
  73   shader_fct_t  soft_fct;
  74 } SHADER_OPCODE;
  75
  76 /*******************************
  77  * vshader functions software VM
  78  */
  79
  80 void vshader_add(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
  81   d->x = s0->x + s1->x;
  82   d->y = s0->y + s1->y;
  83   d->z = s0->z + s1->z;
  84   d->w = s0->w + s1->w;
  85 }
  86
  87 void vshader_dp3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
  88   d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z;
  89 }
  90
  91 void vshader_dp4(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
  92   d->x = d->y = d->z = d->w = s0->x * s1->x + s0->y * s1->y + s0->z * s1->z + s0->w * s1->w;
  93
  94   /*
  95   DPRINTF("executing dp4: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
  96           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w);
  97   */
  98 }
  99
 100 void vshader_dst(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
 101   d->x = 1.0f;
 102   d->y = s0->y * s1->y;
 103   d->z = s0->z;
 104   d->w = s1->w;
 105
 106   /*
 107   DPRINTF("executing dst: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 108           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w);
 109   */
 110 }
 111
 112 void vshader_expp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 113   float tmp_f = floorf(s0->w);
 114   DWORD tmp_d = 0;
 115   tmp_f = powf(2.0f, s0->w);
 116   tmp_d = *((DWORD*) &tmp_f) & 0xFFFFFF00;
 117
 118   d->x  = powf(2.0f, tmp_f);
 119   d->y  = s0->w - tmp_f;
 120   d->z  = *((float*) &tmp_d);
 121   d->w  = 1.0f;
 122
 123   /*
 124   DPRINTF("executing exp: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 125           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w);
 126   */
 127 }
 128
 129 void vshader_lit(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 130   d->x = 1.0f;
 131   d->y = (0.0f < s0->x) ? s0->x : 0.0f;
 132   d->z = (0.0f < s0->x && 0.0f < s0->y) ? powf(s0->y, s0->w) : 0.0f;
 133   d->w = 1.0f;
 134
 135   /*
 136   DPRINTF("executing lit: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 137           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w);
 138   */
 139 }
 140
 141 void vshader_logp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 142   float tmp_f = fabsf(s0->w);
 143   d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE;
 144 }
 145
 146 void vshader_mad(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2) {
 147   d->x = s0->x * s1->x + s2->x;
 148   d->y = s0->y * s1->y + s2->y;
 149   d->z = s0->z * s1->z + s2->z;
 150   d->w = s0->w * s1->w + s2->w;
 151 }
 152
 153 void vshader_max(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
 154   d->x = (s0->x >= s1->x) ? s0->x : s1->x;
 155   d->y = (s0->y >= s1->y) ? s0->y : s1->y;
 156   d->z = (s0->z >= s1->z) ? s0->z : s1->z;
 157   d->w = (s0->w >= s1->w) ? s0->w : s1->w;
 158 }
 159
 160 void vshader_min(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
 161   d->x = (s0->x < s1->x) ? s0->x : s1->x;
 162   d->y = (s0->y < s1->y) ? s0->y : s1->y;
 163   d->z = (s0->z < s1->z) ? s0->z : s1->z;
 164   d->w = (s0->w < s1->w) ? s0->w : s1->w;
 165 }
 166
 167 void vshader_mov(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 168   d->x = s0->x;
 169   d->y = s0->y;
 170   d->z = s0->z;
 171   d->w = s0->w;
 172
 173   /*
 174   DPRINTF("executing mov: s0=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 175           s0->x, s0->y, s0->z, s0->w, d->x, d->y, d->z, d->w);
 176   */
 177 }
 178
 179 void vshader_mul(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
 180   d->x = s0->x * s1->x;
 181   d->y = s0->y * s1->y;
 182   d->z = s0->z * s1->z;
 183   d->w = s0->w * s1->w;
 184
 185   /*
 186   DPRINTF("executing mul: s0=(%f, %f, %f, %f) s1=(%f, %f, %f, %f) => d=(%f, %f, %f, %f)\n",
 187           s0->x, s0->y, s0->z, s0->w, s1->x, s1->y, s1->z, s1->w, d->x, d->y, d->z, d->w);
 188   */
 189 }
 190
 191 void vshader_nop(void) {
 192   /* NOPPPP ahhh too easy ;) */
 193 }
 194
 195 void vshader_rcp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 196   d->x = d->y = d->z = d->w = (0.0f == s0->w) ? HUGE : 1.0f / s0->w;
 197 }
 198
 199 void vshader_rsq(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 200   float tmp_f = fabsf(s0->w);
 201   d->x = d->y = d->z = d->w = (0.0f == tmp_f) ? HUGE : ((1.0f != tmp_f) ? 1.0f / sqrtf(tmp_f) : 1.0f);
 202 }
 203
 204 void vshader_sge(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
 205   d->x = (s0->x >= s1->x) ? 1.0f : 0.0f;
 206   d->y = (s0->y >= s1->y) ? 1.0f : 0.0f;
 207   d->z = (s0->z >= s1->z) ? 1.0f : 0.0f;
 208   d->w = (s0->w >= s1->w) ? 1.0f : 0.0f;
 209 }
 210
 211 void vshader_slt(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
 212   d->x = (s0->x < s1->x) ? 1.0f : 0.0f;
 213   d->y = (s0->y < s1->y) ? 1.0f : 0.0f;
 214   d->z = (s0->z < s1->z) ? 1.0f : 0.0f;
 215   d->w = (s0->w < s1->w) ? 1.0f : 0.0f;
 216 }
 217
 218 void vshader_sub(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1) {
 219   d->x = s0->x - s1->x;
 220   d->y = s0->y - s1->y;
 221   d->z = s0->z - s1->z;
 222   d->w = s0->w - s1->w;
 223 }
 224
 225 /**
 226  * Version 1.1 specific
 227  */
 228
 229 void vshader_exp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 230   d->x = d->y = d->z = d->w = powf(2.0f, s0->w);
 231 }
 232
 233 void vshader_log(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 234   float tmp_f = fabsf(s0->w);
 235   d->x = d->y = d->z = d->w = (0.0f != tmp_f) ? logf(tmp_f) / logf(2.0f) : -HUGE;
 236 }
 237
 238 void vshader_frc(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0) {
 239   d->x = s0->x - floorf(s0->x);
 240   d->y = s0->y - floorf(s0->y);
 241   d->z = 0.0f;
 242   d->w = 1.0f;
 243 }
 244
 245 typedef FLOAT D3DMATRIX44[4][4];
 246 typedef FLOAT D3DMATRIX43[4][3];
 247 typedef FLOAT D3DMATRIX34[4][4];
 248 typedef FLOAT D3DMATRIX33[4][3];
 249 typedef FLOAT D3DMATRIX32[4][2];
 250
 251 void vshader_m4x4(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, /*D3DSHADERVECTOR* mat1*/ D3DMATRIX44 mat) {
 252   /*
 253    * BuGGY CODE: here only if cast not work for copy/paste
 254   D3DSHADERVECTOR* mat2 = mat1 + 1;
 255   D3DSHADERVECTOR* mat3 = mat1 + 2;
 256   D3DSHADERVECTOR* mat4 = mat1 + 3;
 257   d->x = mat1->x * s0->x + mat2->x * s0->y + mat3->x * s0->z + mat4->x * s0->w;
 258   d->y = mat1->y * s0->x + mat2->y * s0->y + mat3->y * s0->z + mat4->y * s0->w;
 259   d->z = mat1->z * s0->x + mat2->z * s0->y + mat3->z * s0->z + mat4->z * s0->w;
 260   d->w = mat1->w * s0->x + mat2->w * s0->y + mat3->w * s0->z + mat4->w * s0->w;
 261   */
 262   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
 263   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
 264   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
 265   d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z + mat[3][3] * s0->w;
 266 }
 267
 268 void vshader_m4x3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX43 mat) {
 269   FIXME("check\n");
 270   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z + mat[0][3] * s0->w;
 271   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z + mat[1][3] * s0->w;
 272   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z + mat[2][3] * s0->w;
 273   d->w = 1.0f;
 274 }
 275
 276 void vshader_m3x4(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX34 mat) {
 277   FIXME("check\n");
 278   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
 279   d->y = mat[2][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
 280   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
 281   d->w = mat[3][0] * s0->x + mat[3][1] * s0->y + mat[3][2] * s0->z;
 282 }
 283
 284 void vshader_m3x3(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX33 mat) {
 285   FIXME("check\n");
 286   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[2][2] * s0->z;
 287   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[2][2] * s0->z;
 288   d->z = mat[2][0] * s0->x + mat[2][1] * s0->y + mat[2][2] * s0->z;
 289   d->w = 1.0f;
 290 }
 291
 292 void vshader_m3x2(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DMATRIX32 mat) {
 293   FIXME("check\n");
 294   d->x = mat[0][0] * s0->x + mat[0][1] * s0->y + mat[0][2] * s0->z;
 295   d->y = mat[1][0] * s0->x + mat[1][1] * s0->y + mat[1][2] * s0->z;
 296   d->z = 0.0f;
 297   d->w = 1.0f;
 298 }
 299
 300 /**
 301  * Version 2.0 specific
 302  */
 303 void vshader_lrp(D3DSHADERVECTOR* d, D3DSHADERVECTOR* s0, D3DSHADERVECTOR* s1, D3DSHADERVECTOR* s2, D3DSHADERVECTOR* s3) {
 304   d->x = s0->x * (s1->x - s2->x) + s2->x;
 305   d->y = s0->y * (s1->y - s2->y) + s2->y;
 306   d->z = s0->z * (s1->z - s2->z) + s2->z;
 307   d->w = s0->w * (s1->w - s2->w) + s2->x;
 308 }
 309
 310 /**
 311  * log, exp, frc, m*x* seems to be macros ins ... to see
 312  */
 313 static CONST SHADER_OPCODE vshader_ins [] = {
 314   {D3DSIO_NOP,  "nop",  0, vshader_nop},
 315   {D3DSIO_MOV,  "mov",  2, vshader_mov},
 316   {D3DSIO_ADD,  "add",  3, vshader_add},
 317   {D3DSIO_SUB,  "sub",  3, vshader_sub},
 318   {D3DSIO_MAD,  "mad",  4, vshader_mad},
 319   {D3DSIO_MUL,  "mul",  3, vshader_mul},
 320   {D3DSIO_RCP,  "rcp",  2, vshader_rcp},
 321   {D3DSIO_RSQ,  "rsq",  2, vshader_rsq},
 322   {D3DSIO_DP3,  "dp3",  3, vshader_dp3},
 323   {D3DSIO_DP4,  "dp4",  3, vshader_dp4},
 324   {D3DSIO_MIN,  "min",  3, vshader_min},
 325   {D3DSIO_MAX,  "max",  3, vshader_max},
 326   {D3DSIO_SLT,  "slt",  3, vshader_slt},
 327   {D3DSIO_SGE,  "sge",  3, vshader_sge},
 328   {D3DSIO_EXP,  "exp",  2, vshader_exp},
 329   {D3DSIO_LOG,  "log",  2, vshader_log},
 330   {D3DSIO_LIT,  "lit",  2, vshader_lit},
 331   {D3DSIO_DST,  "dst",  3, vshader_dst},
 332   {D3DSIO_LRP,  "lrp",  5, vshader_lrp},
 333   {D3DSIO_FRC,  "frc",  2, vshader_frc},
 334   {D3DSIO_M4x4, "m4x4", 3, vshader_m4x4},
 335   {D3DSIO_M4x3, "m4x3", 3, vshader_m4x3},
 336   {D3DSIO_M3x4, "m3x4", 3, vshader_m3x4},
 337   {D3DSIO_M3x3, "m3x3", 3, vshader_m3x3},
 338   {D3DSIO_M3x2, "m3x2", 3, vshader_m3x2},
 339   /** FIXME: use direct acces so add the others opcodes as stubs */
 340   {D3DSIO_EXPP, "expp", 2, vshader_expp},
 341   {D3DSIO_LOGP, "logp", 2, vshader_logp},
 342
 343   {0, NULL, 0, NULL}
 344 };
 345
 346
 347 inline static const SHADER_OPCODE* vshader_program_get_opcode(const DWORD code) {
 348   DWORD i = 0;
 349   /** TODO: use dichotomic search */
 350   while (NULL != vshader_ins[i].name) {
 351     if ((code & D3DSI_OPCODE_MASK) == vshader_ins[i].opcode) {
 352       return &vshader_ins[i];
 353     }
 354     ++i;
 355   }
 356   return NULL;
 357 }
 358
 359 inline static void vshader_program_dump_param(const DWORD param, int input) {
 360   static const char* rastout_reg_names[] = { "oPos", "oFog", "oPts" };
 361   static const char swizzle_reg_chars[] = "xyzw";
 362
 363   DWORD reg = param & 0x00001FFF;
 364   DWORD regtype = ((param & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
 365
 366   if ((param & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG) DPRINTF("-");
 367
 368   switch (regtype << D3DSP_REGTYPE_SHIFT) {
 369   case D3DSPR_TEMP:
 370     DPRINTF("R[%lu]", reg);
 371     break;
 372   case D3DSPR_INPUT:
 373     DPRINTF("V[%lu]", reg);
 374     break;
 375   case D3DSPR_CONST:
 376     DPRINTF("C[%s%lu]", (reg & D3DVS_ADDRMODE_RELATIVE) ? "a0.x + " : "", reg);
 377     break;
 378   case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 379     DPRINTF("a[%lu]", reg);
 380     break;
 381   case D3DSPR_RASTOUT:
 382     DPRINTF("%s", rastout_reg_names[reg]);
 383     break;
 384   case D3DSPR_ATTROUT:
 385     DPRINTF("oD[%lu]", reg);
 386     break;
 387   case D3DSPR_TEXCRDOUT:
 388     DPRINTF("oT[%lu]", reg);
 389     break;
 390   default:
 391     break;
 392   }
 393
 394   if (!input) {
 395     /** operand output */
 396     if ((param & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 397       if (param & D3DSP_WRITEMASK_0) DPRINTF(".x");
 398       if (param & D3DSP_WRITEMASK_1) DPRINTF(".y");
 399       if (param & D3DSP_WRITEMASK_2) DPRINTF(".z");
 400       if (param & D3DSP_WRITEMASK_3) DPRINTF(".w");
 401     }
 402   } else {
 403     /** operand input */
 404     DWORD swizzle = (param & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 405     DWORD swizzle_x = swizzle & 0x03;
 406     DWORD swizzle_y = (swizzle >> 2) & 0x03;
 407     DWORD swizzle_z = (swizzle >> 4) & 0x03;
 408     DWORD swizzle_w = (swizzle >> 6) & 0x03;
 409     /**
 410      * swizzle bits fields:
 411      *  WWZZYYXX
 412      */
 413     if ((D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) != swizzle) { /* ! D3DVS_NOSWIZZLE == 0xE4 << D3DVS_SWIZZLE_SHIFT */
 414       if (swizzle_x == swizzle_y &&
 415           swizzle_x == swizzle_z &&
 416           swizzle_x == swizzle_w) {
 417         DPRINTF(".%c", swizzle_reg_chars[swizzle_x]);
 418       } else {
 419         DPRINTF(".%c%c%c%c",
 420                 swizzle_reg_chars[swizzle_x],
 421                 swizzle_reg_chars[swizzle_y],
 422                 swizzle_reg_chars[swizzle_z],
 423                 swizzle_reg_chars[swizzle_w]);
 424       }
 425     }
 426   }
 427 }
 428
 429 inline static BOOL vshader_is_version_token(DWORD token) {
 430   return 0xFFFE0000 == (token & 0xFFFE0000);
 431 }
 432
 433 inline static BOOL vshader_is_comment_token(DWORD token) {
 434   return D3DSIO_COMMENT == (token & D3DSI_OPCODE_MASK);
 435 }
 436
 437 /**
 438  * Function parser ...
 439  */
 440 inline static VOID IDirect3DVertexShaderImpl_ParseProgram(IDirect3DVertexShaderImpl* vshader, CONST DWORD* pFunction) {
 441   const DWORD* pToken = pFunction;
 442   const SHADER_OPCODE* curOpcode = NULL;
 443   DWORD len = 0;
 444   DWORD i;
 445
 446   if (NULL != pToken) {
 447     while (D3DVS_END() != *pToken) {
 448       if (vshader_is_version_token(*pToken)) { /** version */
 449         DPRINTF("vs.%lu.%lu\n", (*pToken >> 8) & 0x0F, (*pToken & 0x0F));
 450         ++pToken;
 451         ++len;
 452         continue;
 453       }
 454       if (vshader_is_comment_token(*pToken)) { /** comment */
 455         DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
 456         ++pToken;
 457         /*DPRINTF("comment[%ld] ;%s\n", comment_len, (char*)pToken);*/
 458         pToken += comment_len;
 459         len += comment_len + 1;
 460         continue;
 461       }
 462       curOpcode = vshader_program_get_opcode(*pToken);
 463       ++pToken;
 464       ++len;
 465       if (NULL == curOpcode) {
 466         /* unkown current opcode ... */
 467         while (*pToken & 0x80000000) {
 468           DPRINTF("unrecognized opcode: %08lx\n", *pToken);
 469           ++pToken;
 470           ++len;
 471         }
 472       } else {
 473         DPRINTF("%s ", curOpcode->name);
 474         if (curOpcode->num_params > 0) {
 475           vshader_program_dump_param(*pToken, 0);
 476           ++pToken;
 477           ++len;
 478           for (i = 1; i < curOpcode->num_params; ++i) {
 479             DPRINTF(", ");
 480             vshader_program_dump_param(*pToken, 1);
 481             ++pToken;
 482             ++len;
 483           }
 484         }
 485         DPRINTF("\n");
 486       }
 487     }
 488     vshader->functionLength = (len + 1) * sizeof(DWORD);
 489   } else {
 490     vshader->functionLength = 1; /* no Function defined use fixed function vertex processing */
 491   }
 492   /* copy the function ... because it will certainly be released by application */
 493
 494   if (NULL != pFunction) {
 495     vshader->function = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, vshader->functionLength);
 496     memcpy(vshader->function, pFunction, vshader->functionLength);
 497   } else {
 498     vshader->function = NULL;
 499   }
 500 }
 501
 502 HRESULT WINAPI IDirect3DDeviceImpl_CreateVertexShader(IDirect3DDevice8Impl* This, CONST DWORD* pFunction, DWORD Usage, IDirect3DVertexShaderImpl** ppVertexShader) {
 503   IDirect3DVertexShaderImpl* object;
 504
 505   object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexShaderImpl));
 506   if (NULL == object) {
 507     *ppVertexShader = NULL;
 508     return D3DERR_OUTOFVIDEOMEMORY;
 509   }
 510   /*object->lpVtbl = &Direct3DVextexShader9_Vtbl;*/
 511   object->device = This; /* FIXME: AddRef(This) */
 512   object->ref = 1;
 513
 514   object->usage = Usage;
 515   object->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHADERDATA8));
 516
 517   IDirect3DVertexShaderImpl_ParseProgram(object, pFunction);
 518
 519   *ppVertexShader = object;
 520   return D3D_OK;
 521 }
 522
 523 BOOL IDirect3DVertexShaderImpl_ExecuteHAL(IDirect3DVertexShaderImpl* vshader, VSHADERINPUTDATA8* input, VSHADEROUTPUTDATA8* output) {
 524   /**
 525    * TODO: use the NV_vertex_program (or 1_1) extension
 526    *  and specifics vendors (ARB_vertex_program??) variants for it
 527    */
 528   return TRUE;
 529 }
 530
 531 #define TRACE_VECTOR(name) DPRINTF( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w)
 532
 533 HRESULT WINAPI IDirect3DVertexShaderImpl_ExecuteSW(IDirect3DVertexShaderImpl* vshader, VSHADERINPUTDATA8* input, VSHADEROUTPUTDATA8* output) {
 534   /** Vertex Shader Temporary Registers */
 535   D3DSHADERVECTOR R[12];
 536   /*D3DSHADERSCALAR A0;*/
 537   D3DSHADERVECTOR A[1];
 538   /** temporary Vector for modifier management */
 539   D3DSHADERVECTOR d;
 540   D3DSHADERVECTOR s[3];
 541   /** parser datas */
 542   const DWORD* pToken = vshader->function;
 543   const SHADER_OPCODE* curOpcode = NULL;
 544   /** functions parameters */
 545   D3DSHADERVECTOR* p[4];
 546   D3DSHADERVECTOR* p_send[4];
 547   DWORD i;
 548
 549   /** init temporary register */
 550   memset(R, 0, 12 * sizeof(D3DSHADERVECTOR));
 551
 552   /* vshader_program_parse(vshader); */
 553   /*
 554   TRACE_VECTOR(vshader->data->C[0]);
 555   TRACE_VECTOR(vshader->data->C[1]);
 556   TRACE_VECTOR(vshader->data->C[2]);
 557   TRACE_VECTOR(vshader->data->C[3]);
 558   TRACE_VECTOR(vshader->data->C[4]);
 559   TRACE_VECTOR(vshader->data->C[5]);
 560   TRACE_VECTOR(input->V[D3DVSDE_POSITION]);
 561   TRACE_VECTOR(input->V[D3DVSDE_BLENDWEIGHT]);
 562   TRACE_VECTOR(input->V[D3DVSDE_BLENDINDICES]);
 563   TRACE_VECTOR(input->V[D3DVSDE_NORMAL]);
 564   TRACE_VECTOR(input->V[D3DVSDE_PSIZE]);
 565   TRACE_VECTOR(input->V[D3DVSDE_DIFFUSE]);
 566   TRACE_VECTOR(input->V[D3DVSDE_SPECULAR]);
 567   TRACE_VECTOR(input->V[D3DVSDE_TEXCOORD0]);
 568   TRACE_VECTOR(input->V[D3DVSDE_TEXCOORD1]);
 569   */
 570
 571   /* the first dword is the version tag */
 572   /* TODO: parse it */
 573
 574   if (vshader_is_version_token(*pToken)) { /** version */
 575     ++pToken;
 576   }
 577   while (D3DVS_END() != *pToken) {
 578     if (vshader_is_comment_token(*pToken)) { /** comment */
 579       DWORD comment_len = (*pToken & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT;
 580       ++pToken;
 581       pToken += comment_len;
 582       continue ;
 583     }
 584     curOpcode = vshader_program_get_opcode(*pToken);
 585     ++pToken;
 586     if (NULL == curOpcode) {
 587       i = 0;
 588       /* unkown current opcode ... */
 589       while (*pToken & 0x80000000) {
 590         if (i == 0) {
 591           DPRINTF("unrecognized opcode: pos=%d token=%08lX\n", (pToken - 1) - vshader->function, *(pToken - 1));
 592         }
 593         DPRINTF("unrecognized opcode param: pos=%d token=%08lX what=", pToken - vshader->function, *pToken);
 594         vshader_program_dump_param(*pToken, i);
 595         DPRINTF("\n");
 596         ++i;
 597         ++pToken;
 598       }
 599       /*return FALSE;*/
 600     } else {
 601       if (curOpcode->num_params > 0) {
 602         /*DPRINTF(">> execting opcode: pos=%d opcode_name=%s token=%08lX\n", pToken - vshader->function, curOpcode->name, *pToken);*/
 603         for (i = 0; i < curOpcode->num_params; ++i) {
 604           DWORD reg = pToken[i] & 0x00001FFF;
 605           DWORD regtype = ((pToken[i] & D3DSP_REGTYPE_MASK) >> D3DSP_REGTYPE_SHIFT);
 606
 607           switch (regtype << D3DSP_REGTYPE_SHIFT) {
 608           case D3DSPR_TEMP:
 609             /*DPRINTF("p[%d]=R[%d]\n", i, reg);*/
 610             p[i] = &R[reg];
 611             break;
 612           case D3DSPR_INPUT:
 613             /*DPRINTF("p[%d]=V[%s]\n", i, VertexShaderDeclRegister[reg]);*/
 614             p[i] = &input->V[reg];
 615             break;
 616           case D3DSPR_CONST:
 617             if (reg & D3DVS_ADDRMODE_RELATIVE) {
 618               p[i] = &vshader->data->C[(DWORD) A[0].x + reg];
 619             } else {
 620               p[i] = &vshader->data->C[reg];
 621             }
 622             break;
 623           case D3DSPR_ADDR: /*case D3DSPR_TEXTURE:*/
 624             if (0 != reg) {
 625               ERR("cannot handle address registers != a0, forcing use of a0\n");
 626               reg = 0;
 627             }
 628             /*DPRINTF("p[%d]=A[%d]\n", i, reg);*/
 629             p[i] = &A[reg];
 630             break;
 631           case D3DSPR_RASTOUT:
 632             switch (reg) {
 633             case D3DSRO_POSITION:
 634               p[i] = &output->oPos;
 635               break;
 636             case D3DSRO_FOG:
 637               p[i] = &output->oFog;
 638               break;
 639             case D3DSRO_POINT_SIZE:
 640               p[i] = &output->oPts;
 641               break;
 642             }
 643             break;
 644           case D3DSPR_ATTROUT:
 645             /*DPRINTF("p[%d]=oD[%d]\n", i, reg);*/
 646             p[i] = &output->oD[reg];
 647             break;
 648           case D3DSPR_TEXCRDOUT:
 649             /*DPRINTF("p[%d]=oT[%d]\n", i, reg);*/
 650             p[i] = &output->oT[reg];
 651             break;
 652           default:
 653             break;
 654           }
 655
 656           if (i > 0) { /* input reg */
 657             DWORD swizzle = (pToken[i] & D3DVS_SWIZZLE_MASK) >> D3DVS_SWIZZLE_SHIFT;
 658             UINT isNegative = ((*pToken & D3DSP_SRCMOD_MASK) == D3DSPSM_NEG);
 659
 660             if (!isNegative && (D3DVS_NOSWIZZLE >> D3DVS_SWIZZLE_SHIFT) == swizzle) {
 661               /*DPRINTF("p[%d] not swizzled\n", i);*/
 662               p_send[i] = p[i];
 663             } else {
 664               DWORD swizzle_x = swizzle & 0x03;
 665               DWORD swizzle_y = (swizzle >> 2) & 0x03;
 666               DWORD swizzle_z = (swizzle >> 4) & 0x03;
 667               DWORD swizzle_w = (swizzle >> 6) & 0x03;
 668               /*DPRINTF("p[%d] swizzled\n", i);*/
 669               float* tt = (float*) p[i];
 670               s[i].x = (isNegative) ? -tt[swizzle_x] : tt[swizzle_x];
 671               s[i].y = (isNegative) ? -tt[swizzle_y] : tt[swizzle_y];
 672               s[i].z = (isNegative) ? -tt[swizzle_z] : tt[swizzle_z];
 673               s[i].w = (isNegative) ? -tt[swizzle_w] : tt[swizzle_w];
 674               p_send[i] = &s[i];
 675             }
 676           } else { /* output reg */
 677             if ((pToken[i] & D3DSP_WRITEMASK_ALL) == D3DSP_WRITEMASK_ALL) {
 678               p_send[i] = p[i];
 679             } else {
 680               p_send[i] = &d; /* to be post-processed for modifiers management */
 681             }
 682           }
 683         }
 684       }
 685
 686       switch (curOpcode->num_params) {
 687       case 0:
 688         curOpcode->soft_fct();
 689         break;
 690       case 1:
 691         curOpcode->soft_fct(p_send[0]);
 692         break;
 693       case 2:
 694         curOpcode->soft_fct(p_send[0], p_send[1]);
 695         break;
 696       case 3:
 697         curOpcode->soft_fct(p_send[0], p_send[1], p_send[2]);
 698         break;
 699       case 4:
 700         curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3]);
 701         break;
 702       case 5:
 703         curOpcode->soft_fct(p_send[0], p_send[1], p_send[2], p_send[3], p_send[4]);
 704         break;
 705       default:
 706         ERR("%s too many params: %u\n", curOpcode->name, curOpcode->num_params);
 707       }
 708
 709       /* check if output reg modifier post-process */
 710       if (curOpcode->num_params > 0 && (pToken[0] & D3DSP_WRITEMASK_ALL) != D3DSP_WRITEMASK_ALL) {
 711         if (pToken[0] & D3DSP_WRITEMASK_0) p[0]->x = d.x;
 712         if (pToken[0] & D3DSP_WRITEMASK_1) p[0]->y = d.y;
 713         if (pToken[0] & D3DSP_WRITEMASK_2) p[0]->z = d.z;
 714         if (pToken[0] & D3DSP_WRITEMASK_3) p[0]->w = d.w;
 715       }
 716
 717       /*
 718       TRACE_VECTOR(output->oPos);
 719       TRACE_VECTOR(output->oD[0]);
 720       TRACE_VECTOR(output->oD[1]);
 721       TRACE_VECTOR(output->oT[0]);
 722       TRACE_VECTOR(output->oT[1]);
 723       TRACE_VECTOR(R[0]);
 724       TRACE_VECTOR(R[1]);
 725       TRACE_VECTOR(R[2]);
 726       TRACE_VECTOR(R[3]);
 727       TRACE_VECTOR(R[4]);
 728       */
 729
 730       /* to next opcode token */
 731       pToken += curOpcode->num_params;
 732     }
 733   }
 734   return D3D_OK;
 735 }
 736
 737 HRESULT WINAPI IDirect3DVertexShaderImpl_GetFunction(IDirect3DVertexShaderImpl* This, VOID* pData, UINT* pSizeOfData) {
 738   if (NULL == pData) {
 739     *pSizeOfData = This->functionLength;
 740     return D3D_OK;
 741   }
 742   if (*pSizeOfData < This->functionLength) {
 743     *pSizeOfData = This->functionLength;
 744     return D3DERR_MOREDATA;
 745   }
 746   if (NULL == This->function) { /* no function defined */
 747     TRACE("(%p) : GetFunction no User Function defined using NULL to %p\n", This, pData);
 748     (*(DWORD **) pData) = NULL;
 749   } else {
 750     TRACE("(%p) : GetFunction copying to %p\n", This, pData);
 751     memcpy(pData, This->function, This->functionLength);
 752   }
 753   return D3D_OK;
 754 }
 755
 756 HRESULT WINAPI IDirect3DVertexShaderImpl_SetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, CONST FLOAT* pConstantData, UINT Vector4fCount) {
 757   if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
 758     return D3DERR_INVALIDCALL;
 759   }
 760   if (NULL == This->data) { /* temporary while datas not supported */
 761     FIXME("(%p) : VertexShader_SetConstant not fully supported yet\n", This);
 762     return D3DERR_INVALIDCALL;
 763   }
 764   memcpy(&This->data->C[StartRegister], pConstantData, Vector4fCount * 4 * sizeof(FLOAT));
 765   return D3D_OK;
 766 }
 767
 768 HRESULT WINAPI IDirect3DVertexShaderImpl_GetConstantF(IDirect3DVertexShaderImpl* This, UINT StartRegister, FLOAT* pConstantData, UINT Vector4fCount) {
 769   if (StartRegister + Vector4fCount > D3D8_VSHADER_MAX_CONSTANTS) {
 770     return D3DERR_INVALIDCALL;
 771   }
 772   if (NULL == This->data) { /* temporary while datas not supported */
 773     return D3DERR_INVALIDCALL;
 774   }
 775   memcpy(pConstantData, &This->data->C[StartRegister], Vector4fCount * 4 * sizeof(FLOAT));
 776   return D3D_OK;
 777 }
 778
 779
 780 /***********************************************************************
 781  *              ValidateVertexShader (D3D8.@)
 782  */
 783 BOOL WINAPI ValidateVertexShader(LPVOID what, LPVOID toto) {
 784   FIXME("(void): stub: %p %p\n", what, toto);
 785   return TRUE;
 786 }
 787
 788 /***********************************************************************
 789  *              ValidatePixelShader (D3D8.@)
 790  */
 791 BOOL WINAPI ValidatePixelShader(LPVOID what) {
 792   FIXME("(void): stub: %p\n", what);
 793   return TRUE;
 794 }