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

   1 /*
   2  * vertex shaders declaration 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_shader);
  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 /** Vertex Shader Declaration data types tokens */
  68 #define MAX_VSHADER_DECL_TYPES 8
  69 static CONST char* VertexShaderDeclDataTypes[] = {
  70   "D3DVSDT_FLOAT1",
  71   "D3DVSDT_FLOAT2",
  72   "D3DVSDT_FLOAT3",
  73   "D3DVSDT_FLOAT4",
  74   "D3DVSDT_D3DCOLOR",
  75   "D3DVSDT_UBYTE4",
  76   "D3DVSDT_SHORT2",
  77   "D3DVSDT_SHORT4",
  78   NULL
  79 };
  80
  81 static CONST char* VertexShaderDeclRegister[] = {
  82   "D3DVSDE_POSITION",
  83   "D3DVSDE_BLENDWEIGHT",
  84   "D3DVSDE_BLENDINDICES",
  85   "D3DVSDE_NORMAL",
  86   "D3DVSDE_PSIZE",
  87   "D3DVSDE_DIFFUSE",
  88   "D3DVSDE_SPECULAR",
  89   "D3DVSDE_TEXCOORD0",
  90   "D3DVSDE_TEXCOORD1",
  91   "D3DVSDE_TEXCOORD2",
  92   "D3DVSDE_TEXCOORD3",
  93   "D3DVSDE_TEXCOORD4",
  94   "D3DVSDE_TEXCOORD5",
  95   "D3DVSDE_TEXCOORD6",
  96   "D3DVSDE_TEXCOORD7",
  97   "D3DVSDE_POSITION2",
  98   "D3DVSDE_NORMAL2",
  99   NULL
 100 };
 101
 102 /** todo check decl validity */
 103 /*inline static*/ DWORD Direct3DVextexShaderDeclarationImpl_ParseToken(const DWORD* pToken) {
 104   const DWORD token = *pToken;
 105   DWORD tokenlen = 1;
 106
 107   switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
 108   case D3DVSD_TOKEN_NOP:
 109     TRACE(" 0x%08lx NOP()\n", token);
 110     break;
 111   case D3DVSD_TOKEN_STREAM:
 112     if (token & D3DVSD_STREAMTESSMASK) {
 113       TRACE(" 0x%08lx STREAM_TESS()\n", token);
 114     } else {
 115       TRACE(" 0x%08lx STREAM(%lu)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
 116     }
 117     break;
 118   case D3DVSD_TOKEN_STREAMDATA:
 119     if (token & 0x10000000) {
 120       TRACE(" 0x%08lx SKIP(%lu)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
 121     } else {
 122       DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
 123       DWORD reg  = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 124       TRACE(" 0x%08lx REG(%s, %s)\n", token, VertexShaderDeclRegister[reg], VertexShaderDeclDataTypes[type]);
 125     }
 126     break;
 127   case D3DVSD_TOKEN_TESSELLATOR:
 128     if (token & 0x10000000) {
 129       DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
 130       DWORD reg  = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 131       TRACE(" 0x%08lx TESSUV(%s) as %s\n", token, VertexShaderDeclRegister[reg], VertexShaderDeclDataTypes[type]);
 132     } else {
 133       DWORD type   = ((token & D3DVSD_DATATYPEMASK)    >> D3DVSD_DATATYPESHIFT);
 134       DWORD regout = ((token & D3DVSD_VERTEXREGMASK)   >> D3DVSD_VERTEXREGSHIFT);
 135       DWORD regin  = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
 136       TRACE(" 0x%08lx TESSNORMAL(%s, %s) as %s\n", token, VertexShaderDeclRegister[regin], VertexShaderDeclRegister[regout], VertexShaderDeclDataTypes[type]);
 137     }
 138     break;
 139   case D3DVSD_TOKEN_CONSTMEM:
 140     {
 141       DWORD i;
 142       DWORD count        = ((token & D3DVSD_CONSTCOUNTMASK)   >> D3DVSD_CONSTCOUNTSHIFT);
 143       DWORD constaddress = ((token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
 144       TRACE(" 0x%08lx CONST(%lu, %lu)\n", token, constaddress, count);
 145       ++pToken;
 146       for (i = 0; i < count; ++i) {
 147 #if 0
 148         TRACE("        c[%lu] = (0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx)\n",
 149                 constaddress,
 150                 *pToken,
 151                 *(pToken + 1),
 152                 *(pToken + 2),
 153                 *(pToken + 3));
 154 #endif
 155         TRACE("        c[%lu] = (%8f, %8f, %8f, %8f)\n",
 156                 constaddress,
 157                  *(float*) pToken,
 158                  *(float*) (pToken + 1),
 159                  *(float*) (pToken + 2),
 160                  *(float*) (pToken + 3));
 161         pToken += 4;
 162         ++constaddress;
 163       }
 164       tokenlen = (4 * count) + 1;
 165     }
 166     break;
 167   case D3DVSD_TOKEN_EXT:
 168     {
 169       DWORD count   = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
 170       DWORD extinfo = ((token & D3DVSD_EXTINFOMASK)    >> D3DVSD_EXTINFOSHIFT);
 171       TRACE(" 0x%08lx EXT(%lu, %lu)\n", token, count, extinfo);
 172       /* todo ... print extension */
 173       tokenlen = count + 1;
 174     }
 175     break;
 176   case D3DVSD_TOKEN_END:
 177     TRACE(" 0x%08lx END()\n", token);
 178     break;
 179   default:
 180     TRACE(" 0x%08lx UNKNOWN\n", token);
 181     /* argg error */
 182   }
 183   return tokenlen;
 184 }
 185
 186 HRESULT WINAPI IDirect3DDeviceImpl_CreateVertexShaderDeclaration8(IDirect3DDevice8Impl* This, CONST DWORD* pDeclaration8, IDirect3DVertexShaderDeclarationImpl** ppVertexShaderDecl) {
 187   /** parser data */
 188   const DWORD* pToken = pDeclaration8;
 189   DWORD fvf = 0;
 190   DWORD len = 0;
 191   DWORD stream = 0;
 192   DWORD token;
 193   DWORD tokenlen;
 194   DWORD tokentype;
 195   DWORD tex = D3DFVF_TEX0;
 196   /** TRUE if declaration can be matched by a fvf */
 197   IDirect3DVertexShaderDeclarationImpl* object;
 198   BOOL  invalid_fvf = FALSE;
 199
 200   TRACE("(%p) :  pDeclaration8(%p)\n", This, pDeclaration8);
 201
 202   object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexShaderDeclarationImpl));
 203   /*object->lpVtbl = &Direct3DVextexShaderDeclaration8_Vtbl;*/
 204   object->device = This; /* FIXME: AddRef(This) */
 205   object->ref = 1;
 206   object->allFVF = 0;
 207
 208   while (D3DVSD_END() != *pToken) {
 209     token = *pToken;
 210     tokenlen = Direct3DVextexShaderDeclarationImpl_ParseToken(pToken);
 211     tokentype = ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
 212
 213     /** FVF generation block */
 214     if (D3DVSD_TOKEN_STREAM == tokentype && 0 == (D3DVSD_STREAMTESSMASK & token)) {
 215       /**
 216        * how really works streams,
 217        *  in DolphinVS dx8 dsk sample they seems to decal reg numbers !!!
 218        */
 219       DWORD oldStream = stream;
 220       stream = ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
 221
 222       /* copy fvf if valid */
 223       if (FALSE == invalid_fvf) {
 224           fvf |= tex << D3DFVF_TEXCOUNT_SHIFT;
 225           tex = 0;
 226           object->fvf[oldStream] = fvf;
 227           object->allFVF |= fvf;
 228       } else {
 229           object->fvf[oldStream] = 0;
 230           tex = 0;
 231       }
 232
 233       /* reset valid/invalid fvf */
 234       fvf = 0;
 235       invalid_fvf = FALSE;
 236
 237     } else if (D3DVSD_TOKEN_STREAMDATA == tokentype && 0 == (0x10000000 & tokentype)) {
 238       DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
 239       DWORD reg  = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 240
 241       switch (reg) {
 242       case D3DVSDE_POSITION:
 243         switch (type) {
 244         case D3DVSDT_FLOAT3:     fvf |= D3DFVF_XYZ;             break;
 245         case D3DVSDT_FLOAT4:     fvf |= D3DFVF_XYZRHW;          break;
 246         default:
 247           /** errooooorr mismatched use of a register, invalid fvf computing */
 248           invalid_fvf = TRUE;
 249           if (type >= MAX_VSHADER_DECL_TYPES) {
 250             TRACE("Mismatched use in VertexShader declaration of D3DVSDE_POSITION register: unsupported and unrecognized type %08lx\n", type);
 251           } else {
 252             TRACE("Mismatched use in VertexShader declaration of D3DVSDE_POSITION register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 253           }
 254         }
 255         break;
 256
 257       case D3DVSDE_BLENDWEIGHT:
 258         switch (type) {
 259         case D3DVSDT_FLOAT1:     fvf |= D3DFVF_XYZB1;           break;
 260         case D3DVSDT_FLOAT2:     fvf |= D3DFVF_XYZB2;           break;
 261         case D3DVSDT_FLOAT3:     fvf |= D3DFVF_XYZB3;           break;
 262         case D3DVSDT_FLOAT4:     fvf |= D3DFVF_XYZB4;           break;
 263         default:
 264           /** errooooorr mismatched use of a register, invalid fvf computing */
 265           invalid_fvf = TRUE;
 266           TRACE("Mismatched use in VertexShader declaration of D3DVSDE_BLENDWEIGHT register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 267         }
 268         break;
 269
 270       case D3DVSDE_BLENDINDICES: /* seem to be B5 as said in MSDN Dx9SDK ??  */
 271         switch (type) {
 272         case D3DVSDT_UBYTE4:     fvf |= D3DFVF_LASTBETA_UBYTE4;           break;
 273         default:
 274           /** errooooorr mismatched use of a register, invalid fvf computing */
 275           invalid_fvf = TRUE;
 276           TRACE("Mismatched use in VertexShader declaration of D3DVSDE_BLENDINDINCES register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 277         }
 278         break;
 279
 280       case D3DVSDE_NORMAL: /* TODO: only FLOAT3 supported ... another choice possible ? */
 281         switch (type) {
 282         case D3DVSDT_FLOAT3:     fvf |= D3DFVF_NORMAL;          break;
 283         default:
 284           /** errooooorr mismatched use of a register, invalid fvf computing */
 285           invalid_fvf = TRUE;
 286           TRACE("Mismatched use in VertexShader declaration of D3DVSDE_NORMAL register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 287         }
 288         break;
 289
 290       case D3DVSDE_PSIZE:  /* TODO: only FLOAT1 supported ... another choice possible ? */
 291         switch (type) {
 292         case D3DVSDT_FLOAT1:     fvf |= D3DFVF_PSIZE;           break;
 293         default:
 294           /** errooooorr mismatched use of a register, invalid fvf computing */
 295           invalid_fvf = TRUE;
 296           TRACE("Mismatched use in VertexShader declaration of D3DVSDE_PSIZE register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 297         }
 298         break;
 299
 300       case D3DVSDE_DIFFUSE:  /* TODO: only D3DCOLOR supported */
 301         switch (type) {
 302         case D3DVSDT_D3DCOLOR:   fvf |= D3DFVF_DIFFUSE;         break;
 303         default:
 304           /** errooooorr mismatched use of a register, invalid fvf computing */
 305           invalid_fvf = TRUE;
 306           TRACE("Mismatched use in VertexShader declaration of D3DVSDE_DIFFUSE register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 307         }
 308         break;
 309
 310       case D3DVSDE_SPECULAR:  /* TODO: only D3DCOLOR supported */
 311         switch (type) {
 312         case D3DVSDT_D3DCOLOR:   fvf |= D3DFVF_SPECULAR;        break;
 313         default:
 314           /** errooooorr mismatched use of a register, invalid fvf computing */
 315           invalid_fvf = TRUE;
 316           TRACE("Mismatched use in VertexShader declaration of D3DVSDE_SPECULAR register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 317         }
 318         break;
 319
 320       case D3DVSDE_TEXCOORD0:
 321       case D3DVSDE_TEXCOORD1:
 322       case D3DVSDE_TEXCOORD2:
 323       case D3DVSDE_TEXCOORD3:
 324       case D3DVSDE_TEXCOORD4:
 325       case D3DVSDE_TEXCOORD5:
 326       case D3DVSDE_TEXCOORD6:
 327       case D3DVSDE_TEXCOORD7:
 328          /* Fixme? - assume all tex coords in same stream */
 329          {
 330              int texNo = 1 + (reg - D3DVSDE_TEXCOORD0);
 331              tex = max(tex, texNo);
 332              switch (type) {
 333              case D3DVSDT_FLOAT1: fvf |= D3DFVF_TEXCOORDSIZE1(texNo); break;
 334              case D3DVSDT_FLOAT2: fvf |= D3DFVF_TEXCOORDSIZE2(texNo); break;
 335              case D3DVSDT_FLOAT3: fvf |= D3DFVF_TEXCOORDSIZE3(texNo); break;
 336              case D3DVSDT_FLOAT4: fvf |= D3DFVF_TEXCOORDSIZE4(texNo); break;
 337              default:
 338                /** errooooorr mismatched use of a register, invalid fvf computing */
 339                invalid_fvf = TRUE;
 340                TRACE("Mismatched use in VertexShader declaration of D3DVSDE_TEXCOORD? register: unsupported type %s\n", VertexShaderDeclDataTypes[type]);
 341              }
 342          }
 343          break;
 344
 345       case D3DVSDE_POSITION2:   /* maybe D3DFVF_XYZRHW instead D3DFVF_XYZ (of D3DVDE_POSITION) ... to see */
 346       case D3DVSDE_NORMAL2:     /* FIXME i don't know what to do here ;( */
 347         TRACE("[%lu] registers in VertexShader declaration not supported yet (token:0x%08lx)\n", reg, token);
 348         break;
 349       }
 350       TRACE("VertexShader declaration define %lx as current FVF\n", fvf);
 351     }
 352     len += tokenlen;
 353     pToken += tokenlen;
 354   }
 355   /* here D3DVSD_END() */
 356   len +=  Direct3DVextexShaderDeclarationImpl_ParseToken(pToken);
 357
 358   /* copy fvf if valid */
 359   if (FALSE == invalid_fvf) {
 360       fvf |= tex << D3DFVF_TEXCOUNT_SHIFT;
 361       object->fvf[stream] = fvf;
 362       object->allFVF |= fvf;
 363   } else {
 364       object->fvf[stream] = 0;
 365   }
 366   TRACE("Completed, allFVF = %lx\n", object->allFVF);
 367
 368   /* compute size */
 369   object->declaration8Length = len * sizeof(DWORD);
 370   /* copy the declaration */
 371   object->pDeclaration8 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, object->declaration8Length);
 372   memcpy(object->pDeclaration8, pDeclaration8, object->declaration8Length);
 373   /* returns */
 374   *ppVertexShaderDecl = object;
 375   return D3D_OK;
 376 }
 377
 378
 379 HRESULT WINAPI IDirect3DDeviceImpl_FillVertexShaderInput(IDirect3DDevice8Impl* This,
 380                                                          IDirect3DVertexShaderImpl* vshader,
 381                                                          DWORD SkipnStrides) {
 382   /** parser data */
 383   const DWORD* pToken = This->UpdateStateBlock->vertexShaderDecl->pDeclaration8;
 384   DWORD stream = 0;
 385   DWORD token;
 386   /*DWORD tokenlen;*/
 387   DWORD tokentype;
 388   /** for input readers */
 389   const char* curPos = NULL;
 390   FLOAT x, y, z, w;
 391   SHORT u, v, r, t;
 392   DWORD dw;
 393
 394   TRACE("(%p) - This:%p, skipstrides=%lu\n", vshader, This, SkipnStrides);
 395
 396   while (D3DVSD_END() != *pToken) {
 397     token = *pToken;
 398     tokentype = ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
 399
 400     /** FVF generation block */
 401     if (D3DVSD_TOKEN_STREAM == tokentype && 0 == (D3DVSD_STREAMTESSMASK & token)) {
 402       IDirect3DVertexBuffer8* pVB;
 403       int skip = 0;
 404
 405       ++pToken;
 406       /**
 407        * how really works streams,
 408        *  in DolphinVS dx8 dsk sample use it !!!
 409        */
 410       stream = ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
 411       skip = This->StateBlock->stream_stride[stream];
 412       pVB  = This->StateBlock->stream_source[stream];
 413
 414       if (NULL == pVB) {
 415           ERR("using unitialised stream[%lu]\n", stream);
 416           return D3DERR_INVALIDCALL;
 417       } else {
 418           if (This->StateBlock->streamIsUP == TRUE) {
 419               curPos = ((char *) pVB) + (SkipnStrides * skip);   /* Not really a VB */
 420           } else {
 421               curPos = ((IDirect3DVertexBuffer8Impl*) pVB)->allocatedMemory + (SkipnStrides * skip);
 422           }
 423
 424           TRACE(" using stream[%lu] with %p (%p + (Stride %d * skip %ld))\n", stream, curPos,
 425                  ((IDirect3DVertexBuffer8Impl*) pVB)->allocatedMemory, skip, SkipnStrides);
 426       }
 427     } else if (D3DVSD_TOKEN_CONSTMEM == tokentype) {
 428       /** Const decl */
 429       DWORD i;
 430       DWORD count        = ((token & D3DVSD_CONSTCOUNTMASK)   >> D3DVSD_CONSTCOUNTSHIFT);
 431       DWORD constaddress = ((token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
 432       ++pToken;
 433       for (i = 0; i < count; ++i) {
 434         vshader->data->C[constaddress + i].x = *(float*)pToken;
 435         vshader->data->C[constaddress + i].y = *(float*)(pToken + 1);
 436         vshader->data->C[constaddress + i].z = *(float*)(pToken + 2);
 437         vshader->data->C[constaddress + i].w = *(float*)(pToken + 3);
 438         pToken += 4;
 439       }
 440
 441     } else if (D3DVSD_TOKEN_STREAMDATA == tokentype && 0 != (0x10000000 & tokentype)) {
 442       /** skip datas */
 443       DWORD skipCount = ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
 444       curPos = curPos + skipCount * sizeof(DWORD);
 445       ++pToken;
 446
 447     } else if (D3DVSD_TOKEN_STREAMDATA == tokentype && 0 == (0x10000000 & tokentype)) {
 448       DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
 449       DWORD reg  = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 450       ++pToken;
 451
 452       switch (type) {
 453       case D3DVSDT_FLOAT1:
 454         x = *(float*) curPos;
 455         curPos = curPos + sizeof(float);
 456         /**/
 457         vshader->input.V[reg].x = x;
 458         vshader->input.V[reg].y = 0.0f;
 459         vshader->input.V[reg].z = 0.0f;
 460         vshader->input.V[reg].w = 1.0f;
 461         break;
 462
 463       case D3DVSDT_FLOAT2:
 464         x = *(float*) curPos;
 465         curPos = curPos + sizeof(float);
 466         y = *(float*) curPos;
 467         curPos = curPos + sizeof(float);
 468         /**/
 469         vshader->input.V[reg].x = x;
 470         vshader->input.V[reg].y = y;
 471         vshader->input.V[reg].z = 0.0f;
 472         vshader->input.V[reg].w = 1.0f;
 473         break;
 474
 475       case D3DVSDT_FLOAT3:
 476         x = *(float*) curPos;
 477         curPos = curPos + sizeof(float);
 478         y = *(float*) curPos;
 479         curPos = curPos + sizeof(float);
 480         z = *(float*) curPos;
 481         curPos = curPos + sizeof(float);
 482         /**/
 483         vshader->input.V[reg].x = x;
 484         vshader->input.V[reg].y = y;
 485         vshader->input.V[reg].z = z;
 486         vshader->input.V[reg].w = 1.0f;
 487         break;
 488
 489       case D3DVSDT_FLOAT4:
 490         x = *(float*) curPos;
 491         curPos = curPos + sizeof(float);
 492         y = *(float*) curPos;
 493         curPos = curPos + sizeof(float);
 494         z = *(float*) curPos;
 495         curPos = curPos + sizeof(float);
 496         w = *(float*) curPos;
 497         curPos = curPos + sizeof(float);
 498         /**/
 499         vshader->input.V[reg].x = x;
 500         vshader->input.V[reg].y = y;
 501         vshader->input.V[reg].z = z;
 502         vshader->input.V[reg].w = w;
 503         break;
 504
 505       case D3DVSDT_D3DCOLOR:
 506         dw = *(DWORD*) curPos;
 507         curPos = curPos + sizeof(DWORD);
 508         /**/
 509         vshader->input.V[reg].x = (float) (((dw >> 16) & 0xFF) / 255.0f);
 510         vshader->input.V[reg].y = (float) (((dw >>  8) & 0xFF) / 255.0f);
 511         vshader->input.V[reg].z = (float) (((dw >>  0) & 0xFF) / 255.0f);
 512         vshader->input.V[reg].w = (float) (((dw >> 24) & 0xFF) / 255.0f);
 513         break;
 514
 515       case D3DVSDT_SHORT2:
 516         u = *(SHORT*) curPos;
 517         curPos = curPos + sizeof(SHORT);
 518         v = *(SHORT*) curPos;
 519         curPos = curPos + sizeof(SHORT);
 520         /**/
 521         vshader->input.V[reg].x = (float) u;
 522         vshader->input.V[reg].y = (float) v;
 523         vshader->input.V[reg].z = 0.0f;
 524         vshader->input.V[reg].w = 1.0f;
 525         break;
 526
 527       case D3DVSDT_SHORT4:
 528         u = *(SHORT*) curPos;
 529         curPos = curPos + sizeof(SHORT);
 530         v = *(SHORT*) curPos;
 531         curPos = curPos + sizeof(SHORT);
 532         r = *(SHORT*) curPos;
 533         curPos = curPos + sizeof(SHORT);
 534         t = *(SHORT*) curPos;
 535         curPos = curPos + sizeof(SHORT);
 536         /**/
 537         vshader->input.V[reg].x = (float) u;
 538         vshader->input.V[reg].y = (float) v;
 539         vshader->input.V[reg].z = (float) r;
 540         vshader->input.V[reg].w = (float) t;
 541         break;
 542
 543       case D3DVSDT_UBYTE4:
 544         dw = *(DWORD*) curPos;
 545         curPos = curPos + sizeof(DWORD);
 546         /**/
 547         vshader->input.V[reg].x = (float) ((dw & 0x000F) >>  0);
 548         vshader->input.V[reg].y = (float) ((dw & 0x00F0) >>  8);
 549         vshader->input.V[reg].z = (float) ((dw & 0x0F00) >> 16);
 550         vshader->input.V[reg].w = (float) ((dw & 0xF000) >> 24);
 551
 552         break;
 553
 554       default: /** errooooorr what to do ? */
 555         ERR("Error in VertexShader declaration of %s register: unsupported type %s\n", VertexShaderDeclRegister[reg], VertexShaderDeclDataTypes[type]);
 556       }
 557     }
 558
 559   }
 560   /* here D3DVSD_END() */
 561   return D3D_OK;
 562 }
 563
 564 HRESULT WINAPI IDirect3DVertexShaderDeclarationImpl_GetDeclaration8(IDirect3DVertexShaderDeclarationImpl* This, DWORD* pData, UINT* pSizeOfData) {
 565   if (NULL == pData) {
 566     *pSizeOfData = This->declaration8Length;
 567     return D3D_OK;
 568   }
 569   if (*pSizeOfData < This->declaration8Length) {
 570     *pSizeOfData = This->declaration8Length;
 571     return D3DERR_MOREDATA;
 572   }
 573   TRACE("(%p) : GetVertexShaderDeclaration copying to %p\n", This, pData);
 574   memcpy(pData, This->pDeclaration8, This->declaration8Length);
 575   return D3D_OK;
 576 }