1 /* Direct3D ExecuteBuffer
4 This files contains the implementation of Direct3DExecuteBuffer. */
11 #include "wine/obj_base.h"
17 #include "d3d_private.h"
21 /* Structure to store the 'semi transformed' vertices */
49 static ICOM_VTABLE(IDirect3DExecuteBuffer
) 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 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; */
180 void *instr
= ilpBuff
->desc
.lpData
+ is
;
181 OpenGL_IDirect3DDevice
*odev
= (OpenGL_IDirect3DDevice
*) dev
;
183 TRACE(ddraw
, "ExecuteData : \n");
185 _dump_executedata(&(ilpBuff
->data
));
188 LPD3DINSTRUCTION current
= (LPD3DINSTRUCTION
) instr
;
192 count
= current
->wCount
;
193 size
= current
->bSize
;
194 instr
+= sizeof(D3DINSTRUCTION
);
196 switch (current
->bOpcode
) {
198 TRACE(ddraw
, "POINT-s (%d)\n", count
);
200 instr
+= count
* size
;
204 TRACE(ddraw
, "LINE-s (%d)\n", count
);
206 instr
+= count
* size
;
209 case D3DOP_TRIANGLE
: {
211 float z_inv_matrix
[16] = {
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
;
222 TRACE(ddraw
, "TRIANGLE (%d)\n", count
);
224 switch (ilpBuff
->vertex_type
) {
226 /* This time, there is lighting */
227 glEnable(GL_LIGHTING
);
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
);
239 glLoadMatrixf((float *) z_inv_matrix
);
240 glMultMatrixf((float *) odev
->proj_mat
);
241 glMultMatrixf((float *) odev
->view_mat
);
246 glDisable(GL_LIGHTING
);
248 /* Use given matrixes */
249 glMatrixMode(GL_MODELVIEW
);
250 glLoadIdentity(); /* The model transformation was done during the
251 transformation phase */
252 glMatrixMode(GL_PROJECTION
);
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
);
259 glLoadMatrixf((float *) z_inv_matrix
);
260 glMultMatrixf((float *) odev
->proj_mat
);
261 glMultMatrixf((float *) odev
->view_mat
);
264 case D3DVT_TLVERTEX
: {
265 GLdouble height
, width
, minZ
, maxZ
;
267 /* First, disable lighting */
268 glDisable(GL_LIGHTING
);
270 /* Then do not put any transformation matrixes */
271 glMatrixMode(GL_MODELVIEW
);
273 glMatrixMode(GL_PROJECTION
);
277 ERR(ddraw
, "No current viewport !\n");
278 /* Using standard values */
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
;
290 /* I do not know why, but many Dx 3.0 games have minZ = maxZ = 0.0 */
296 glOrtho(0.0, width
, height
, 0.0, -minZ
, -maxZ
);
300 ERR(ddraw
, "Unhandled vertex type !\n");
304 switch (ilpBuff
->vertex_type
) {
306 TRIANGLE_LOOP(DO_VERTEX
);
310 TRIANGLE_LOOP(DO_LVERTEX
);
314 TRIANGLE_LOOP(DO_TLVERTEX
);
318 ERR(ddraw
, "Unhandled vertex type !\n");
323 case D3DOP_MATRIXLOAD
: {
324 TRACE(ddraw
, "MATRIXLOAD-s (%d)\n", count
);
326 instr
+= count
* size
;
329 case D3DOP_MATRIXMULTIPLY
: {
331 TRACE(ddraw
, "MATRIXMULTIPLY (%d)\n", count
);
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
;
339 TRACE(ddraw
, " Dest : %08lx Src1 : %08lx Src2 : %08lx\n",
340 ci
->hDestMatrix
, ci
->hSrcMatrix1
, ci
->hSrcMatrix2
);
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 */
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 */
358 case D3DOP_STATETRANSFORM
: {
360 TRACE(ddraw
, "STATETRANSFORM (%d)\n", count
);
362 for (i
= 0; i
< count
; i
++) {
363 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
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];
372 case D3DTRANSFORMSTATE_VIEW
: {
373 TRACE(ddraw
, " VIEW (%p)\n", (D3DMATRIX
*) ci
->v
.dwArg
[0]);
374 odev
->view_mat
= (D3DMATRIX
*) ci
->v
.dwArg
[0];
377 case D3DTRANSFORMSTATE_PROJECTION
: {
378 TRACE(ddraw
, " PROJECTION (%p)\n", (D3DMATRIX
*) ci
->v
.dwArg
[0]);
379 odev
->proj_mat
= (D3DMATRIX
*) ci
->v
.dwArg
[0];
383 ERR(ddraw
, " Unhandled state transformation !! (%d)\n", (int) ci
->t
.dtstTransformStateType
);
392 case D3DOP_STATELIGHT
: {
394 TRACE(ddraw
, "STATELIGHT (%d)\n", count
);
396 for (i
= 0; i
< count
; i
++) {
397 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
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");
408 TRACE(ddraw
, " bad Material Handle\n");
412 case D3DLIGHTSTATE_AMBIENT
: {
414 DWORD dwLightState
= ci
->v
.dwArg
[0];
415 TRACE(ddraw
, " AMBIENT\n");
417 light
[0] = ((dwLightState
>> 16) & 0xFF) / 255.0;
418 light
[1] = ((dwLightState
>> 8) & 0xFF) / 255.0;
419 light
[2] = ((dwLightState
>> 0) & 0xFF) / 255.0;
421 glLightModelfv(GL_LIGHT_MODEL_AMBIENT
, (float *) light
);
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));
430 case D3DLIGHTSTATE_COLORMODEL
: {
431 TRACE(ddraw
, " COLORMODEL\n");
434 case D3DLIGHTSTATE_FOGMODE
: {
435 TRACE(ddraw
, " FOGMODE\n");
438 case D3DLIGHTSTATE_FOGSTART
: {
439 TRACE(ddraw
, " FOGSTART\n");
442 case D3DLIGHTSTATE_FOGEND
: {
443 TRACE(ddraw
, " FOGEND\n");
446 case D3DLIGHTSTATE_FOGDENSITY
: {
447 TRACE(ddraw
, " FOGDENSITY\n");
451 ERR(ddraw
, " Unhandled light state !! (%d)\n", (int) ci
->t
.dlstLightStateType
);
458 case D3DOP_STATERENDER
: {
460 TRACE(ddraw
, "STATERENDER (%d)\n", count
);
462 for (i
= 0; i
< count
; i
++) {
463 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
465 /* Handle the state transform */
466 set_render_state(ci
->t
.drstRenderStateType
, ci
->v
.dwArg
[0], &(odev
->rs
));
472 case D3DOP_PROCESSVERTICES
: {
474 TRACE(ddraw
, "PROCESSVERTICES (%d)\n", count
);
476 for (i
= 0; i
< count
; i
++) {
477 LPD3DPROCESSVERTICES ci
= (LPD3DPROCESSVERTICES
) instr
;
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
)
485 if (ci
->dwFlags
& D3DPROCESSVERTICES_NOCOLOR
)
487 if (ci
->dwFlags
== D3DPROCESSVERTICES_OPMASK
)
489 if (ci
->dwFlags
& D3DPROCESSVERTICES_TRANSFORM
)
491 if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORMLIGHT
)
492 DUMP("TRANSFORMLIGHT ");
493 if (ci
->dwFlags
& D3DPROCESSVERTICES_UPDATEEXTENTS
)
494 DUMP("UPDATEEXTENTS ");
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...
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.
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).
514 In this case, a 'direct' approach (i.e. without using OpenGL, but
515 writing our own 3D rasterizer) would be easier. */
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 */
524 /* Enough for the moment */
525 if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORMLIGHT
) {
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
;
531 TRACE(ddraw
, " World Matrix : (%p)\n", mat
);
534 ilpBuff
->vertex_type
= D3DVT_VERTEX
;
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
;
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
);
554 } else if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORM
) {
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
;
560 TRACE(ddraw
, " World Matrix : (%p)\n", mat
);
563 ilpBuff
->vertex_type
= D3DVT_LVERTEX
;
565 for (nb
= 0; nb
< ci
->dwCount
; nb
++) {
566 dst
->c
= src
->c
.color
;
567 dst
->sc
= src
->s
.specular
;
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
);
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
;
584 ilpBuff
->vertex_type
= D3DVT_TLVERTEX
;
586 memcpy(dst
, src
, ci
->dwCount
* sizeof(D3DTLVERTEX
));
588 ERR(ddraw
, "Unhandled vertex processing !\n");
595 case D3DOP_TEXTURELOAD
: {
596 TRACE(ddraw
, "TEXTURELOAD-s (%d)\n", count
);
598 instr
+= count
* size
;
602 TRACE(ddraw
, "EXIT (%d)\n", count
);
603 /* We did this instruction */
609 case D3DOP_BRANCHFORWARD
: {
611 TRACE(ddraw
, "BRANCHFORWARD (%d)\n", count
);
613 for (i
= 0; i
< count
; i
++) {
614 LPD3DBRANCH ci
= (LPD3DBRANCH
) instr
;
616 if ((ilpBuff
->data
.dsStatus
.dwStatus
& ci
->dwMask
) == ci
->dwValue
) {
618 TRACE(ddraw
," Should branch to %ld\n", ci
->dwOffset
);
622 TRACE(ddraw
," Should branch to %ld\n", ci
->dwOffset
);
631 TRACE(ddraw
, "SPAN-s (%d)\n", count
);
633 instr
+= count
* size
;
636 case D3DOP_SETSTATUS
: {
638 TRACE(ddraw
, "SETSTATUS (%d)\n", count
);
640 for (i
= 0; i
< count
; i
++) {
641 LPD3DSTATUS ci
= (LPD3DSTATUS
) instr
;
643 ilpBuff
->data
.dsStatus
= *ci
;
650 ERR(ddraw
, "Unhandled OpCode !!!\n");
651 /* Try to save ... */
652 instr
+= count
* size
;
660 /*******************************************************************************
661 * ExecuteBuffer Creation functions
663 LPDIRECT3DEXECUTEBUFFER
d3dexecutebuffer_create(IDirect3DDeviceImpl
* d3ddev
, LPD3DEXECUTEBUFFERDESC lpDesc
)
665 IDirect3DExecuteBufferImpl
* eb
;
667 eb
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(IDirect3DExecuteBufferImpl
));
669 eb
->lpvtbl
= &executebuffer_vtable
;
672 /* Initializes memory */
675 /* No buffer given */
676 if (!(eb
->desc
.dwFlags
& D3DDEB_LPDATA
))
677 eb
->desc
.lpData
= NULL
;
679 /* No buffer size given */
680 if (!(lpDesc
->dwFlags
& D3DDEB_BUFSIZE
))
681 eb
->desc
.dwBufferSize
= 0;
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
);
688 eb
->need_free
= FALSE
;
691 /* No vertices for the moment */
692 eb
->vertex_data
= NULL
;
694 eb
->desc
.dwFlags
|= D3DDEB_LPDATA
;
696 eb
->execute
= execute
;
698 return (LPDIRECT3DEXECUTEBUFFER
)eb
;
701 /*******************************************************************************
702 * IDirect3ExecuteBuffer methods
705 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_QueryInterface(LPDIRECT3DEXECUTEBUFFER iface
,
709 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
712 WINE_StringFromCLSID((LPCLSID
)riid
,xrefiid
);
713 FIXME(ddraw
, "(%p)->(%s,%p): stub\n", This
, xrefiid
,ppvObj
);
720 static ULONG WINAPI
IDirect3DExecuteBufferImpl_AddRef(LPDIRECT3DEXECUTEBUFFER iface
)
722 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
723 TRACE(ddraw
, "(%p)->()incrementing from %lu.\n", This
, This
->ref
);
725 return ++(This
->ref
);
730 static ULONG WINAPI
IDirect3DExecuteBufferImpl_Release(LPDIRECT3DEXECUTEBUFFER iface
)
732 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
733 FIXME( ddraw
, "(%p)->() decrementing from %lu.\n", This
, This
->ref
);
735 if (!--(This
->ref
)) {
736 if ((This
->desc
.lpData
!= NULL
) && This
->need_free
)
737 HeapFree(GetProcessHeap(),0,This
->desc
.lpData
);
739 if (This
->vertex_data
!= NULL
)
740 HeapFree(GetProcessHeap(),0,This
->vertex_data
);
742 HeapFree(GetProcessHeap(),0,This
);
749 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_Initialize(LPDIRECT3DEXECUTEBUFFER iface
,
750 LPDIRECT3DDEVICE lpDirect3DDevice
,
751 LPD3DEXECUTEBUFFERDESC lpDesc
)
753 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
754 FIXME(ddraw
, "(%p)->(%p,%p): stub\n", This
, lpDirect3DDevice
, lpDesc
);
759 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_Lock(LPDIRECT3DEXECUTEBUFFER iface
,
760 LPD3DEXECUTEBUFFERDESC lpDesc
)
762 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
763 TRACE(ddraw
, "(%p)->(%p)\n", This
, lpDesc
);
765 /* Copies the buffer description */
766 *lpDesc
= This
->desc
;
771 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_Unlock(LPDIRECT3DEXECUTEBUFFER iface
)
773 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
774 TRACE(ddraw
, "(%p)->()\n", This
);
779 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_SetExecuteData(LPDIRECT3DEXECUTEBUFFER iface
,
780 LPD3DEXECUTEDATA lpData
)
782 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
785 TRACE(ddraw
, "(%p)->(%p)\n", This
, lpData
);
787 This
->data
= *lpData
;
789 /* Get the number of vertices in the execute buffer */
790 nbvert
= This
->data
.dwVertexCount
;
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
));
798 if (TRACE_ON(ddraw
)) {
799 _dump_executedata(lpData
);
805 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_GetExecuteData(LPDIRECT3DEXECUTEBUFFER iface
,
806 LPD3DEXECUTEDATA lpData
)
808 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
809 TRACE(ddraw
, "(%p)->(%p): stub\n", This
, lpData
);
811 *lpData
= This
->data
;
816 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_Validate(LPDIRECT3DEXECUTEBUFFER iface
,
818 LPD3DVALIDATECALLBACK lpFunc
,
822 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
823 TRACE(ddraw
, "(%p)->(%p,%p,%p,%lu)\n", This
, lpdwOffset
, lpFunc
, lpUserArg
, dwReserved
);
828 static HRESULT WINAPI
IDirect3DExecuteBufferImpl_Optimize(LPDIRECT3DEXECUTEBUFFER iface
,
831 ICOM_THIS(IDirect3DExecuteBufferImpl
,iface
);
832 TRACE(ddraw
, "(%p)->(%lu)\n", This
, dwReserved
);
838 /*******************************************************************************
839 * IDirect3DLight VTable
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
856 #endif /* HAVE_MESAGL */