Restructured DirectDraw. Split into X11 and DGA driver, and multiple
[wine] / dlls / ddraw / d3dexecutebuffer.c
1 /* Direct3D ExecuteBuffer
2    (c) 1998 Lionel ULMER
3    
4    This files contains the implementation of Direct3DExecuteBuffer. */
5
6
7 #include <string.h>
8 #include "config.h"
9 #include "windef.h"
10 #include "winerror.h"
11 #include "wine/obj_base.h"
12 #include "heap.h"
13 #include "ddraw.h"
14 #include "d3d.h"
15 #include "debugtools.h"
16
17 #include "mesa_private.h"
18
19 #define D3DDPRIVATE(x) mesa_d3dd_private *odev=((mesa_d3dd_private*)(x)->private)
20
21 DEFAULT_DEBUG_CHANNEL(ddraw)
22
23 /* Structure to store the 'semi transformed' vertices */
24 typedef struct {
25   D3DVALUE x;
26   D3DVALUE y;
27   D3DVALUE z;
28   D3DVALUE w;
29
30   D3DVALUE nx;
31   D3DVALUE ny;
32   D3DVALUE nz;
33
34   D3DVALUE u;
35   D3DVALUE v;
36 } OGL_Vertex;
37
38 typedef struct {
39   D3DVALUE x;
40   D3DVALUE y;
41   D3DVALUE z;
42   D3DVALUE w;
43
44   D3DCOLOR c;
45   D3DCOLOR sc;
46
47   D3DVALUE u;
48   D3DVALUE v;
49 } OGL_LVertex;
50
51 static ICOM_VTABLE(IDirect3DExecuteBuffer) executebuffer_vtable;
52
53 /*******************************************************************************
54  *                              ExecuteBuffer static functions
55  */
56 void _dump_d3dstatus(LPD3DSTATUS lpStatus) {
57   
58 }
59
60 void _dump_executedata(LPD3DEXECUTEDATA lpData) {
61   DPRINTF("dwSize : %ld\n", lpData->dwSize);
62   DPRINTF("Vertex      Offset : %ld  Count  : %ld\n", lpData->dwVertexOffset, lpData->dwVertexCount);
63   DPRINTF("Instruction Offset : %ld  Length : %ld\n", lpData->dwInstructionOffset, lpData->dwInstructionLength);
64   DPRINTF("HVertex     Offset : %ld\n", lpData->dwHVertexOffset);
65   _dump_d3dstatus(&(lpData->dsStatus));
66 }
67
68 #define DO_VERTEX(index)                        \
69 {                                                                               \
70   glTexCoord2f(vx[index].u,                                                     \
71                vx[index].v);                                                    \
72   glNormal3f(vx[index].nx,                                                      \
73              vx[index].ny,                                                      \
74              vx[index].nz);                                                     \
75   glVertex4f(vx[index].x,                                                       \
76              vx[index].y,                                                       \
77              vx[index].z,                                                       \
78              vx[index].w);                                                      \
79                                                                                 \
80   TRACE("   V: %f %f %f %f (%f %f %f) (%f %f)\n",                       \
81         vx[index].x, vx[index].y, vx[index].z, vx[index].w,                     \
82         vx[index].nx, vx[index].ny, vx[index].nz,                               \
83         vx[index].u, vx[index].v);                                              \
84 }
85
86 #define DO_LVERTEX(index)                                                       \
87 {                                                                               \
88   DWORD col = l_vx[index].c;                                                    \
89                                                                                 \
90   glColor3f(((col >> 16) & 0xFF) / 255.0,                                       \
91             ((col >>  8) & 0xFF) / 255.0,                                       \
92             ((col >>  0) & 0xFF) / 255.0);                                      \
93   glTexCoord2f(l_vx[index].u,                                                   \
94                l_vx[index].v);                                                  \
95   glVertex4f(l_vx[index].x,                                                     \
96              l_vx[index].y,                                                     \
97              l_vx[index].z,                                                     \
98              l_vx[index].w);                                                    \
99                                                                                 \
100   TRACE("  LV: %f %f %f %f (%02lx %02lx %02lx) (%f %f)\n",              \
101         l_vx[index].x, l_vx[index].y, l_vx[index].z, l_vx[index].w,             \
102         ((col >> 16) & 0xFF), ((col >>  8) & 0xFF), ((col >>  0) & 0xFF),       \
103         l_vx[index].u, l_vx[index].v);                                          \
104 }
105
106 #define DO_TLVERTEX(index)                                                      \
107 {                                                                               \
108   D3DTLVERTEX *vx = &(tl_vx[index]);                                            \
109   DWORD col = vx->c.color;                                                      \
110                                                                                 \
111   glColor3f(((col >> 16) & 0xFF) / 255.0,                                       \
112             ((col >>  8) & 0xFF) / 255.0,                                       \
113             ((col >>  0) & 0xFF) / 255.0);                                      \
114   glTexCoord2f(vx->u.tu, vx->v.tv);                                             \
115   if (vx->r.rhw < 0.01)                                                         \
116     glVertex3f(vx->x.sx,                                                        \
117                vx->y.sy,                                                        \
118                vx->z.sz);                                                       \
119   else                                                                          \
120     glVertex4f(vx->x.sx / vx->r.rhw,                                            \
121                vx->y.sy / vx->r.rhw,                                            \
122                vx->z.sz / vx->r.rhw,                                            \
123                1.0 / vx->r.rhw);                                                \
124   TRACE(" TLV: %f %f %f (%02lx %02lx %02lx) (%f %f) (%f)\n",            \
125         vx->x.sx, vx->y.sy, vx->z.sz,                                           \
126         ((col >> 16) & 0xFF), ((col >>  8) & 0xFF), ((col >>  0) & 0xFF),       \
127         vx->u.tu, vx->v.tv, vx->r.rhw);                                         \
128 }
129
130 #define TRIANGLE_LOOP(macro)                            \
131 {                                                       \
132   glBegin(GL_TRIANGLES); {                              \
133     for (i = 0; i < count; i++) {                       \
134       LPD3DTRIANGLE ci = (LPD3DTRIANGLE) instr;         \
135                                                         \
136       TRACE("  v1: %d  v2: %d  v3: %d\n",       \
137             ci->v1.v1, ci->v2.v2, ci->v3.v3);           \
138       TRACE("  Flags : ");                      \
139       if (TRACE_ON(ddraw)) {                            \
140         /* Wireframe */                                 \
141         if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)        \
142           DPRINTF("EDGEENABLE1 ");                              \
143         if (ci->wFlags & D3DTRIFLAG_EDGEENABLE2)        \
144           DPRINTF("EDGEENABLE2 ");                              \
145         if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)        \
146           DPRINTF("EDGEENABLE3 ");                              \
147                                                         \
148         /* Strips / Fans */                             \
149         if (ci->wFlags == D3DTRIFLAG_EVEN)              \
150           DPRINTF("EVEN ");                             \
151         if (ci->wFlags == D3DTRIFLAG_ODD)               \
152           DPRINTF("ODD ");                                      \
153         if (ci->wFlags == D3DTRIFLAG_START)             \
154           DPRINTF("START ");                            \
155         if ((ci->wFlags > 0) && (ci->wFlags < 30))      \
156           DPRINTF("STARTFLAT(%d) ", ci->wFlags);                \
157         DPRINTF("\n");                                  \
158       }                                                 \
159                                                         \
160       /* Draw the triangle */                           \
161       macro(ci->v1.v1);                                 \
162       macro(ci->v2.v2);                                 \
163       macro(ci->v3.v3);                                 \
164                                                         \
165       instr += size;                                    \
166     }                                                   \
167   } glEnd();                                            \
168 }
169
170
171 static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
172                     LPDIRECT3DDEVICE dev,
173                     LPDIRECT3DVIEWPORT vp) {
174   IDirect3DExecuteBufferImpl* ilpBuff=(IDirect3DExecuteBufferImpl*)lpBuff;
175   IDirect3DViewport2Impl* ivp=(IDirect3DViewport2Impl*)vp;
176   /* DWORD bs = ilpBuff->desc.dwBufferSize; */
177   DWORD vs = ilpBuff->data.dwVertexOffset;
178   /* DWORD vc = ilpBuff->data.dwVertexCount; */
179   DWORD is = ilpBuff->data.dwInstructionOffset;
180   /* DWORD il = ilpBuff->data.dwInstructionLength; */
181   
182   void *instr = ilpBuff->desc.lpData + is;
183   D3DDPRIVATE((IDirect3DDeviceImpl*)dev);
184   
185   TRACE("ExecuteData : \n");
186   if (TRACE_ON(ddraw))
187   _dump_executedata(&(ilpBuff->data));
188   
189   ENTER_GL();
190   
191   while (1) {
192     LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr;
193     BYTE size;
194     WORD count;
195
196     count = current->wCount;
197     size = current->bSize;
198     instr += sizeof(D3DINSTRUCTION);
199     
200     switch (current->bOpcode) {
201     case D3DOP_POINT: {
202       TRACE("POINT-s          (%d)\n", count);
203
204       instr += count * size;
205     } break;
206       
207     case D3DOP_LINE: {
208       TRACE("LINE-s           (%d)\n", count);
209
210       instr += count * size;
211     } break;
212       
213     case D3DOP_TRIANGLE: {
214       int i;
215       float z_inv_matrix[16] = {
216         1.0, 0.0,  0.0, 0.0,
217         0.0, 1.0,  0.0, 0.0,
218         0.0, 0.0, -1.0, 0.0,
219         0.0, 0.0,  1.0, 1.0
220       };
221       
222       OGL_Vertex  *vx    = (OGL_Vertex  *) ilpBuff->vertex_data;
223       OGL_LVertex *l_vx  = (OGL_LVertex *) ilpBuff->vertex_data;
224       D3DTLVERTEX *tl_vx = (D3DTLVERTEX *) ilpBuff->vertex_data;
225       
226       TRACE("TRIANGLE         (%d)\n", count);
227
228       switch (ilpBuff->vertex_type) {
229       case D3DVT_VERTEX:
230         /* This time, there is lighting */
231         glEnable(GL_LIGHTING);
232         
233       /* Use given matrixes */
234       glMatrixMode(GL_MODELVIEW);
235       glLoadIdentity(); /* The model transformation was done during the
236                            transformation phase */
237       glMatrixMode(GL_PROJECTION);
238         TRACE("  Projection Matrix : (%p)\n", odev->proj_mat);
239         dump_mat(odev->proj_mat);
240         TRACE("  View       Matrix : (%p)\n", odev->view_mat);
241         dump_mat(odev->view_mat);
242
243         glLoadMatrixf((float *) z_inv_matrix);
244         glMultMatrixf((float *) odev->proj_mat);
245       glMultMatrixf((float *) odev->view_mat);
246         break;
247
248       case D3DVT_LVERTEX:
249         /* No lighting */
250         glDisable(GL_LIGHTING);
251
252         /* Use given matrixes */
253         glMatrixMode(GL_MODELVIEW);
254         glLoadIdentity(); /* The model transformation was done during the
255                              transformation phase */
256         glMatrixMode(GL_PROJECTION);
257
258         TRACE("  Projection Matrix : (%p)\n", odev->proj_mat);
259         dump_mat(odev->proj_mat);
260         TRACE("  View       Matrix : (%p)\n", odev->view_mat);
261         dump_mat(odev->view_mat);
262
263         glLoadMatrixf((float *) z_inv_matrix);
264         glMultMatrixf((float *) odev->proj_mat);
265         glMultMatrixf((float *) odev->view_mat);
266         break;
267
268       case D3DVT_TLVERTEX: {
269         GLdouble height, width, minZ, maxZ;
270         
271         /* First, disable lighting */
272         glDisable(GL_LIGHTING);
273         
274         /* Then do not put any transformation matrixes */
275         glMatrixMode(GL_MODELVIEW);
276         glLoadIdentity();
277         glMatrixMode(GL_PROJECTION);
278         glLoadIdentity();
279         
280         if (ivp == NULL) {
281           ERR("No current viewport !\n");
282           /* Using standard values */
283           height = 640.0;
284           width = 480.0;
285           minZ = -10.0;
286           maxZ = 10.0;
287         } else {
288           height = (GLdouble) ivp->viewport.vp1.dwHeight;
289           width  = (GLdouble) ivp->viewport.vp1.dwWidth;
290           minZ   = (GLdouble) ivp->viewport.vp1.dvMinZ;
291           maxZ   = (GLdouble) ivp->viewport.vp1.dvMaxZ;
292
293           if (minZ == maxZ) {
294             /* I do not know why, but many Dx 3.0 games have minZ = maxZ = 0.0 */
295             minZ = 0.0;
296             maxZ = 1.0;
297         }
298         }
299
300         glOrtho(0.0, width, height, 0.0, -minZ, -maxZ);
301       } break;
302         
303       default:
304         ERR("Unhandled vertex type !\n");
305         break;
306       }
307
308       switch (ilpBuff->vertex_type) {
309       case D3DVT_VERTEX:
310         TRIANGLE_LOOP(DO_VERTEX);
311         break;
312         
313       case D3DVT_LVERTEX:
314         TRIANGLE_LOOP(DO_LVERTEX);
315         break;
316         
317       case D3DVT_TLVERTEX:
318         TRIANGLE_LOOP(DO_TLVERTEX);
319         break;
320         
321       default:
322         ERR("Unhandled vertex type !\n");
323       }
324       
325     } break;
326     
327     case D3DOP_MATRIXLOAD: {
328       TRACE("MATRIXLOAD-s     (%d)\n", count);
329
330       instr += count * size;
331     } break;
332       
333     case D3DOP_MATRIXMULTIPLY: {
334       int i;
335       TRACE("MATRIXMULTIPLY   (%d)\n", count);
336
337       for (i = 0; i < count; i++) {
338         LPD3DMATRIXMULTIPLY ci = (LPD3DMATRIXMULTIPLY) instr;
339         LPD3DMATRIX a = (LPD3DMATRIX) ci->hDestMatrix;
340         LPD3DMATRIX b = (LPD3DMATRIX) ci->hSrcMatrix1;
341         LPD3DMATRIX c = (LPD3DMATRIX) ci->hSrcMatrix2;
342         
343         TRACE("  Dest : %08lx  Src1 : %08lx  Src2 : %08lx\n",
344               ci->hDestMatrix, ci->hSrcMatrix1, ci->hSrcMatrix2);
345
346         /* Do the multiplication..
347            As I am VERY lazy, I let OpenGL do the multiplication for me */
348         glMatrixMode(GL_PROJECTION);
349         /* Save the current matrix */
350         glPushMatrix();
351         /* Load Matrix one and do the multiplication */
352         glLoadMatrixf((float *) c);
353         glMultMatrixf((float *) b);
354         glGetFloatv(GL_PROJECTION_MATRIX, (float *) a);
355         /* Restore the current matrix */
356         glPopMatrix();
357         
358         instr += size;
359       }
360     } break;
361       
362     case D3DOP_STATETRANSFORM: {
363       int i;
364       TRACE("STATETRANSFORM   (%d)\n", count);
365
366       for (i = 0; i < count; i++) {
367         LPD3DSTATE ci = (LPD3DSTATE) instr;
368
369         /* Handle the state transform */
370         switch (ci->t.dtstTransformStateType) {
371         case D3DTRANSFORMSTATE_WORLD: {
372           TRACE("  WORLD (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
373           odev->world_mat = (D3DMATRIX*) ci->v.dwArg[0];
374         } break;
375
376         case D3DTRANSFORMSTATE_VIEW: {
377           TRACE("  VIEW (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
378           odev->view_mat = (D3DMATRIX*) ci->v.dwArg[0];
379         } break;
380
381         case D3DTRANSFORMSTATE_PROJECTION: {
382           TRACE("  PROJECTION (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
383           odev->proj_mat = (D3DMATRIX*) ci->v.dwArg[0];
384         } break;
385
386         default:
387           ERR("  Unhandled state transformation !! (%d)\n", (int) ci->t.dtstTransformStateType);
388           break;
389           
390         }
391         
392         instr += size;
393       }
394     } break;
395       
396     case D3DOP_STATELIGHT: {
397       int i;
398       TRACE("STATELIGHT       (%d)\n", count);
399
400       for (i = 0; i < count; i++) {
401         LPD3DSTATE ci = (LPD3DSTATE) instr;
402         
403         /* Handle the state transform */
404         switch (ci->t.dlstLightStateType) {
405         case D3DLIGHTSTATE_MATERIAL: {
406           IDirect3DMaterial2Impl* mat = (IDirect3DMaterial2Impl*) ci->v.dwArg[0];
407           TRACE("  MATERIAL\n");
408           
409           if (mat != NULL) {
410             mat->activate(mat);
411           } else {
412             TRACE("    bad Material Handle\n");
413           }
414         } break ;
415           
416         case D3DLIGHTSTATE_AMBIENT: {
417           float light[4];
418           DWORD dwLightState = ci->v.dwArg[0];
419           TRACE("  AMBIENT\n");
420           
421           light[0] = ((dwLightState >> 16) & 0xFF) / 255.0;
422           light[1] = ((dwLightState >>  8) & 0xFF) / 255.0;
423           light[2] = ((dwLightState >>  0) & 0xFF) / 255.0;
424           light[3] = 1.0;
425           glLightModelfv(GL_LIGHT_MODEL_AMBIENT, (float *) light);
426
427           TRACE("    R:%02lx G:%02lx B:%02lx A:%02lx\n",
428                 ((dwLightState >> 16) & 0xFF),
429                 ((dwLightState >>  8) & 0xFF),
430                 ((dwLightState >>  0) & 0xFF),
431                 ((dwLightState >> 24) & 0xFF));
432         } break ;
433           
434         case D3DLIGHTSTATE_COLORMODEL: {
435           TRACE("  COLORMODEL\n");
436         } break ;
437           
438         case D3DLIGHTSTATE_FOGMODE: {
439           TRACE("  FOGMODE\n");
440         } break ;
441           
442         case D3DLIGHTSTATE_FOGSTART: {
443           TRACE("  FOGSTART\n");
444         } break ;
445           
446         case D3DLIGHTSTATE_FOGEND: {
447           TRACE("  FOGEND\n");
448         } break ;
449           
450         case D3DLIGHTSTATE_FOGDENSITY: {
451           TRACE("  FOGDENSITY\n");
452         } break ;
453           
454         default:
455           ERR("  Unhandled light state !! (%d)\n", (int) ci->t.dlstLightStateType);
456           break;
457         }
458         instr += size;
459       }
460     } break;
461       
462     case D3DOP_STATERENDER: {
463       int i;
464       TRACE("STATERENDER      (%d)\n", count);
465       
466       for (i = 0; i < count; i++) {
467         LPD3DSTATE ci = (LPD3DSTATE) instr;
468         
469         /* Handle the state transform */
470         set_render_state(ci->t.drstRenderStateType, ci->v.dwArg[0], &(odev->rs));
471
472         instr += size;
473       }
474     } break;
475       
476     case D3DOP_PROCESSVERTICES: {
477       int i;
478       TRACE("PROCESSVERTICES  (%d)\n", count);
479       
480       for (i = 0; i < count; i++) {
481         LPD3DPROCESSVERTICES ci = (LPD3DPROCESSVERTICES) instr;
482         
483         TRACE("  Start : %d Dest : %d Count : %ld\n",
484               ci->wStart, ci->wDest, ci->dwCount);
485         TRACE("  Flags : ");
486         if (TRACE_ON(ddraw)) {
487           if (ci->dwFlags & D3DPROCESSVERTICES_COPY)
488             DPRINTF("COPY ");
489           if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
490             DPRINTF("NOCOLOR ");
491           if (ci->dwFlags == D3DPROCESSVERTICES_OPMASK)
492             DPRINTF("OPMASK ");
493           if (ci->dwFlags & D3DPROCESSVERTICES_TRANSFORM)
494             DPRINTF("TRANSFORM ");
495           if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT)
496             DPRINTF("TRANSFORMLIGHT ");
497           if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
498             DPRINTF("UPDATEEXTENTS ");
499           DPRINTF("\n");
500         }
501
502         /* This is where doing Direct3D on top on OpenGL is quite difficult.
503            This method transforms a set of vertices using the CURRENT state
504            (lighting, projection, ...) but does not rasterize them.
505            They will oinly be put on screen later (with the POINT / LINE and
506            TRIANGLE op-codes). The problem is that you can have a triangle
507            with each point having been transformed using another state...
508
509            In this implementation, I will emulate only ONE thing : each
510            vertex can have its own "WORLD" transformation (this is used in the
511            TWIST.EXE demo of the 5.2 SDK). I suppose that all vertices of the 
512            execute buffer use the same state.
513
514            If I find applications that change other states, I will try to do a
515            more 'fine-tuned' state emulation (but I may become quite tricky if 
516            it changes a light position in the middle of a triangle).
517            
518            In this case, a 'direct' approach (i.e. without using OpenGL, but
519            writing our own 3D rasterizer) would be easier. */
520
521         /* The current method (with the hypothesis that only the WORLD matrix
522            will change between two points) is like this :
523             - I transform 'manually' all the vertices with the current WORLD
524               matrix and store them in the vertex buffer
525             - during the rasterization phase, the WORLD matrix will be set to
526               the Identity matrix */
527
528         /* Enough for the moment */
529         if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) {
530           int nb;
531           D3DVERTEX  *src = ((LPD3DVERTEX)  (ilpBuff->desc.lpData + vs)) + ci->wStart;
532           OGL_Vertex *dst = ((OGL_Vertex *) (ilpBuff->vertex_data)) + ci->wDest;
533           D3DMATRIX *mat = odev->world_mat;
534
535           TRACE("  World Matrix : (%p)\n", mat);
536           dump_mat(mat);
537
538           ilpBuff->vertex_type = D3DVT_VERTEX;
539           
540           for (nb = 0; nb < ci->dwCount; nb++) {
541             /* For the moment, no normal transformation... */
542             dst->nx = src->nx.nx;
543             dst->ny = src->ny.ny;
544             dst->nz = src->nz.nz;
545             
546             dst->u  = src->u.tu;
547             dst->v  = src->v.tv;
548
549             /* Now, the matrix multiplication */
550             dst->x = (src->x.x * mat->_11) + (src->y.y * mat->_21) + (src->z.z * mat->_31) + (1.0 * mat->_41);
551             dst->y = (src->x.x * mat->_12) + (src->y.y * mat->_22) + (src->z.z * mat->_32) + (1.0 * mat->_42);
552             dst->z = (src->x.x * mat->_13) + (src->y.y * mat->_23) + (src->z.z * mat->_33) + (1.0 * mat->_43);
553             dst->w = (src->x.x * mat->_14) + (src->y.y * mat->_24) + (src->z.z * mat->_34) + (1.0 * mat->_44);
554             
555             src++;
556             dst++;
557           }
558         } else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) {
559           int nb;
560           D3DLVERTEX *src  = ((LPD3DLVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
561           OGL_LVertex *dst = ((OGL_LVertex *) (ilpBuff->vertex_data)) + ci->wDest;
562           D3DMATRIX *mat = odev->world_mat;
563
564           TRACE("  World Matrix : (%p)\n", mat);
565           dump_mat(mat);
566
567           ilpBuff->vertex_type = D3DVT_LVERTEX;
568           
569           for (nb = 0; nb < ci->dwCount; nb++) {
570             dst->c  = src->c.color;
571             dst->sc = src->s.specular;
572             dst->u  = src->u.tu;
573             dst->v  = src->v.tv;
574
575             /* Now, the matrix multiplication */
576             dst->x = (src->x.x * mat->_11) + (src->y.y * mat->_21) + (src->z.z * mat->_31) + (1.0 * mat->_41);
577             dst->y = (src->x.x * mat->_12) + (src->y.y * mat->_22) + (src->z.z * mat->_32) + (1.0 * mat->_42);
578             dst->z = (src->x.x * mat->_13) + (src->y.y * mat->_23) + (src->z.z * mat->_33) + (1.0 * mat->_43);
579             dst->w = (src->x.x * mat->_14) + (src->y.y * mat->_24) + (src->z.z * mat->_34) + (1.0 * mat->_44);
580             
581             src++;
582             dst++;
583           }
584         } else if (ci->dwFlags == D3DPROCESSVERTICES_COPY) {
585           D3DTLVERTEX *src = ((LPD3DTLVERTEX) (ilpBuff->desc.lpData + vs)) + ci->wStart;
586           D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (ilpBuff->vertex_data)) + ci->wDest;
587
588           ilpBuff->vertex_type = D3DVT_TLVERTEX;
589           
590           memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX));
591         } else {
592           ERR("Unhandled vertex processing !\n");
593         }
594         
595         instr += size;
596       }
597     } break;
598       
599     case D3DOP_TEXTURELOAD: {
600       TRACE("TEXTURELOAD-s    (%d)\n", count);
601
602       instr += count * size;
603     } break;
604       
605     case D3DOP_EXIT: {
606       TRACE("EXIT             (%d)\n", count);
607       /* We did this instruction */
608       instr += size;
609       /* Exit this loop */
610       goto end_of_buffer;
611     } break;
612       
613     case D3DOP_BRANCHFORWARD: {
614       int i;
615       TRACE("BRANCHFORWARD    (%d)\n", count);
616
617       for (i = 0; i < count; i++) {
618         LPD3DBRANCH ci = (LPD3DBRANCH) instr;
619         
620         if ((ilpBuff->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue) {
621           if (!ci->bNegate) {
622             TRACE(" Should branch to %ld\n", ci->dwOffset);
623           }
624         } else {
625           if (ci->bNegate) {
626             TRACE(" Should branch to %ld\n", ci->dwOffset);
627           }
628         }
629
630         instr += size;
631       }
632     } break;
633       
634     case D3DOP_SPAN: {
635       TRACE("SPAN-s           (%d)\n", count);
636
637       instr += count * size;
638     } break;
639       
640     case D3DOP_SETSTATUS: {
641       int i;
642       TRACE("SETSTATUS        (%d)\n", count);
643
644       for (i = 0; i < count; i++) {
645         LPD3DSTATUS ci = (LPD3DSTATUS) instr;
646         
647         ilpBuff->data.dsStatus = *ci;
648         
649         instr += size;
650       }
651     } break;
652
653     default:
654       ERR("Unhandled OpCode !!!\n");
655       /* Try to save ... */
656       instr += count * size;
657       break;
658     }
659   }
660
661  end_of_buffer:
662   LEAVE_GL();
663 }
664
665 /*******************************************************************************
666  *                              ExecuteBuffer Creation functions
667  */
668 LPDIRECT3DEXECUTEBUFFER d3dexecutebuffer_create(IDirect3DDeviceImpl* d3ddev, LPD3DEXECUTEBUFFERDESC lpDesc)
669 {
670   IDirect3DExecuteBufferImpl* eb;
671   
672   eb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DExecuteBufferImpl));
673   eb->ref = 1;
674   ICOM_VTBL(eb) = &executebuffer_vtable;
675   eb->d3ddev = d3ddev;
676
677   /* Initializes memory */
678   eb->desc = *lpDesc;
679
680   /* No buffer given */
681   if (!(eb->desc.dwFlags & D3DDEB_LPDATA))
682     eb->desc.lpData = NULL;
683
684   /* No buffer size given */
685   if (!(lpDesc->dwFlags & D3DDEB_BUFSIZE))
686     eb->desc.dwBufferSize = 0;
687
688   /* Create buffer if asked */
689   if ((eb->desc.lpData == NULL) && (eb->desc.dwBufferSize > 0)) {
690     eb->need_free = TRUE;
691     eb->desc.lpData = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,eb->desc.dwBufferSize);
692   } else {
693     eb->need_free = FALSE;
694   }
695     
696   /* No vertices for the moment */
697   eb->vertex_data = NULL;
698
699   eb->desc.dwFlags |= D3DDEB_LPDATA;
700
701   eb->execute = execute;
702   
703   return (LPDIRECT3DEXECUTEBUFFER)eb;
704 }
705
706 /*******************************************************************************
707  *                              IDirect3ExecuteBuffer methods
708  */
709
710 static HRESULT WINAPI IDirect3DExecuteBufferImpl_QueryInterface(LPDIRECT3DEXECUTEBUFFER iface,
711                                                             REFIID riid,
712                                                             LPVOID* ppvObj)
713 {
714   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
715   
716   FIXME("(%p)->(%s,%p): stub\n", This, debugstr_guid(riid),ppvObj);
717   
718   return S_OK;
719 }
720
721
722
723 static ULONG WINAPI IDirect3DExecuteBufferImpl_AddRef(LPDIRECT3DEXECUTEBUFFER iface)
724 {
725   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
726   TRACE("(%p)->()incrementing from %lu.\n", This, This->ref );
727   
728   return ++(This->ref);
729 }
730
731
732
733 static ULONG WINAPI IDirect3DExecuteBufferImpl_Release(LPDIRECT3DEXECUTEBUFFER iface)
734 {
735   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
736   FIXME("(%p)->() decrementing from %lu.\n", This, This->ref );
737   
738   if (!--(This->ref)) {
739     if ((This->desc.lpData != NULL) && This->need_free)
740       HeapFree(GetProcessHeap(),0,This->desc.lpData);
741
742     if (This->vertex_data != NULL)
743       HeapFree(GetProcessHeap(),0,This->vertex_data);
744
745     HeapFree(GetProcessHeap(),0,This);
746     return 0;
747   }
748   
749   return This->ref;
750 }
751
752 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Initialize(LPDIRECT3DEXECUTEBUFFER iface,
753                                                         LPDIRECT3DDEVICE lpDirect3DDevice,
754                                                         LPD3DEXECUTEBUFFERDESC lpDesc)
755 {
756   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
757   FIXME("(%p)->(%p,%p): stub\n", This, lpDirect3DDevice, lpDesc);
758   
759   return DD_OK;
760 }
761
762 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Lock(LPDIRECT3DEXECUTEBUFFER iface,
763                                                   LPD3DEXECUTEBUFFERDESC lpDesc)
764 {
765   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
766   TRACE("(%p)->(%p)\n", This, lpDesc);
767
768   /* Copies the buffer description */
769   *lpDesc = This->desc;
770   
771   return DD_OK;
772 }
773
774 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Unlock(LPDIRECT3DEXECUTEBUFFER iface)
775 {
776   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
777   TRACE("(%p)->()\n", This);
778
779   return DD_OK;
780 }
781
782 static HRESULT WINAPI IDirect3DExecuteBufferImpl_SetExecuteData(LPDIRECT3DEXECUTEBUFFER iface,
783                                                             LPD3DEXECUTEDATA lpData)
784 {
785   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
786   DWORD nbvert;
787
788   TRACE("(%p)->(%p)\n", This, lpData);
789
790   This->data = *lpData;
791
792   /* Get the number of vertices in the execute buffer */
793   nbvert = This->data.dwVertexCount;
794     
795   /* Prepares the transformed vertex buffer */
796   if (This->vertex_data != NULL)
797     HeapFree(GetProcessHeap(), 0, This->vertex_data);
798   This->vertex_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,nbvert * sizeof(OGL_Vertex));
799
800
801   if (TRACE_ON(ddraw)) {
802     _dump_executedata(lpData);
803   }
804   
805   return DD_OK;
806 }
807
808 static HRESULT WINAPI IDirect3DExecuteBufferImpl_GetExecuteData(LPDIRECT3DEXECUTEBUFFER iface,
809                                                             LPD3DEXECUTEDATA lpData)
810 {
811   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
812   TRACE("(%p)->(%p): stub\n", This, lpData);
813
814   *lpData = This->data;
815   
816   return DD_OK;
817 }
818
819 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Validate(LPDIRECT3DEXECUTEBUFFER iface,
820                                                       LPDWORD lpdwOffset,
821                                                       LPD3DVALIDATECALLBACK lpFunc,
822                                                       LPVOID lpUserArg,
823                                                       DWORD dwReserved)
824 {
825   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
826   TRACE("(%p)->(%p,%p,%p,%lu)\n", This, lpdwOffset, lpFunc, lpUserArg, dwReserved);
827
828   return DD_OK;
829 }
830
831 static HRESULT WINAPI IDirect3DExecuteBufferImpl_Optimize(LPDIRECT3DEXECUTEBUFFER iface,
832                                                       DWORD dwReserved)
833 {
834   ICOM_THIS(IDirect3DExecuteBufferImpl,iface);
835   TRACE("(%p)->(%lu)\n", This, dwReserved);
836
837   return DD_OK;
838 }
839
840
841 /*******************************************************************************
842  *                              IDirect3DLight VTable
843  */
844 static ICOM_VTABLE(IDirect3DExecuteBuffer) executebuffer_vtable = 
845 {
846   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
847   /*** IUnknown methods ***/
848   IDirect3DExecuteBufferImpl_QueryInterface,
849   IDirect3DExecuteBufferImpl_AddRef,
850   IDirect3DExecuteBufferImpl_Release,
851   /*** IDirect3DExecuteBuffer methods ***/
852   IDirect3DExecuteBufferImpl_Initialize,
853   IDirect3DExecuteBufferImpl_Lock,
854   IDirect3DExecuteBufferImpl_Unlock,
855   IDirect3DExecuteBufferImpl_SetExecuteData,
856   IDirect3DExecuteBufferImpl_GetExecuteData,
857   IDirect3DExecuteBufferImpl_Validate,
858   IDirect3DExecuteBufferImpl_Optimize
859 };