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