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