1 /* Direct3D ExecuteBuffer
4 This files contains the implementation of Direct3DExecuteBuffer. */
11 #include "wine/obj_base.h"
18 #include "d3d_private.h"
22 /* Structure to store the 'semi transformed' vertices */
50 static IDirect3DExecuteBuffer_VTable executebuffer_vtable;
52 /*******************************************************************************
53 * ExecuteBuffer static functions
55 void _dump_d3dstatus(LPD3DSTATUS lpStatus) {
59 void _dump_executedata(LPD3DEXECUTEDATA lpData) {
60 DUMP("dwSize : %ld\n", lpData->dwSize);
61 DUMP("Vertex Offset : %ld Count : %ld\n", lpData->dwVertexOffset, lpData->dwVertexCount);
62 DUMP("Instruction Offset : %ld Length : %ld\n", lpData->dwInstructionOffset, lpData->dwInstructionLength);
63 DUMP("HVertex Offset : %ld\n", lpData->dwHVertexOffset);
64 _dump_d3dstatus(&(lpData->dsStatus));
67 #define DO_VERTEX(index) \
69 glTexCoord2f(vx[index].u, \
71 glNormal3f(vx[index].nx, \
74 glVertex4f(vx[index].x, \
79 TRACE(ddraw, " V: %f %f %f %f (%f %f %f) (%f %f)\n", \
80 vx[index].x, vx[index].y, vx[index].z, vx[index].w, \
81 vx[index].nx, vx[index].ny, vx[index].nz, \
82 vx[index].u, vx[index].v); \
85 #define DO_LVERTEX(index) \
87 DWORD col = l_vx[index].c; \
89 glColor3f(((col >> 16) & 0xFF) / 255.0, \
90 ((col >> 8) & 0xFF) / 255.0, \
91 ((col >> 0) & 0xFF) / 255.0); \
92 glTexCoord2f(l_vx[index].u, \
94 glVertex4f(l_vx[index].x, \
99 TRACE(ddraw, " LV: %f %f %f %f (%02lx %02lx %02lx) (%f %f)\n", \
100 l_vx[index].x, l_vx[index].y, l_vx[index].z, l_vx[index].w, \
101 ((col >> 16) & 0xFF), ((col >> 8) & 0xFF), ((col >> 0) & 0xFF), \
102 l_vx[index].u, l_vx[index].v); \
105 #define DO_TLVERTEX(index) \
107 D3DTLVERTEX *vx = &(tl_vx[index]); \
108 DWORD col = vx->c.color; \
110 glColor3f(((col >> 16) & 0xFF) / 255.0, \
111 ((col >> 8) & 0xFF) / 255.0, \
112 ((col >> 0) & 0xFF) / 255.0); \
113 glTexCoord2f(vx->u.tu, vx->v.tv); \
114 if (vx->r.rhw < 0.01) \
115 glVertex3f(vx->x.sx, \
119 glVertex4f(vx->x.sx / vx->r.rhw, \
120 vx->y.sy / vx->r.rhw, \
121 vx->z.sz / vx->r.rhw, \
123 TRACE(ddraw, " TLV: %f %f %f (%02lx %02lx %02lx) (%f %f) (%f)\n", \
124 vx->x.sx, vx->y.sy, vx->z.sz, \
125 ((col >> 16) & 0xFF), ((col >> 8) & 0xFF), ((col >> 0) & 0xFF), \
126 vx->u.tu, vx->v.tv, vx->r.rhw); \
129 #define TRIANGLE_LOOP(macro) \
131 glBegin(GL_TRIANGLES); { \
132 for (i = 0; i < count; i++) { \
133 LPD3DTRIANGLE ci = (LPD3DTRIANGLE) instr; \
135 TRACE(ddraw, " v1: %d v2: %d v3: %d\n", \
136 ci->v1.v1, ci->v2.v2, ci->v3.v3); \
137 TRACE(ddraw, " Flags : "); \
138 if (TRACE_ON(ddraw)) { \
140 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1) \
141 DUMP("EDGEENABLE1 "); \
142 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE2) \
143 DUMP("EDGEENABLE2 "); \
144 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1) \
145 DUMP("EDGEENABLE3 "); \
147 /* Strips / Fans */ \
148 if (ci->wFlags == D3DTRIFLAG_EVEN) \
150 if (ci->wFlags == D3DTRIFLAG_ODD) \
152 if (ci->wFlags == D3DTRIFLAG_START) \
154 if ((ci->wFlags > 0) && (ci->wFlags < 30)) \
155 DUMP("STARTFLAT(%d) ", ci->wFlags); \
159 /* Draw the triangle */ \
170 static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff,
171 LPDIRECT3DDEVICE dev,
172 LPDIRECT3DVIEWPORT vp) {
173 /* DWORD bs = lpBuff->desc.dwBufferSize; */
174 DWORD vs = lpBuff->data.dwVertexOffset;
175 /* DWORD vc = lpBuff->data.dwVertexCount; */
176 DWORD is = lpBuff->data.dwInstructionOffset;
177 /* DWORD il = lpBuff->data.dwInstructionLength; */
179 void *instr = lpBuff->desc.lpData + is;
180 OpenGL_IDirect3DDevice *odev = (OpenGL_IDirect3DDevice *) dev;
182 TRACE(ddraw, "ExecuteData : \n");
184 _dump_executedata(&(lpBuff->data));
187 LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr;
191 count = current->wCount;
192 size = current->bSize;
193 instr += sizeof(D3DINSTRUCTION);
195 switch (current->bOpcode) {
197 TRACE(ddraw, "POINT-s (%d)\n", count);
199 instr += count * size;
203 TRACE(ddraw, "LINE-s (%d)\n", count);
205 instr += count * size;
208 case D3DOP_TRIANGLE: {
210 float z_inv_matrix[16] = {
217 OGL_Vertex *vx = (OGL_Vertex *) lpBuff->vertex_data;
218 OGL_LVertex *l_vx = (OGL_LVertex *) lpBuff->vertex_data;
219 D3DTLVERTEX *tl_vx = (D3DTLVERTEX *) lpBuff->vertex_data;
221 TRACE(ddraw, "TRIANGLE (%d)\n", count);
223 switch (lpBuff->vertex_type) {
225 /* This time, there is lighting */
226 glEnable(GL_LIGHTING);
228 /* Use given matrixes */
229 glMatrixMode(GL_MODELVIEW);
230 glLoadIdentity(); /* The model transformation was done during the
231 transformation phase */
232 glMatrixMode(GL_PROJECTION);
233 TRACE(ddraw, " Projection Matrix : (%p)\n", odev->proj_mat);
234 dump_mat(odev->proj_mat);
235 TRACE(ddraw, " View Matrix : (%p)\n", odev->view_mat);
236 dump_mat(odev->view_mat);
238 glLoadMatrixf((float *) z_inv_matrix);
239 glMultMatrixf((float *) odev->proj_mat);
240 glMultMatrixf((float *) odev->view_mat);
245 glDisable(GL_LIGHTING);
247 /* Use given matrixes */
248 glMatrixMode(GL_MODELVIEW);
249 glLoadIdentity(); /* The model transformation was done during the
250 transformation phase */
251 glMatrixMode(GL_PROJECTION);
253 TRACE(ddraw, " Projection Matrix : (%p)\n", odev->proj_mat);
254 dump_mat(odev->proj_mat);
255 TRACE(ddraw, " View Matrix : (%p)\n", odev->view_mat);
256 dump_mat(odev->view_mat);
258 glLoadMatrixf((float *) z_inv_matrix);
259 glMultMatrixf((float *) odev->proj_mat);
260 glMultMatrixf((float *) odev->view_mat);
263 case D3DVT_TLVERTEX: {
264 GLdouble height, width, minZ, maxZ;
266 /* First, disable lighting */
267 glDisable(GL_LIGHTING);
269 /* Then do not put any transformation matrixes */
270 glMatrixMode(GL_MODELVIEW);
272 glMatrixMode(GL_PROJECTION);
276 ERR(ddraw, "No current viewport !\n");
277 /* Using standard values */
283 height = (GLdouble) vp->viewport.vp1.dwHeight;
284 width = (GLdouble) vp->viewport.vp1.dwWidth;
285 minZ = (GLdouble) vp->viewport.vp1.dvMinZ;
286 maxZ = (GLdouble) vp->viewport.vp1.dvMaxZ;
289 /* I do not know why, but many Dx 3.0 games have minZ = maxZ = 0.0 */
295 glOrtho(0.0, width, height, 0.0, -minZ, -maxZ);
299 ERR(ddraw, "Unhandled vertex type !\n");
303 switch (lpBuff->vertex_type) {
305 TRIANGLE_LOOP(DO_VERTEX);
309 TRIANGLE_LOOP(DO_LVERTEX);
313 TRIANGLE_LOOP(DO_TLVERTEX);
317 ERR(ddraw, "Unhandled vertex type !\n");
322 case D3DOP_MATRIXLOAD: {
323 TRACE(ddraw, "MATRIXLOAD-s (%d)\n", count);
325 instr += count * size;
328 case D3DOP_MATRIXMULTIPLY: {
330 TRACE(ddraw, "MATRIXMULTIPLY (%d)\n", count);
332 for (i = 0; i < count; i++) {
333 LPD3DMATRIXMULTIPLY ci = (LPD3DMATRIXMULTIPLY) instr;
334 LPD3DMATRIX a = (LPD3DMATRIX) ci->hDestMatrix;
335 LPD3DMATRIX b = (LPD3DMATRIX) ci->hSrcMatrix1;
336 LPD3DMATRIX c = (LPD3DMATRIX) ci->hSrcMatrix2;
338 TRACE(ddraw, " Dest : %08lx Src1 : %08lx Src2 : %08lx\n",
339 ci->hDestMatrix, ci->hSrcMatrix1, ci->hSrcMatrix2);
341 /* Do the multiplication..
342 As I am VERY lazy, I let OpenGL do the multiplication for me */
343 glMatrixMode(GL_PROJECTION);
344 /* Save the current matrix */
346 /* Load Matrix one and do the multiplication */
347 glLoadMatrixf((float *) c);
348 glMultMatrixf((float *) b);
349 glGetFloatv(GL_PROJECTION_MATRIX, (float *) a);
350 /* Restore the current matrix */
357 case D3DOP_STATETRANSFORM: {
359 TRACE(ddraw, "STATETRANSFORM (%d)\n", count);
361 for (i = 0; i < count; i++) {
362 LPD3DSTATE ci = (LPD3DSTATE) instr;
364 /* Handle the state transform */
365 switch (ci->t.dtstTransformStateType) {
366 case D3DTRANSFORMSTATE_WORLD: {
367 TRACE(ddraw, " WORLD (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
368 odev->world_mat = (D3DMATRIX*) ci->v.dwArg[0];
371 case D3DTRANSFORMSTATE_VIEW: {
372 TRACE(ddraw, " VIEW (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
373 odev->view_mat = (D3DMATRIX*) ci->v.dwArg[0];
376 case D3DTRANSFORMSTATE_PROJECTION: {
377 TRACE(ddraw, " PROJECTION (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
378 odev->proj_mat = (D3DMATRIX*) ci->v.dwArg[0];
382 ERR(ddraw, " Unhandled state transformation !! (%d)\n", (int) ci->t.dtstTransformStateType);
391 case D3DOP_STATELIGHT: {
393 TRACE(ddraw, "STATELIGHT (%d)\n", count);
395 for (i = 0; i < count; i++) {
396 LPD3DSTATE ci = (LPD3DSTATE) instr;
398 /* Handle the state transform */
399 switch (ci->t.dlstLightStateType) {
400 case D3DLIGHTSTATE_MATERIAL: {
401 LPDIRECT3DMATERIAL mat = (LPDIRECT3DMATERIAL) ci->v.dwArg[0];
402 TRACE(ddraw, " MATERIAL\n");
407 TRACE(ddraw, " bad Material Handle\n");
411 case D3DLIGHTSTATE_AMBIENT: {
413 DWORD dwLightState = ci->v.dwArg[0];
414 TRACE(ddraw, " AMBIENT\n");
416 light[0] = ((dwLightState >> 16) & 0xFF) / 255.0;
417 light[1] = ((dwLightState >> 8) & 0xFF) / 255.0;
418 light[2] = ((dwLightState >> 0) & 0xFF) / 255.0;
420 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, (float *) light);
422 TRACE(ddraw, " R:%02lx G:%02lx B:%02lx A:%02lx\n",
423 ((dwLightState >> 16) & 0xFF),
424 ((dwLightState >> 8) & 0xFF),
425 ((dwLightState >> 0) & 0xFF),
426 ((dwLightState >> 24) & 0xFF));
429 case D3DLIGHTSTATE_COLORMODEL: {
430 TRACE(ddraw, " COLORMODEL\n");
433 case D3DLIGHTSTATE_FOGMODE: {
434 TRACE(ddraw, " FOGMODE\n");
437 case D3DLIGHTSTATE_FOGSTART: {
438 TRACE(ddraw, " FOGSTART\n");
441 case D3DLIGHTSTATE_FOGEND: {
442 TRACE(ddraw, " FOGEND\n");
445 case D3DLIGHTSTATE_FOGDENSITY: {
446 TRACE(ddraw, " FOGDENSITY\n");
450 ERR(ddraw, " Unhandled light state !! (%d)\n", (int) ci->t.dlstLightStateType);
457 case D3DOP_STATERENDER: {
459 TRACE(ddraw, "STATERENDER (%d)\n", count);
461 for (i = 0; i < count; i++) {
462 LPD3DSTATE ci = (LPD3DSTATE) instr;
464 /* Handle the state transform */
465 set_render_state(ci->t.drstRenderStateType, ci->v.dwArg[0], &(odev->rs));
471 case D3DOP_PROCESSVERTICES: {
473 TRACE(ddraw, "PROCESSVERTICES (%d)\n", count);
475 for (i = 0; i < count; i++) {
476 LPD3DPROCESSVERTICES ci = (LPD3DPROCESSVERTICES) instr;
478 TRACE(ddraw, " Start : %d Dest : %d Count : %ld\n",
479 ci->wStart, ci->wDest, ci->dwCount);
480 TRACE(ddraw, " Flags : ");
481 if (TRACE_ON(ddraw)) {
482 if (ci->dwFlags & D3DPROCESSVERTICES_COPY)
484 if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
486 if (ci->dwFlags == D3DPROCESSVERTICES_OPMASK)
488 if (ci->dwFlags & D3DPROCESSVERTICES_TRANSFORM)
490 if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT)
491 DUMP("TRANSFORMLIGHT ");
492 if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
493 DUMP("UPDATEEXTENTS ");
497 /* This is where doing Direct3D on top on OpenGL is quite difficult.
498 This method transforms a set of vertices using the CURRENT state
499 (lighting, projection, ...) but does not rasterize them.
500 They will oinly be put on screen later (with the POINT / LINE and
501 TRIANGLE op-codes). The problem is that you can have a triangle
502 with each point having been transformed using another state...
504 In this implementation, I will emulate only ONE thing : each
505 vertex can have its own "WORLD" transformation (this is used in the
506 TWIST.EXE demo of the 5.2 SDK). I suppose that all vertices of the
507 execute buffer use the same state.
509 If I find applications that change other states, I will try to do a
510 more 'fine-tuned' state emulation (but I may become quite tricky if
511 it changes a light position in the middle of a triangle).
513 In this case, a 'direct' approach (i.e. without using OpenGL, but
514 writing our own 3D rasterizer) would be easier. */
516 /* The current method (with the hypothesis that only the WORLD matrix
517 will change between two points) is like this :
518 - I transform 'manually' all the vertices with the current WORLD
519 matrix and store them in the vertex buffer
520 - during the rasterization phase, the WORLD matrix will be set to
521 the Identity matrix */
523 /* Enough for the moment */
524 if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) {
526 D3DVERTEX *src = ((LPD3DVERTEX) (lpBuff->desc.lpData + vs)) + ci->wStart;
527 OGL_Vertex *dst = ((OGL_Vertex *) (lpBuff->vertex_data)) + ci->wDest;
528 D3DMATRIX *mat = odev->world_mat;
530 TRACE(ddraw, " World Matrix : (%p)\n", mat);
533 lpBuff->vertex_type = D3DVT_VERTEX;
535 for (nb = 0; nb < ci->dwCount; nb++) {
536 /* For the moment, no normal transformation... */
537 dst->nx = src->nx.nx;
538 dst->ny = src->ny.ny;
539 dst->nz = src->nz.nz;
544 /* Now, the matrix multiplication */
545 dst->x = (src->x.x * mat->_11) + (src->y.y * mat->_21) + (src->z.z * mat->_31) + (1.0 * mat->_41);
546 dst->y = (src->x.x * mat->_12) + (src->y.y * mat->_22) + (src->z.z * mat->_32) + (1.0 * mat->_42);
547 dst->z = (src->x.x * mat->_13) + (src->y.y * mat->_23) + (src->z.z * mat->_33) + (1.0 * mat->_43);
548 dst->w = (src->x.x * mat->_14) + (src->y.y * mat->_24) + (src->z.z * mat->_34) + (1.0 * mat->_44);
553 } else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) {
555 D3DLVERTEX *src = ((LPD3DLVERTEX) (lpBuff->desc.lpData + vs)) + ci->wStart;
556 OGL_LVertex *dst = ((OGL_LVertex *) (lpBuff->vertex_data)) + ci->wDest;
557 D3DMATRIX *mat = odev->world_mat;
559 TRACE(ddraw, " World Matrix : (%p)\n", mat);
562 lpBuff->vertex_type = D3DVT_LVERTEX;
564 for (nb = 0; nb < ci->dwCount; nb++) {
565 dst->c = src->c.color;
566 dst->sc = src->s.specular;
570 /* Now, the matrix multiplication */
571 dst->x = (src->x.x * mat->_11) + (src->y.y * mat->_21) + (src->z.z * mat->_31) + (1.0 * mat->_41);
572 dst->y = (src->x.x * mat->_12) + (src->y.y * mat->_22) + (src->z.z * mat->_32) + (1.0 * mat->_42);
573 dst->z = (src->x.x * mat->_13) + (src->y.y * mat->_23) + (src->z.z * mat->_33) + (1.0 * mat->_43);
574 dst->w = (src->x.x * mat->_14) + (src->y.y * mat->_24) + (src->z.z * mat->_34) + (1.0 * mat->_44);
579 } else if (ci->dwFlags == D3DPROCESSVERTICES_COPY) {
580 D3DTLVERTEX *src = ((LPD3DTLVERTEX) (lpBuff->desc.lpData + vs)) + ci->wStart;
581 D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (lpBuff->vertex_data)) + ci->wDest;
583 lpBuff->vertex_type = D3DVT_TLVERTEX;
585 memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX));
587 ERR(ddraw, "Unhandled vertex processing !\n");
594 case D3DOP_TEXTURELOAD: {
595 TRACE(ddraw, "TEXTURELOAD-s (%d)\n", count);
597 instr += count * size;
601 TRACE(ddraw, "EXIT (%d)\n", count);
602 /* We did this instruction */
608 case D3DOP_BRANCHFORWARD: {
610 TRACE(ddraw, "BRANCHFORWARD (%d)\n", count);
612 for (i = 0; i < count; i++) {
613 LPD3DBRANCH ci = (LPD3DBRANCH) instr;
615 if ((lpBuff->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue) {
617 TRACE(ddraw," Should branch to %ld\n", ci->dwOffset);
621 TRACE(ddraw," Should branch to %ld\n", ci->dwOffset);
630 TRACE(ddraw, "SPAN-s (%d)\n", count);
632 instr += count * size;
635 case D3DOP_SETSTATUS: {
637 TRACE(ddraw, "SETSTATUS (%d)\n", count);
639 for (i = 0; i < count; i++) {
640 LPD3DSTATUS ci = (LPD3DSTATUS) instr;
642 lpBuff->data.dsStatus = *ci;
649 ERR(ddraw, "Unhandled OpCode !!!\n");
650 /* Try to save ... */
651 instr += count * size;
659 /*******************************************************************************
660 * ExecuteBuffer Creation functions
662 LPDIRECT3DEXECUTEBUFFER d3dexecutebuffer_create(LPDIRECT3DDEVICE d3ddev, LPD3DEXECUTEBUFFERDESC lpDesc)
664 LPDIRECT3DEXECUTEBUFFER eb;
666 eb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirect3DExecuteBuffer));
668 eb->lpvtbl = &executebuffer_vtable;
671 /* Initializes memory */
674 /* No buffer given */
675 if (!(eb->desc.dwFlags & D3DDEB_LPDATA))
676 eb->desc.lpData = NULL;
678 /* No buffer size given */
679 if (!(lpDesc->dwFlags & D3DDEB_BUFSIZE))
680 eb->desc.dwBufferSize = 0;
682 /* Create buffer if asked */
683 if ((eb->desc.lpData == NULL) && (eb->desc.dwBufferSize > 0)) {
684 eb->need_free = TRUE;
685 eb->desc.lpData = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,eb->desc.dwBufferSize);
687 eb->need_free = FALSE;
690 /* No vertices for the moment */
691 eb->vertex_data = NULL;
693 eb->desc.dwFlags |= D3DDEB_LPDATA;
695 eb->execute = execute;
700 /*******************************************************************************
701 * IDirect3DLight methods
704 static HRESULT WINAPI IDirect3DExecuteBuffer_QueryInterface(LPDIRECT3DEXECUTEBUFFER this,
710 WINE_StringFromCLSID((LPCLSID)riid,xrefiid);
711 FIXME(ddraw, "(%p)->(%s,%p): stub\n", this, xrefiid,ppvObj);
718 static ULONG WINAPI IDirect3DExecuteBuffer_AddRef(LPDIRECT3DEXECUTEBUFFER this)
720 TRACE(ddraw, "(%p)->()incrementing from %lu.\n", this, this->ref );
722 return ++(this->ref);
727 static ULONG WINAPI IDirect3DExecuteBuffer_Release(LPDIRECT3DEXECUTEBUFFER this)
729 FIXME( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
731 if (!--(this->ref)) {
732 if ((this->desc.lpData != NULL) && this->need_free)
733 HeapFree(GetProcessHeap(),0,this->desc.lpData);
735 if (this->vertex_data != NULL)
736 HeapFree(GetProcessHeap(),0,this->vertex_data);
738 HeapFree(GetProcessHeap(),0,this);
745 static HRESULT WINAPI IDirect3DExecuteBuffer_Initialize(LPDIRECT3DEXECUTEBUFFER this,
746 LPDIRECT3DDEVICE lpDirect3DDevice,
747 LPD3DEXECUTEBUFFERDESC lpDesc)
749 FIXME(ddraw, "(%p)->(%p,%p): stub\n", this, lpDirect3DDevice, lpDesc);
754 static HRESULT WINAPI IDirect3DExecuteBuffer_Lock(LPDIRECT3DEXECUTEBUFFER this,
755 LPD3DEXECUTEBUFFERDESC lpDesc)
757 TRACE(ddraw, "(%p)->(%p)\n", this, lpDesc);
759 /* Copies the buffer description */
760 *lpDesc = this->desc;
765 static HRESULT WINAPI IDirect3DExecuteBuffer_Unlock(LPDIRECT3DEXECUTEBUFFER this)
767 TRACE(ddraw, "(%p)->()\n", this);
772 static HRESULT WINAPI IDirect3DExecuteBuffer_SetExecuteData(LPDIRECT3DEXECUTEBUFFER this,
773 LPD3DEXECUTEDATA lpData)
777 TRACE(ddraw, "(%p)->(%p)\n", this, lpData);
779 this->data = *lpData;
781 /* Get the number of vertices in the execute buffer */
782 nbvert = this->data.dwVertexCount;
784 /* Prepares the transformed vertex buffer */
785 if (this->vertex_data != NULL)
786 HeapFree(GetProcessHeap(), 0, this->vertex_data);
787 this->vertex_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,nbvert * sizeof(OGL_Vertex));
790 if (TRACE_ON(ddraw)) {
791 _dump_executedata(lpData);
797 static HRESULT WINAPI IDirect3DExecuteBuffer_GetExecuteData(LPDIRECT3DEXECUTEBUFFER this,
798 LPD3DEXECUTEDATA lpData)
800 TRACE(ddraw, "(%p)->(%p): stub\n", this, lpData);
802 *lpData = this->data;
807 static HRESULT WINAPI IDirect3DExecuteBuffer_Validate(LPDIRECT3DEXECUTEBUFFER this,
809 LPD3DVALIDATECALLBACK lpFunc,
813 TRACE(ddraw, "(%p)->(%p,%p,%p,%lu)\n", this, lpdwOffset, lpFunc, lpUserArg, dwReserved);
818 static HRESULT WINAPI IDirect3DExecuteBuffer_Optimize(LPDIRECT3DEXECUTEBUFFER this,
821 TRACE(ddraw, "(%p)->(%lu)\n", this, dwReserved);
827 /*******************************************************************************
828 * IDirect3DLight VTable
830 static IDirect3DExecuteBuffer_VTable executebuffer_vtable = {
831 /*** IUnknown methods ***/
832 IDirect3DExecuteBuffer_QueryInterface,
833 IDirect3DExecuteBuffer_AddRef,
834 IDirect3DExecuteBuffer_Release,
835 /*** IDirect3DExecuteBuffer methods ***/
836 IDirect3DExecuteBuffer_Initialize,
837 IDirect3DExecuteBuffer_Lock,
838 IDirect3DExecuteBuffer_Unlock,
839 IDirect3DExecuteBuffer_SetExecuteData,
840 IDirect3DExecuteBuffer_GetExecuteData,
841 IDirect3DExecuteBuffer_Validate,
842 IDirect3DExecuteBuffer_Optimize
845 #endif /* HAVE_MESAGL */