1 /* Direct3D ExecuteBuffer
4 This files contains the implementation of Direct3DExecuteBuffer. */
11 #include "interfaces.h"
17 #include "d3d_private.h"
21 /* Structure to store the 'semi transformed' vertices */
49 static IDirect3DExecuteBuffer_VTable executebuffer_vtable
;
51 /*******************************************************************************
52 * ExecuteBuffer static functions
54 void _dump_d3dstatus(LPD3DSTATUS lpStatus
) {
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
));
66 #define DO_VERTEX(index) \
68 glTexCoord2f(vx[index].u, \
70 glNormal3f(vx[index].nx, \
73 glVertex4f(vx[index].x, \
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); \
84 #define DO_LVERTEX(index) \
86 DWORD col = l_vx[index].c; \
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, \
93 glVertex4f(l_vx[index].x, \
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); \
104 #define DO_TLVERTEX(index) \
106 D3DTLVERTEX *vx = &(tl_vx[index]); \
107 DWORD col = vx->c.color; \
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, \
118 glVertex4f(vx->x.sx / vx->r.rhw, \
119 vx->y.sy / vx->r.rhw, \
120 vx->z.sz / 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); \
128 #define TRIANGLE_LOOP(macro) \
130 glBegin(GL_TRIANGLES); { \
131 for (i = 0; i < count; i++) { \
132 LPD3DTRIANGLE ci = (LPD3DTRIANGLE) instr; \
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)) { \
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 "); \
146 /* Strips / Fans */ \
147 if (ci->wFlags == D3DTRIFLAG_EVEN) \
149 if (ci->wFlags == D3DTRIFLAG_ODD) \
151 if (ci->wFlags == D3DTRIFLAG_START) \
153 if ((ci->wFlags > 0) && (ci->wFlags < 30)) \
154 DUMP("STARTFLAT(%d) ", ci->wFlags); \
158 /* Draw the triangle */ \
169 static void execute(LPDIRECT3DEXECUTEBUFFER lpBuff
,
170 LPDIRECT3DDEVICE dev
,
171 LPDIRECT3DVIEWPORT vp
) {
172 /* DWORD bs = lpBuff->desc.dwBufferSize; */
173 DWORD vs
= lpBuff
->data
.dwVertexOffset
;
174 /* DWORD vc = lpBuff->data.dwVertexCount; */
175 DWORD is
= lpBuff
->data
.dwInstructionOffset
;
176 /* DWORD il = lpBuff->data.dwInstructionLength; */
178 void *instr
= lpBuff
->desc
.lpData
+ is
;
179 OpenGL_IDirect3DDevice
*odev
= (OpenGL_IDirect3DDevice
*) dev
;
181 TRACE(ddraw
, "ExecuteData : \n");
183 _dump_executedata(&(lpBuff
->data
));
186 LPD3DINSTRUCTION current
= (LPD3DINSTRUCTION
) instr
;
190 count
= current
->wCount
;
191 size
= current
->bSize
;
192 instr
+= sizeof(D3DINSTRUCTION
);
194 switch (current
->bOpcode
) {
196 TRACE(ddraw
, "POINT-s (%d)\n", count
);
198 instr
+= count
* size
;
202 TRACE(ddraw
, "LINE-s (%d)\n", count
);
204 instr
+= count
* size
;
207 case D3DOP_TRIANGLE
: {
209 float z_inv_matrix
[16] = {
216 OGL_Vertex
*vx
= (OGL_Vertex
*) lpBuff
->vertex_data
;
217 OGL_LVertex
*l_vx
= (OGL_LVertex
*) lpBuff
->vertex_data
;
218 D3DTLVERTEX
*tl_vx
= (D3DTLVERTEX
*) lpBuff
->vertex_data
;
220 TRACE(ddraw
, "TRIANGLE (%d)\n", count
);
222 switch (lpBuff
->vertex_type
) {
224 /* This time, there is lighting */
225 glEnable(GL_LIGHTING
);
227 /* Use given matrixes */
228 glMatrixMode(GL_MODELVIEW
);
229 glLoadIdentity(); /* The model transformation was done during the
230 transformation phase */
231 glMatrixMode(GL_PROJECTION
);
232 TRACE(ddraw
, " Projection Matrix : (%p)\n", odev
->proj_mat
);
233 dump_mat(odev
->proj_mat
);
234 TRACE(ddraw
, " View Matrix : (%p)\n", odev
->view_mat
);
235 dump_mat(odev
->view_mat
);
237 glLoadMatrixf((float *) z_inv_matrix
);
238 glMultMatrixf((float *) odev
->proj_mat
);
239 glMultMatrixf((float *) odev
->view_mat
);
244 glDisable(GL_LIGHTING
);
246 /* Use given matrixes */
247 glMatrixMode(GL_MODELVIEW
);
248 glLoadIdentity(); /* The model transformation was done during the
249 transformation phase */
250 glMatrixMode(GL_PROJECTION
);
252 TRACE(ddraw
, " Projection Matrix : (%p)\n", odev
->proj_mat
);
253 dump_mat(odev
->proj_mat
);
254 TRACE(ddraw
, " View Matrix : (%p)\n", odev
->view_mat
);
255 dump_mat(odev
->view_mat
);
257 glLoadMatrixf((float *) z_inv_matrix
);
258 glMultMatrixf((float *) odev
->proj_mat
);
259 glMultMatrixf((float *) odev
->view_mat
);
262 case D3DVT_TLVERTEX
: {
263 GLdouble height
, width
, minZ
, maxZ
;
265 /* First, disable lighting */
266 glDisable(GL_LIGHTING
);
268 /* Then do not put any transformation matrixes */
269 glMatrixMode(GL_MODELVIEW
);
271 glMatrixMode(GL_PROJECTION
);
275 ERR(ddraw
, "No current viewport !\n");
276 /* Using standard values */
282 height
= (GLdouble
) vp
->viewport
.vp1
.dwHeight
;
283 width
= (GLdouble
) vp
->viewport
.vp1
.dwWidth
;
284 minZ
= (GLdouble
) vp
->viewport
.vp1
.dvMinZ
;
285 maxZ
= (GLdouble
) vp
->viewport
.vp1
.dvMaxZ
;
288 /* I do not know why, but many Dx 3.0 games have minZ = maxZ = 0.0 */
294 glOrtho(0.0, width
, height
, 0.0, -minZ
, -maxZ
);
298 ERR(ddraw
, "Unhandled vertex type !\n");
302 switch (lpBuff
->vertex_type
) {
304 TRIANGLE_LOOP(DO_VERTEX
);
308 TRIANGLE_LOOP(DO_LVERTEX
);
312 TRIANGLE_LOOP(DO_TLVERTEX
);
316 ERR(ddraw
, "Unhandled vertex type !\n");
321 case D3DOP_MATRIXLOAD
: {
322 TRACE(ddraw
, "MATRIXLOAD-s (%d)\n", count
);
324 instr
+= count
* size
;
327 case D3DOP_MATRIXMULTIPLY
: {
329 TRACE(ddraw
, "MATRIXMULTIPLY (%d)\n", count
);
331 for (i
= 0; i
< count
; i
++) {
332 LPD3DMATRIXMULTIPLY ci
= (LPD3DMATRIXMULTIPLY
) instr
;
333 LPD3DMATRIX a
= (LPD3DMATRIX
) ci
->hDestMatrix
;
334 LPD3DMATRIX b
= (LPD3DMATRIX
) ci
->hSrcMatrix1
;
335 LPD3DMATRIX c
= (LPD3DMATRIX
) ci
->hSrcMatrix2
;
337 TRACE(ddraw
, " Dest : %08lx Src1 : %08lx Src2 : %08lx\n",
338 ci
->hDestMatrix
, ci
->hSrcMatrix1
, ci
->hSrcMatrix2
);
340 /* Do the multiplication..
341 As I am VERY lazy, I let OpenGL do the multiplication for me */
342 glMatrixMode(GL_PROJECTION
);
343 /* Save the current matrix */
345 /* Load Matrix one and do the multiplication */
346 glLoadMatrixf((float *) c
);
347 glMultMatrixf((float *) b
);
348 glGetFloatv(GL_PROJECTION_MATRIX
, (float *) a
);
349 /* Restore the current matrix */
356 case D3DOP_STATETRANSFORM
: {
358 TRACE(ddraw
, "STATETRANSFORM (%d)\n", count
);
360 for (i
= 0; i
< count
; i
++) {
361 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
363 /* Handle the state transform */
364 switch (ci
->t
.dtstTransformStateType
) {
365 case D3DTRANSFORMSTATE_WORLD
: {
366 TRACE(ddraw
, " WORLD (%p)\n", (D3DMATRIX
*) ci
->v
.dwArg
[0]);
367 odev
->world_mat
= (D3DMATRIX
*) ci
->v
.dwArg
[0];
370 case D3DTRANSFORMSTATE_VIEW
: {
371 TRACE(ddraw
, " VIEW (%p)\n", (D3DMATRIX
*) ci
->v
.dwArg
[0]);
372 odev
->view_mat
= (D3DMATRIX
*) ci
->v
.dwArg
[0];
375 case D3DTRANSFORMSTATE_PROJECTION
: {
376 TRACE(ddraw
, " PROJECTION (%p)\n", (D3DMATRIX
*) ci
->v
.dwArg
[0]);
377 odev
->proj_mat
= (D3DMATRIX
*) ci
->v
.dwArg
[0];
381 ERR(ddraw
, " Unhandled state transformation !! (%d)\n", (int) ci
->t
.dtstTransformStateType
);
390 case D3DOP_STATELIGHT
: {
392 TRACE(ddraw
, "STATELIGHT (%d)\n", count
);
394 for (i
= 0; i
< count
; i
++) {
395 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
397 /* Handle the state transform */
398 switch (ci
->t
.dlstLightStateType
) {
399 case D3DLIGHTSTATE_MATERIAL
: {
400 LPDIRECT3DMATERIAL mat
= (LPDIRECT3DMATERIAL
) ci
->v
.dwArg
[0];
401 TRACE(ddraw
, " MATERIAL\n");
406 TRACE(ddraw
, " bad Material Handle\n");
410 case D3DLIGHTSTATE_AMBIENT
: {
412 DWORD dwLightState
= ci
->v
.dwArg
[0];
413 TRACE(ddraw
, " AMBIENT\n");
415 light
[0] = ((dwLightState
>> 16) & 0xFF) / 255.0;
416 light
[1] = ((dwLightState
>> 8) & 0xFF) / 255.0;
417 light
[2] = ((dwLightState
>> 0) & 0xFF) / 255.0;
419 glLightModelfv(GL_LIGHT_MODEL_AMBIENT
, (float *) light
);
421 TRACE(ddraw
, " R:%02lx G:%02lx B:%02lx A:%02lx\n",
422 ((dwLightState
>> 16) & 0xFF),
423 ((dwLightState
>> 8) & 0xFF),
424 ((dwLightState
>> 0) & 0xFF),
425 ((dwLightState
>> 24) & 0xFF));
428 case D3DLIGHTSTATE_COLORMODEL
: {
429 TRACE(ddraw
, " COLORMODEL\n");
432 case D3DLIGHTSTATE_FOGMODE
: {
433 TRACE(ddraw
, " FOGMODE\n");
436 case D3DLIGHTSTATE_FOGSTART
: {
437 TRACE(ddraw
, " FOGSTART\n");
440 case D3DLIGHTSTATE_FOGEND
: {
441 TRACE(ddraw
, " FOGEND\n");
444 case D3DLIGHTSTATE_FOGDENSITY
: {
445 TRACE(ddraw
, " FOGDENSITY\n");
449 ERR(ddraw
, " Unhandled light state !! (%d)\n", (int) ci
->t
.dlstLightStateType
);
456 case D3DOP_STATERENDER
: {
458 TRACE(ddraw
, "STATERENDER (%d)\n", count
);
460 for (i
= 0; i
< count
; i
++) {
461 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
463 /* Handle the state transform */
464 set_render_state(ci
->t
.drstRenderStateType
, ci
->v
.dwArg
[0], &(odev
->rs
));
470 case D3DOP_PROCESSVERTICES
: {
472 TRACE(ddraw
, "PROCESSVERTICES (%d)\n", count
);
474 for (i
= 0; i
< count
; i
++) {
475 LPD3DPROCESSVERTICES ci
= (LPD3DPROCESSVERTICES
) instr
;
477 TRACE(ddraw
, " Start : %d Dest : %d Count : %ld\n",
478 ci
->wStart
, ci
->wDest
, ci
->dwCount
);
479 TRACE(ddraw
, " Flags : ");
480 if (TRACE_ON(ddraw
)) {
481 if (ci
->dwFlags
& D3DPROCESSVERTICES_COPY
)
483 if (ci
->dwFlags
& D3DPROCESSVERTICES_NOCOLOR
)
485 if (ci
->dwFlags
== D3DPROCESSVERTICES_OPMASK
)
487 if (ci
->dwFlags
& D3DPROCESSVERTICES_TRANSFORM
)
489 if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORMLIGHT
)
490 DUMP("TRANSFORMLIGHT ");
491 if (ci
->dwFlags
& D3DPROCESSVERTICES_UPDATEEXTENTS
)
492 DUMP("UPDATEEXTENTS ");
496 /* This is where doing Direct3D on top on OpenGL is quite difficult.
497 This method transforms a set of vertices using the CURRENT state
498 (lighting, projection, ...) but does not rasterize them.
499 They will oinly be put on screen later (with the POINT / LINE and
500 TRIANGLE op-codes). The problem is that you can have a triangle
501 with each point having been transformed using another state...
503 In this implementation, I will emulate only ONE thing : each
504 vertex can have its own "WORLD" transformation (this is used in the
505 TWIST.EXE demo of the 5.2 SDK). I suppose that all vertices of the
506 execute buffer use the same state.
508 If I find applications that change other states, I will try to do a
509 more 'fine-tuned' state emulation (but I may become quite tricky if
510 it changes a light position in the middle of a triangle).
512 In this case, a 'direct' approach (i.e. without using OpenGL, but
513 writing our own 3D rasterizer) would be easier. */
515 /* The current method (with the hypothesis that only the WORLD matrix
516 will change between two points) is like this :
517 - I transform 'manually' all the vertices with the current WORLD
518 matrix and store them in the vertex buffer
519 - during the rasterization phase, the WORLD matrix will be set to
520 the Identity matrix */
522 /* Enough for the moment */
523 if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORMLIGHT
) {
525 D3DVERTEX
*src
= ((LPD3DVERTEX
) (lpBuff
->desc
.lpData
+ vs
)) + ci
->wStart
;
526 OGL_Vertex
*dst
= ((OGL_Vertex
*) (lpBuff
->vertex_data
)) + ci
->wDest
;
527 D3DMATRIX
*mat
= odev
->world_mat
;
529 TRACE(ddraw
, " World Matrix : (%p)\n", mat
);
532 lpBuff
->vertex_type
= D3DVT_VERTEX
;
534 for (nb
= 0; nb
< ci
->dwCount
; nb
++) {
535 /* For the moment, no normal transformation... */
536 dst
->nx
= src
->nx
.nx
;
537 dst
->ny
= src
->ny
.ny
;
538 dst
->nz
= src
->nz
.nz
;
543 /* Now, the matrix multiplication */
544 dst
->x
= (src
->x
.x
* mat
->_11
) + (src
->y
.y
* mat
->_21
) + (src
->z
.z
* mat
->_31
) + (1.0 * mat
->_41
);
545 dst
->y
= (src
->x
.x
* mat
->_12
) + (src
->y
.y
* mat
->_22
) + (src
->z
.z
* mat
->_32
) + (1.0 * mat
->_42
);
546 dst
->z
= (src
->x
.x
* mat
->_13
) + (src
->y
.y
* mat
->_23
) + (src
->z
.z
* mat
->_33
) + (1.0 * mat
->_43
);
547 dst
->w
= (src
->x
.x
* mat
->_14
) + (src
->y
.y
* mat
->_24
) + (src
->z
.z
* mat
->_34
) + (1.0 * mat
->_44
);
552 } else if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORM
) {
554 D3DLVERTEX
*src
= ((LPD3DLVERTEX
) (lpBuff
->desc
.lpData
+ vs
)) + ci
->wStart
;
555 OGL_LVertex
*dst
= ((OGL_LVertex
*) (lpBuff
->vertex_data
)) + ci
->wDest
;
556 D3DMATRIX
*mat
= odev
->world_mat
;
558 TRACE(ddraw
, " World Matrix : (%p)\n", mat
);
561 lpBuff
->vertex_type
= D3DVT_LVERTEX
;
563 for (nb
= 0; nb
< ci
->dwCount
; nb
++) {
564 dst
->c
= src
->c
.color
;
565 dst
->sc
= src
->s
.specular
;
569 /* Now, the matrix multiplication */
570 dst
->x
= (src
->x
.x
* mat
->_11
) + (src
->y
.y
* mat
->_21
) + (src
->z
.z
* mat
->_31
) + (1.0 * mat
->_41
);
571 dst
->y
= (src
->x
.x
* mat
->_12
) + (src
->y
.y
* mat
->_22
) + (src
->z
.z
* mat
->_32
) + (1.0 * mat
->_42
);
572 dst
->z
= (src
->x
.x
* mat
->_13
) + (src
->y
.y
* mat
->_23
) + (src
->z
.z
* mat
->_33
) + (1.0 * mat
->_43
);
573 dst
->w
= (src
->x
.x
* mat
->_14
) + (src
->y
.y
* mat
->_24
) + (src
->z
.z
* mat
->_34
) + (1.0 * mat
->_44
);
578 } else if (ci
->dwFlags
== D3DPROCESSVERTICES_COPY
) {
579 D3DTLVERTEX
*src
= ((LPD3DTLVERTEX
) (lpBuff
->desc
.lpData
+ vs
)) + ci
->wStart
;
580 D3DTLVERTEX
*dst
= ((LPD3DTLVERTEX
) (lpBuff
->vertex_data
)) + ci
->wDest
;
582 lpBuff
->vertex_type
= D3DVT_TLVERTEX
;
584 memcpy(dst
, src
, ci
->dwCount
* sizeof(D3DTLVERTEX
));
586 ERR(ddraw
, "Unhandled vertex processing !\n");
593 case D3DOP_TEXTURELOAD
: {
594 TRACE(ddraw
, "TEXTURELOAD-s (%d)\n", count
);
596 instr
+= count
* size
;
600 TRACE(ddraw
, "EXIT (%d)\n", count
);
601 /* We did this instruction */
607 case D3DOP_BRANCHFORWARD
: {
609 TRACE(ddraw
, "BRANCHFORWARD (%d)\n", count
);
611 for (i
= 0; i
< count
; i
++) {
612 LPD3DBRANCH ci
= (LPD3DBRANCH
) instr
;
614 if ((lpBuff
->data
.dsStatus
.dwStatus
& ci
->dwMask
) == ci
->dwValue
) {
616 TRACE(ddraw
," Should branch to %ld\n", ci
->dwOffset
);
620 TRACE(ddraw
," Should branch to %ld\n", ci
->dwOffset
);
629 TRACE(ddraw
, "SPAN-s (%d)\n", count
);
631 instr
+= count
* size
;
634 case D3DOP_SETSTATUS
: {
636 TRACE(ddraw
, "SETSTATUS (%d)\n", count
);
638 for (i
= 0; i
< count
; i
++) {
639 LPD3DSTATUS ci
= (LPD3DSTATUS
) instr
;
641 lpBuff
->data
.dsStatus
= *ci
;
648 ERR(ddraw
, "Unhandled OpCode !!!\n");
649 /* Try to save ... */
650 instr
+= count
* size
;
658 /*******************************************************************************
659 * ExecuteBuffer Creation functions
661 LPDIRECT3DEXECUTEBUFFER
d3dexecutebuffer_create(LPDIRECT3DDEVICE d3ddev
, LPD3DEXECUTEBUFFERDESC lpDesc
)
663 LPDIRECT3DEXECUTEBUFFER eb
;
665 eb
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(IDirect3DExecuteBuffer
));
667 eb
->lpvtbl
= &executebuffer_vtable
;
670 /* Initializes memory */
673 /* No buffer given */
674 if (!(eb
->desc
.dwFlags
& D3DDEB_LPDATA
))
675 eb
->desc
.lpData
= NULL
;
677 /* No buffer size given */
678 if (!(lpDesc
->dwFlags
& D3DDEB_BUFSIZE
))
679 eb
->desc
.dwBufferSize
= 0;
681 /* Create buffer if asked */
682 if ((eb
->desc
.lpData
== NULL
) && (eb
->desc
.dwBufferSize
> 0)) {
683 eb
->need_free
= TRUE
;
684 eb
->desc
.lpData
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,eb
->desc
.dwBufferSize
);
686 eb
->need_free
= FALSE
;
689 /* No vertices for the moment */
690 eb
->vertex_data
= NULL
;
692 eb
->desc
.dwFlags
|= D3DDEB_LPDATA
;
694 eb
->execute
= execute
;
699 /*******************************************************************************
700 * IDirect3DLight methods
703 static HRESULT WINAPI
IDirect3DExecuteBuffer_QueryInterface(LPDIRECT3DEXECUTEBUFFER
this,
709 WINE_StringFromCLSID((LPCLSID
)riid
,xrefiid
);
710 FIXME(ddraw
, "(%p)->(%s,%p): stub\n", this, xrefiid
,ppvObj
);
717 static ULONG WINAPI
IDirect3DExecuteBuffer_AddRef(LPDIRECT3DEXECUTEBUFFER
this)
719 TRACE(ddraw
, "(%p)->()incrementing from %lu.\n", this, this->ref
);
721 return ++(this->ref
);
726 static ULONG WINAPI
IDirect3DExecuteBuffer_Release(LPDIRECT3DEXECUTEBUFFER
this)
728 FIXME( ddraw
, "(%p)->() decrementing from %lu.\n", this, this->ref
);
730 if (!--(this->ref
)) {
731 if ((this->desc
.lpData
!= NULL
) && this->need_free
)
732 HeapFree(GetProcessHeap(),0,this->desc
.lpData
);
734 if (this->vertex_data
!= NULL
)
735 HeapFree(GetProcessHeap(),0,this->vertex_data
);
737 HeapFree(GetProcessHeap(),0,this);
744 static HRESULT WINAPI
IDirect3DExecuteBuffer_Initialize(LPDIRECT3DEXECUTEBUFFER
this,
745 LPDIRECT3DDEVICE lpDirect3DDevice
,
746 LPD3DEXECUTEBUFFERDESC lpDesc
)
748 FIXME(ddraw
, "(%p)->(%p,%p): stub\n", this, lpDirect3DDevice
, lpDesc
);
753 static HRESULT WINAPI
IDirect3DExecuteBuffer_Lock(LPDIRECT3DEXECUTEBUFFER
this,
754 LPD3DEXECUTEBUFFERDESC lpDesc
)
756 TRACE(ddraw
, "(%p)->(%p)\n", this, lpDesc
);
758 /* Copies the buffer description */
759 *lpDesc
= this->desc
;
764 static HRESULT WINAPI
IDirect3DExecuteBuffer_Unlock(LPDIRECT3DEXECUTEBUFFER
this)
766 TRACE(ddraw
, "(%p)->()\n", this);
771 static HRESULT WINAPI
IDirect3DExecuteBuffer_SetExecuteData(LPDIRECT3DEXECUTEBUFFER
this,
772 LPD3DEXECUTEDATA lpData
)
776 TRACE(ddraw
, "(%p)->(%p)\n", this, lpData
);
778 this->data
= *lpData
;
780 /* Get the number of vertices in the execute buffer */
781 nbvert
= this->data
.dwVertexCount
;
783 /* Prepares the transformed vertex buffer */
784 if (this->vertex_data
!= NULL
)
785 HeapFree(GetProcessHeap(), 0, this->vertex_data
);
786 this->vertex_data
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,nbvert
* sizeof(OGL_Vertex
));
789 if (TRACE_ON(ddraw
)) {
790 _dump_executedata(lpData
);
796 static HRESULT WINAPI
IDirect3DExecuteBuffer_GetExecuteData(LPDIRECT3DEXECUTEBUFFER
this,
797 LPD3DEXECUTEDATA lpData
)
799 TRACE(ddraw
, "(%p)->(%p): stub\n", this, lpData
);
801 *lpData
= this->data
;
806 static HRESULT WINAPI
IDirect3DExecuteBuffer_Validate(LPDIRECT3DEXECUTEBUFFER
this,
808 LPD3DVALIDATECALLBACK lpFunc
,
812 TRACE(ddraw
, "(%p)->(%p,%p,%p,%lu)\n", this, lpdwOffset
, lpFunc
, lpUserArg
, dwReserved
);
817 static HRESULT WINAPI
IDirect3DExecuteBuffer_Optimize(LPDIRECT3DEXECUTEBUFFER
this,
820 TRACE(ddraw
, "(%p)->(%lu)\n", this, dwReserved
);
826 /*******************************************************************************
827 * IDirect3DLight VTable
829 static IDirect3DExecuteBuffer_VTable executebuffer_vtable
= {
830 /*** IUnknown methods ***/
831 IDirect3DExecuteBuffer_QueryInterface
,
832 IDirect3DExecuteBuffer_AddRef
,
833 IDirect3DExecuteBuffer_Release
,
834 /*** IDirect3DExecuteBuffer methods ***/
835 IDirect3DExecuteBuffer_Initialize
,
836 IDirect3DExecuteBuffer_Lock
,
837 IDirect3DExecuteBuffer_Unlock
,
838 IDirect3DExecuteBuffer_SetExecuteData
,
839 IDirect3DExecuteBuffer_GetExecuteData
,
840 IDirect3DExecuteBuffer_Validate
,
841 IDirect3DExecuteBuffer_Optimize
844 #endif /* HAVE_MESAGL */