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 */