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