1 /* Direct3D ExecuteBuffer
2 * Copyright (c) 1998-2004 Lionel ULMER
3 * Copyright (c) 2002-2004 Christian Costa
4 * Copyright (c) 2006 Stefan Dösinger
6 * This file contains the implementation of IDirect3DExecuteBuffer.
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/port.h"
32 #define NONAMELESSUNION
39 #include "wine/exception.h"
45 #include "ddraw_private.h"
46 #include "wine/debug.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(d3d7
);
50 /*****************************************************************************
52 * _dump_D3DEXECUTEBUFFERDESC
54 * Debug functions which write the executebuffer data to the console
56 *****************************************************************************/
58 static void _dump_executedata(LPD3DEXECUTEDATA lpData
) {
59 DPRINTF("dwSize : %d\n", lpData
->dwSize
);
60 DPRINTF("Vertex Offset : %d Count : %d\n", lpData
->dwVertexOffset
, lpData
->dwVertexCount
);
61 DPRINTF("Instruction Offset : %d Length : %d\n", lpData
->dwInstructionOffset
, lpData
->dwInstructionLength
);
62 DPRINTF("HVertex Offset : %d\n", lpData
->dwHVertexOffset
);
65 static void _dump_D3DEXECUTEBUFFERDESC(LPD3DEXECUTEBUFFERDESC lpDesc
) {
66 DPRINTF("dwSize : %d\n", lpDesc
->dwSize
);
67 DPRINTF("dwFlags : %x\n", lpDesc
->dwFlags
);
68 DPRINTF("dwCaps : %x\n", lpDesc
->dwCaps
);
69 DPRINTF("dwBufferSize : %d\n", lpDesc
->dwBufferSize
);
70 DPRINTF("lpData : %p\n", lpDesc
->lpData
);
73 /*****************************************************************************
74 * IDirect3DExecuteBufferImpl_Execute
76 * The main functionality of the execute buffer
77 * It transforms the vertices if necessary, and calls IDirect3DDevice7
78 * for drawing the vertices. It is called from
79 * IDirect3DDevice::Execute
81 * TODO: Perhaps some comments about the various opcodes wouldn't hurt
83 * Don't declare this static, as it's called from device.c,
84 * IDirect3DDevice::Execute
87 * Device: 3D Device associated to use for drawing
88 * Viewport: Viewport for this operation
90 *****************************************************************************/
92 IDirect3DExecuteBufferImpl_Execute(IDirect3DExecuteBufferImpl
*This
,
93 IDirect3DDeviceImpl
*lpDevice
,
94 IDirect3DViewportImpl
*lpViewport
)
96 /* DWORD bs = This->desc.dwBufferSize; */
97 DWORD vs
= This
->data
.dwVertexOffset
;
98 /* DWORD vc = This->data.dwVertexCount; */
99 DWORD is
= This
->data
.dwInstructionOffset
;
100 /* DWORD il = This->data.dwInstructionLength; */
102 char *instr
= (char *)This
->desc
.lpData
+ is
;
104 /* Should check if the viewport was added or not to the device */
106 /* Activate the viewport */
107 lpViewport
->active_device
= lpDevice
;
108 lpViewport
->activate(lpViewport
);
110 TRACE("ExecuteData :\n");
112 _dump_executedata(&(This
->data
));
115 LPD3DINSTRUCTION current
= (LPD3DINSTRUCTION
) instr
;
119 count
= current
->wCount
;
120 size
= current
->bSize
;
121 instr
+= sizeof(D3DINSTRUCTION
);
123 switch (current
->bOpcode
) {
125 WARN("POINT-s (%d)\n", count
);
126 instr
+= count
* size
;
130 WARN("LINE-s (%d)\n", count
);
131 instr
+= count
* size
;
134 case D3DOP_TRIANGLE
: {
136 D3DTLVERTEX
*tl_vx
= (D3DTLVERTEX
*) This
->vertex_data
;
137 TRACE("TRIANGLE (%d)\n", count
);
139 if (count
*3>This
->nb_indices
) {
140 This
->nb_indices
= count
* 3;
141 HeapFree(GetProcessHeap(),0,This
->indices
);
142 This
->indices
= HeapAlloc(GetProcessHeap(),0,sizeof(WORD
)*This
->nb_indices
);
145 for (i
= 0; i
< count
; i
++) {
146 LPD3DTRIANGLE ci
= (LPD3DTRIANGLE
) instr
;
147 TRACE_(d3d7
)(" v1: %d v2: %d v3: %d\n",ci
->u1
.v1
, ci
->u2
.v2
, ci
->u3
.v3
);
148 TRACE_(d3d7
)(" Flags : ");
149 if (TRACE_ON(d3d7
)) {
151 if (ci
->wFlags
& D3DTRIFLAG_EDGEENABLE1
)
152 TRACE_(d3d7
)("EDGEENABLE1 ");
153 if (ci
->wFlags
& D3DTRIFLAG_EDGEENABLE2
)
154 TRACE_(d3d7
)("EDGEENABLE2 ");
155 if (ci
->wFlags
& D3DTRIFLAG_EDGEENABLE1
)
156 TRACE_(d3d7
)("EDGEENABLE3 ");
158 if (ci
->wFlags
== D3DTRIFLAG_EVEN
)
159 TRACE_(d3d7
)("EVEN ");
160 if (ci
->wFlags
== D3DTRIFLAG_ODD
)
161 TRACE_(d3d7
)("ODD ");
162 if (ci
->wFlags
== D3DTRIFLAG_START
)
163 TRACE_(d3d7
)("START ");
164 if ((ci
->wFlags
> 0) && (ci
->wFlags
< 30))
165 TRACE_(d3d7
)("STARTFLAT(%d) ", ci
->wFlags
);
168 This
->indices
[(i
* 3) ] = ci
->u1
.v1
;
169 This
->indices
[(i
* 3) + 1] = ci
->u2
.v2
;
170 This
->indices
[(i
* 3) + 2] = ci
->u3
.v3
;
173 /* IDirect3DDevices have color keying always enabled -
174 * enable it before drawing. This overwrites any ALPHA*
177 IWineD3DDevice_SetRenderState(lpDevice
->wineD3DDevice
,
178 WINED3DRS_COLORKEYENABLE
,
180 IDirect3DDevice7_DrawIndexedPrimitive(ICOM_INTERFACE(lpDevice
,IDirect3DDevice7
),
181 D3DPT_TRIANGLELIST
,D3DFVF_TLVERTEX
,tl_vx
,0,This
->indices
,count
*3,0);
184 case D3DOP_MATRIXLOAD
:
185 WARN("MATRIXLOAD-s (%d)\n", count
);
186 instr
+= count
* size
;
189 case D3DOP_MATRIXMULTIPLY
: {
191 TRACE("MATRIXMULTIPLY (%d)\n", count
);
193 for (i
= 0; i
< count
; i
++) {
194 LPD3DMATRIXMULTIPLY ci
= (LPD3DMATRIXMULTIPLY
) instr
;
197 if(!ci
->hDestMatrix
|| ci
->hDestMatrix
> lpDevice
->numHandles
||
198 !ci
->hSrcMatrix1
|| ci
->hSrcMatrix1
> lpDevice
->numHandles
||
199 !ci
->hSrcMatrix2
|| ci
->hSrcMatrix2
> lpDevice
->numHandles
) {
200 ERR("Handles out of bounds\n");
201 } else if (lpDevice
->Handles
[ci
->hDestMatrix
- 1].type
!= DDrawHandle_Matrix
||
202 lpDevice
->Handles
[ci
->hSrcMatrix1
- 1].type
!= DDrawHandle_Matrix
||
203 lpDevice
->Handles
[ci
->hSrcMatrix2
- 1].type
!= DDrawHandle_Matrix
) {
204 ERR("Handle types invalid\n");
206 a
= (LPD3DMATRIX
) lpDevice
->Handles
[ci
->hDestMatrix
- 1].ptr
;
207 b
= (LPD3DMATRIX
) lpDevice
->Handles
[ci
->hSrcMatrix1
- 1].ptr
;
208 c
= (LPD3DMATRIX
) lpDevice
->Handles
[ci
->hSrcMatrix2
- 1].ptr
;
209 TRACE(" Dest : %p Src1 : %p Src2 : %p\n",
211 multiply_matrix(a
,c
,b
);
218 case D3DOP_STATETRANSFORM
: {
220 TRACE("STATETRANSFORM (%d)\n", count
);
222 for (i
= 0; i
< count
; i
++) {
223 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
225 if(!ci
->u2
.dwArg
[0]) {
226 ERR("Setting a NULL matrix handle, what should I do?\n");
227 } else if(ci
->u2
.dwArg
[0] > lpDevice
->numHandles
) {
228 ERR("Handle %d is out of bounds\n", ci
->u2
.dwArg
[0]);
229 } else if(lpDevice
->Handles
[ci
->u2
.dwArg
[0] - 1].type
!= DDrawHandle_Matrix
) {
230 ERR("Handle %d is not a matrix handle\n", ci
->u2
.dwArg
[0]);
232 IDirect3DDevice7_SetTransform(ICOM_INTERFACE(lpDevice
, IDirect3DDevice7
),
233 ci
->u1
.drstRenderStateType
, (LPD3DMATRIX
) lpDevice
->Handles
[ci
->u2
.dwArg
[0] - 1].ptr
);
239 case D3DOP_STATELIGHT
: {
241 TRACE("STATELIGHT (%d)\n", count
);
243 for (i
= 0; i
< count
; i
++) {
244 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
246 TRACE("(%08x,%08x)\n",ci
->u1
.dlstLightStateType
, ci
->u2
.dwArg
[0]);
248 if (!ci
->u1
.dlstLightStateType
&& (ci
->u1
.dlstLightStateType
> D3DLIGHTSTATE_COLORVERTEX
))
249 ERR("Unexpected Light State Type\n");
250 else if (ci
->u1
.dlstLightStateType
== D3DLIGHTSTATE_MATERIAL
/* 1 */) {
251 IDirect3DMaterialImpl
*mat
= (IDirect3DMaterialImpl
*) ci
->u2
.dwArg
[0];
256 FIXME(" D3DLIGHTSTATE_MATERIAL called with NULL material !!!\n");
259 else if (ci
->u1
.dlstLightStateType
== D3DLIGHTSTATE_COLORMODEL
/* 3 */) {
260 switch (ci
->u2
.dwArg
[0]) {
262 ERR("DDCOLOR_MONO should not happen!\n");
265 /* We are already in this mode */
268 ERR("Unknown color model!\n");
271 D3DRENDERSTATETYPE rs
= 0;
272 switch (ci
->u1
.dlstLightStateType
) {
274 case D3DLIGHTSTATE_AMBIENT
: /* 2 */
275 rs
= D3DRENDERSTATE_AMBIENT
;
277 case D3DLIGHTSTATE_FOGMODE
: /* 4 */
278 rs
= D3DRENDERSTATE_FOGVERTEXMODE
;
280 case D3DLIGHTSTATE_FOGSTART
: /* 5 */
281 rs
= D3DRENDERSTATE_FOGSTART
;
283 case D3DLIGHTSTATE_FOGEND
: /* 6 */
284 rs
= D3DRENDERSTATE_FOGEND
;
286 case D3DLIGHTSTATE_FOGDENSITY
: /* 7 */
287 rs
= D3DRENDERSTATE_FOGDENSITY
;
289 case D3DLIGHTSTATE_COLORVERTEX
: /* 8 */
290 rs
= D3DRENDERSTATE_COLORVERTEX
;
296 IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(lpDevice
, IDirect3DDevice7
),
304 case D3DOP_STATERENDER
: {
306 TRACE("STATERENDER (%d)\n", count
);
308 for (i
= 0; i
< count
; i
++) {
309 LPD3DSTATE ci
= (LPD3DSTATE
) instr
;
311 IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(lpDevice
, IDirect3DDevice7
),
312 ci
->u1
.drstRenderStateType
, ci
->u2
.dwArg
[0]);
318 case D3DOP_PROCESSVERTICES
:
320 /* TODO: Share code with IDirect3DVertexBuffer::ProcessVertices and / or
321 * IWineD3DDevice::ProcessVertices
324 D3DMATRIX view_mat
, world_mat
, proj_mat
;
325 TRACE("PROCESSVERTICES (%d)\n", count
);
327 /* Get the transform and world matrix */
328 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
330 IWineD3DDevice_GetTransform(lpDevice
->wineD3DDevice
,
331 D3DTRANSFORMSTATE_VIEW
,
332 (WINED3DMATRIX
*) &view_mat
);
334 IWineD3DDevice_GetTransform(lpDevice
->wineD3DDevice
,
335 D3DTRANSFORMSTATE_PROJECTION
,
336 (WINED3DMATRIX
*) &proj_mat
);
338 IWineD3DDevice_GetTransform(lpDevice
->wineD3DDevice
,
339 D3DTRANSFORMSTATE_WORLD
,
340 (WINED3DMATRIX
*) &world_mat
);
342 for (i
= 0; i
< count
; i
++) {
343 LPD3DPROCESSVERTICES ci
= (LPD3DPROCESSVERTICES
) instr
;
345 TRACE(" Start : %d Dest : %d Count : %d\n",
346 ci
->wStart
, ci
->wDest
, ci
->dwCount
);
348 if (TRACE_ON(d3d7
)) {
349 if (ci
->dwFlags
& D3DPROCESSVERTICES_COPY
)
351 if (ci
->dwFlags
& D3DPROCESSVERTICES_NOCOLOR
)
353 if (ci
->dwFlags
== D3DPROCESSVERTICES_OPMASK
)
355 if (ci
->dwFlags
& D3DPROCESSVERTICES_TRANSFORM
)
357 if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORMLIGHT
)
358 TRACE("TRANSFORMLIGHT ");
359 if (ci
->dwFlags
& D3DPROCESSVERTICES_UPDATEEXTENTS
)
360 TRACE("UPDATEEXTENTS ");
364 /* This is where doing Direct3D on top on OpenGL is quite difficult.
365 This method transforms a set of vertices using the CURRENT state
366 (lighting, projection, ...) but does not rasterize them.
367 They will only be put on screen later (with the POINT / LINE and
368 TRIANGLE op-codes). The problem is that you can have a triangle
369 with each point having been transformed using another state...
371 In this implementation, I will emulate only ONE thing : each
372 vertex can have its own "WORLD" transformation (this is used in the
373 TWIST.EXE demo of the 5.2 SDK). I suppose that all vertices of the
374 execute buffer use the same state.
376 If I find applications that change other states, I will try to do a
377 more 'fine-tuned' state emulation (but I may become quite tricky if
378 it changes a light position in the middle of a triangle).
380 In this case, a 'direct' approach (i.e. without using OpenGL, but
381 writing our own 3D rasterizer) would be easier. */
383 /* The current method (with the hypothesis that only the WORLD matrix
384 will change between two points) is like this :
385 - I transform 'manually' all the vertices with the current WORLD
386 matrix and store them in the vertex buffer
387 - during the rasterization phase, the WORLD matrix will be set to
388 the Identity matrix */
390 /* Enough for the moment */
391 if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORMLIGHT
) {
393 D3DVERTEX
*src
= ((LPD3DVERTEX
) ((char *)This
->desc
.lpData
+ vs
)) + ci
->wStart
;
394 D3DTLVERTEX
*dst
= ((LPD3DTLVERTEX
) (This
->vertex_data
)) + ci
->wDest
;
395 D3DMATRIX
*mat2
= &world_mat
;
398 D3DVIEWPORT
* Viewport
= &lpViewport
->viewports
.vp1
;
400 if (TRACE_ON(d3d7
)) {
401 TRACE(" Projection Matrix : (%p)\n", &proj_mat
);
402 dump_D3DMATRIX(&proj_mat
);
403 TRACE(" View Matrix : (%p)\n", &view_mat
);
404 dump_D3DMATRIX(&view_mat
);
405 TRACE(" World Matrix : (%p)\n", &world_mat
);
406 dump_D3DMATRIX(&world_mat
);
409 multiply_matrix(&mat
,&view_mat
,&world_mat
);
410 multiply_matrix(&mat
,&proj_mat
,&mat
);
412 for (nb
= 0; nb
< ci
->dwCount
; nb
++) {
413 /* Normals transformation */
414 nx
= (src
->u4
.nx
* mat2
->_11
) + (src
->u5
.ny
* mat2
->_21
) + (src
->u6
.nz
* mat2
->_31
);
415 ny
= (src
->u4
.nx
* mat2
->_12
) + (src
->u5
.ny
* mat2
->_22
) + (src
->u6
.nz
* mat2
->_32
);
416 nz
= (src
->u4
.nx
* mat2
->_13
) + (src
->u5
.ny
* mat2
->_23
) + (src
->u6
.nz
* mat2
->_33
);
418 /* No lighting yet */
419 dst
->u5
.color
= 0xFFFFFFFF; /* Opaque white */
420 dst
->u6
.specular
= 0xFF000000; /* No specular and no fog factor */
422 dst
->u7
.tu
= src
->u7
.tu
;
423 dst
->u8
.tv
= src
->u8
.tv
;
425 /* Now, the matrix multiplication */
426 dst
->u1
.sx
= (src
->u1
.x
* mat
._11
) + (src
->u2
.y
* mat
._21
) + (src
->u3
.z
* mat
._31
) + (1.0 * mat
._41
);
427 dst
->u2
.sy
= (src
->u1
.x
* mat
._12
) + (src
->u2
.y
* mat
._22
) + (src
->u3
.z
* mat
._32
) + (1.0 * mat
._42
);
428 dst
->u3
.sz
= (src
->u1
.x
* mat
._13
) + (src
->u2
.y
* mat
._23
) + (src
->u3
.z
* mat
._33
) + (1.0 * mat
._43
);
429 dst
->u4
.rhw
= (src
->u1
.x
* mat
._14
) + (src
->u2
.y
* mat
._24
) + (src
->u3
.z
* mat
._34
) + (1.0 * mat
._44
);
431 dst
->u1
.sx
= dst
->u1
.sx
/ dst
->u4
.rhw
* Viewport
->dwWidth
/ 2
432 + Viewport
->dwX
+ Viewport
->dwWidth
/ 2;
433 dst
->u2
.sy
= dst
->u2
.sy
/ dst
->u4
.rhw
* Viewport
->dwHeight
/ 2
434 + Viewport
->dwY
+ Viewport
->dwHeight
/ 2;
435 dst
->u3
.sz
/= dst
->u4
.rhw
;
436 dst
->u4
.rhw
= 1 / dst
->u4
.rhw
;
442 } else if (ci
->dwFlags
== D3DPROCESSVERTICES_TRANSFORM
) {
444 D3DLVERTEX
*src
= ((LPD3DLVERTEX
) ((char *)This
->desc
.lpData
+ vs
)) + ci
->wStart
;
445 D3DTLVERTEX
*dst
= ((LPD3DTLVERTEX
) (This
->vertex_data
)) + ci
->wDest
;
447 D3DVIEWPORT
* Viewport
= &lpViewport
->viewports
.vp1
;
449 if (TRACE_ON(d3d7
)) {
450 TRACE(" Projection Matrix : (%p)\n", &proj_mat
);
451 dump_D3DMATRIX(&proj_mat
);
452 TRACE(" View Matrix : (%p)\n",&view_mat
);
453 dump_D3DMATRIX(&view_mat
);
454 TRACE(" World Matrix : (%p)\n", &mat
);
455 dump_D3DMATRIX(&mat
);
458 multiply_matrix(&mat
,&view_mat
,&world_mat
);
459 multiply_matrix(&mat
,&proj_mat
,&mat
);
461 for (nb
= 0; nb
< ci
->dwCount
; nb
++) {
462 dst
->u5
.color
= src
->u4
.color
;
463 dst
->u6
.specular
= src
->u5
.specular
;
464 dst
->u7
.tu
= src
->u6
.tu
;
465 dst
->u8
.tv
= src
->u7
.tv
;
467 /* Now, the matrix multiplication */
468 dst
->u1
.sx
= (src
->u1
.x
* mat
._11
) + (src
->u2
.y
* mat
._21
) + (src
->u3
.z
* mat
._31
) + (1.0 * mat
._41
);
469 dst
->u2
.sy
= (src
->u1
.x
* mat
._12
) + (src
->u2
.y
* mat
._22
) + (src
->u3
.z
* mat
._32
) + (1.0 * mat
._42
);
470 dst
->u3
.sz
= (src
->u1
.x
* mat
._13
) + (src
->u2
.y
* mat
._23
) + (src
->u3
.z
* mat
._33
) + (1.0 * mat
._43
);
471 dst
->u4
.rhw
= (src
->u1
.x
* mat
._14
) + (src
->u2
.y
* mat
._24
) + (src
->u3
.z
* mat
._34
) + (1.0 * mat
._44
);
473 dst
->u1
.sx
/= dst
->u4
.rhw
* Viewport
->dvScaleX
* Viewport
->dwWidth
/ 2 + Viewport
->dwX
;
474 dst
->u2
.sy
/= dst
->u4
.rhw
* Viewport
->dvScaleY
* Viewport
->dwHeight
/ 2 + Viewport
->dwY
;
475 dst
->u3
.sz
/= dst
->u4
.rhw
;
476 dst
->u4
.rhw
= 1 / dst
->u4
.rhw
;
481 } else if (ci
->dwFlags
== D3DPROCESSVERTICES_COPY
) {
482 D3DTLVERTEX
*src
= ((LPD3DTLVERTEX
) ((char *)This
->desc
.lpData
+ vs
)) + ci
->wStart
;
483 D3DTLVERTEX
*dst
= ((LPD3DTLVERTEX
) (This
->vertex_data
)) + ci
->wDest
;
485 memcpy(dst
, src
, ci
->dwCount
* sizeof(D3DTLVERTEX
));
487 ERR("Unhandled vertex processing !\n");
494 case D3DOP_TEXTURELOAD
: {
495 WARN("TEXTURELOAD-s (%d)\n", count
);
497 instr
+= count
* size
;
501 TRACE("EXIT (%d)\n", count
);
502 /* We did this instruction */
508 case D3DOP_BRANCHFORWARD
: {
510 TRACE("BRANCHFORWARD (%d)\n", count
);
512 for (i
= 0; i
< count
; i
++) {
513 LPD3DBRANCH ci
= (LPD3DBRANCH
) instr
;
515 if ((This
->data
.dsStatus
.dwStatus
& ci
->dwMask
) == ci
->dwValue
) {
517 TRACE(" Branch to %d\n", ci
->dwOffset
);
518 instr
= (char*)current
+ ci
->dwOffset
;
523 TRACE(" Branch to %d\n", ci
->dwOffset
);
524 instr
= (char*)current
+ ci
->dwOffset
;
534 WARN("SPAN-s (%d)\n", count
);
536 instr
+= count
* size
;
539 case D3DOP_SETSTATUS
: {
541 TRACE("SETSTATUS (%d)\n", count
);
543 for (i
= 0; i
< count
; i
++) {
544 LPD3DSTATUS ci
= (LPD3DSTATUS
) instr
;
546 This
->data
.dsStatus
= *ci
;
553 ERR("Unhandled OpCode %d !!!\n",current
->bOpcode
);
554 /* Try to save ... */
555 instr
+= count
* size
;
564 /*****************************************************************************
565 * IDirect3DExecuteBuffer::QueryInterface
567 * Well, a usual QueryInterface function. Don't know fur sure which
568 * interfaces it can Query.
571 * riid: The interface ID queried for
572 * obj: Address to return the interface pointer at
575 * D3D_OK in case of a success (S_OK? Think it's the same)
576 * OLE_E_ENUM_NOMORE if the interface wasn't found.
577 * (E_NOINTERFACE?? Don't know what I really need)
579 *****************************************************************************/
580 static HRESULT WINAPI
581 IDirect3DExecuteBufferImpl_QueryInterface(IDirect3DExecuteBuffer
*iface
,
585 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
586 TRACE("(%p/%p)->(%s,%p)\n", This
, iface
, debugstr_guid(riid
), obj
);
590 if ( IsEqualGUID( &IID_IUnknown
, riid
) ) {
591 IDirect3DExecuteBuffer_AddRef(ICOM_INTERFACE(This
, IDirect3DExecuteBuffer
));
593 TRACE(" Creating IUnknown interface at %p.\n", *obj
);
596 if ( IsEqualGUID( &IID_IDirect3DMaterial
, riid
) ) {
597 IDirect3DExecuteBuffer_AddRef(ICOM_INTERFACE(This
, IDirect3DExecuteBuffer
));
598 *obj
= ICOM_INTERFACE(This
, IDirect3DExecuteBuffer
);
599 TRACE(" Creating IDirect3DExecuteBuffer interface %p\n", *obj
);
602 FIXME("(%p): interface for IID %s NOT found!\n", This
, debugstr_guid(riid
));
603 return E_NOINTERFACE
;
607 /*****************************************************************************
608 * IDirect3DExecuteBuffer::AddRef
610 * A normal AddRef method, nothing special
615 *****************************************************************************/
617 IDirect3DExecuteBufferImpl_AddRef(IDirect3DExecuteBuffer
*iface
)
619 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
620 ULONG ref
= InterlockedIncrement(&This
->ref
);
622 FIXME("(%p)->()incrementing from %u.\n", This
, ref
- 1);
627 /*****************************************************************************
628 * IDirect3DExecuteBuffer::Release
630 * A normal Release method, nothing special
635 *****************************************************************************/
637 IDirect3DExecuteBufferImpl_Release(IDirect3DExecuteBuffer
*iface
)
639 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
640 ULONG ref
= InterlockedDecrement(&This
->ref
);
642 TRACE("(%p)->()decrementing from %u.\n", This
, ref
+ 1);
646 HeapFree(GetProcessHeap(),0,This
->desc
.lpData
);
647 HeapFree(GetProcessHeap(),0,This
->vertex_data
);
648 HeapFree(GetProcessHeap(),0,This
->indices
);
649 HeapFree(GetProcessHeap(),0,This
);
656 /*****************************************************************************
657 * IDirect3DExecuteBuffer::Initialize
659 * Initializes the Execute Buffer. This method exists for COM compliance
660 * Nothing to do here.
665 *****************************************************************************/
666 static HRESULT WINAPI
667 IDirect3DExecuteBufferImpl_Initialize(IDirect3DExecuteBuffer
*iface
,
668 IDirect3DDevice
*lpDirect3DDevice
,
669 D3DEXECUTEBUFFERDESC
*lpDesc
)
671 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
672 TRACE("(%p)->(%p,%p) no-op....\n", This
, lpDirect3DDevice
, lpDesc
);
676 /*****************************************************************************
677 * IDirect3DExecuteBuffer::Lock
679 * Locks the buffer, so the app can write into it.
682 * Desc: Pointer to return the buffer description. This Description contains
683 * a pointer to the buffer data.
686 * This implementation always returns D3D_OK
688 *****************************************************************************/
689 static HRESULT WINAPI
690 IDirect3DExecuteBufferImpl_Lock(IDirect3DExecuteBuffer
*iface
,
691 D3DEXECUTEBUFFERDESC
*lpDesc
)
693 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
695 TRACE("(%p)->(%p)\n", This
, lpDesc
);
697 dwSize
= lpDesc
->dwSize
;
698 memset(lpDesc
, 0, dwSize
);
699 memcpy(lpDesc
, &This
->desc
, dwSize
);
701 if (TRACE_ON(d3d7
)) {
702 TRACE(" Returning description :\n");
703 _dump_D3DEXECUTEBUFFERDESC(lpDesc
);
708 /*****************************************************************************
709 * IDirect3DExecuteBuffer::Unlock
711 * Unlocks the buffer. We don't have anything to do here
714 * This implementation always returns D3D_OK
716 *****************************************************************************/
717 static HRESULT WINAPI
718 IDirect3DExecuteBufferImpl_Unlock(IDirect3DExecuteBuffer
*iface
)
720 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
721 TRACE("(%p)->() no-op...\n", This
);
725 /*****************************************************************************
726 * IDirect3DExecuteBuffer::SetExecuteData
728 * Sets the execute data. This data is used to describe the buffer's content
731 * Data: Pointer to a D3DEXECUTEDATA structure containing the data to
736 * DDERR_OUTOFMEMORY if the vertex buffer allocation failed
738 *****************************************************************************/
739 static HRESULT WINAPI
740 IDirect3DExecuteBufferImpl_SetExecuteData(IDirect3DExecuteBuffer
*iface
,
741 D3DEXECUTEDATA
*lpData
)
743 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
745 TRACE("(%p)->(%p)\n", This
, lpData
);
747 memcpy(&This
->data
, lpData
, lpData
->dwSize
);
749 /* Get the number of vertices in the execute buffer */
750 nbvert
= This
->data
.dwVertexCount
;
752 /* Prepares the transformed vertex buffer */
753 HeapFree(GetProcessHeap(), 0, This
->vertex_data
);
754 This
->vertex_data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, nbvert
* sizeof(D3DTLVERTEX
));
756 if (TRACE_ON(d3d7
)) {
757 _dump_executedata(lpData
);
763 /*****************************************************************************
764 * IDirect3DExecuteBuffer::GetExecuteData
766 * Returns the data in the execute buffer
769 * Data: Pointer to a D3DEXECUTEDATA structure used to return data
774 *****************************************************************************/
775 static HRESULT WINAPI
776 IDirect3DExecuteBufferImpl_GetExecuteData(IDirect3DExecuteBuffer
*iface
,
777 D3DEXECUTEDATA
*lpData
)
779 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
781 TRACE("(%p)->(%p): stub!\n", This
, lpData
);
783 dwSize
= lpData
->dwSize
;
784 memset(lpData
, 0, dwSize
);
785 memcpy(lpData
, &This
->data
, dwSize
);
787 if (TRACE_ON(d3d7
)) {
788 TRACE("Returning data :\n");
789 _dump_executedata(lpData
);
795 /*****************************************************************************
796 * IDirect3DExecuteBuffer::Validate
798 * DirectX 5 SDK: "The IDirect3DExecuteBuffer::Validate method is not
799 * currently implemented"
805 * DDERR_UNSUPPORTED, because it's not implemented in Windows.
807 *****************************************************************************/
808 static HRESULT WINAPI
809 IDirect3DExecuteBufferImpl_Validate(IDirect3DExecuteBuffer
*iface
,
811 LPD3DVALIDATECALLBACK Func
,
815 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
816 TRACE("(%p)->(%p,%p,%p,%08x): Unimplemented!\n", This
, Offset
, Func
, UserArg
, Reserved
);
817 return DDERR_UNSUPPORTED
; /* Unchecked */
820 /*****************************************************************************
821 * IDirect3DExecuteBuffer::Optimize
823 * DirectX5 SDK: "The IDirect3DExecuteBuffer::Optimize method is not
824 * currently supported"
827 * Dummy: Seems to be an unused dummy ;)
830 * DDERR_UNSUPPORTED, because it's not implemented in Windows.
832 *****************************************************************************/
833 static HRESULT WINAPI
834 IDirect3DExecuteBufferImpl_Optimize(IDirect3DExecuteBuffer
*iface
,
837 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl
, IDirect3DExecuteBuffer
, iface
);
838 TRACE("(%p)->(%08x): Unimplemented\n", This
, Dummy
);
839 return DDERR_UNSUPPORTED
; /* Unchecked */
842 const IDirect3DExecuteBufferVtbl IDirect3DExecuteBuffer_Vtbl
=
844 IDirect3DExecuteBufferImpl_QueryInterface
,
845 IDirect3DExecuteBufferImpl_AddRef
,
846 IDirect3DExecuteBufferImpl_Release
,
847 IDirect3DExecuteBufferImpl_Initialize
,
848 IDirect3DExecuteBufferImpl_Lock
,
849 IDirect3DExecuteBufferImpl_Unlock
,
850 IDirect3DExecuteBufferImpl_SetExecuteData
,
851 IDirect3DExecuteBufferImpl_GetExecuteData
,
852 IDirect3DExecuteBufferImpl_Validate
,
853 IDirect3DExecuteBufferImpl_Optimize
,