?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
programs/wcmd: Rename to programs/cmd.
[wine.git] / dlls / ddraw / executebuffer.c
blob3f5069d27d8561fe7355cb619d7e22de03107edf
1 /* Direct3D ExecuteBuffer
2 * Copyright (c) 1998-2004 Lionel ULMER
3 * Copyright (c) 2002-2004 Christian Costa
4 * Copyright (c) 2006 Stefan Dösinger
5 *
6 * This file contains the implementation of IDirect3DExecuteBuffer.
7 *
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.
12 *
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.
17 *
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
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <stdlib.h>
30
31 #define COBJMACROS
32 #define NONAMELESSUNION
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winnls.h"
37 #include "winerror.h"
38 #include "wingdi.h"
39 #include "wine/exception.h"
40 #include "excpt.h"
41
42 #include "ddraw.h"
43 #include "d3d.h"
44
45 #include "ddraw_private.h"
46 #include "wine/debug.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(d3d7);
49
50 /*****************************************************************************
51 * _dump_executedata
52 * _dump_D3DEXECUTEBUFFERDESC
53 *
54 * Debug functions which write the executebuffer data to the console
55 *
56 *****************************************************************************/
57
58 static void _dump_executedata(LPD3DEXECUTEDATA lpData) {
59 DPRINTF("dwSize : %ld\n", lpData->dwSize);
60 DPRINTF("Vertex Offset : %ld Count : %ld\n", lpData->dwVertexOffset, lpData->dwVertexCount);
61 DPRINTF("Instruction Offset : %ld Length : %ld\n", lpData->dwInstructionOffset, lpData->dwInstructionLength);
62 DPRINTF("HVertex Offset : %ld\n", lpData->dwHVertexOffset);
63 }
64
65 static void _dump_D3DEXECUTEBUFFERDESC(LPD3DEXECUTEBUFFERDESC lpDesc) {
66 DPRINTF("dwSize : %ld\n", lpDesc->dwSize);
67 DPRINTF("dwFlags : %lx\n", lpDesc->dwFlags);
68 DPRINTF("dwCaps : %lx\n", lpDesc->dwCaps);
69 DPRINTF("dwBufferSize : %ld\n", lpDesc->dwBufferSize);
70 DPRINTF("lpData : %p\n", lpDesc->lpData);
71 }
72
73 /*****************************************************************************
74 * IDirect3DExecuteBufferImpl_Execute
75 *
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
80 *
81 * TODO: Perhaps some comments about the various opcodes wouldn't hurt
82 *
83 * Don't declare this static, as it's called from device.c,
84 * IDirect3DDevice::Execute
85 *
86 * Params:
87 * Device: 3D Device associated to use for drawing
88 * Viewport: Viewport for this operation
89 *
90 *****************************************************************************/
91 void
92 IDirect3DExecuteBufferImpl_Execute(IDirect3DExecuteBufferImpl *This,
93 IDirect3DDeviceImpl *lpDevice,
94 IDirect3DViewportImpl *lpViewport)
95 {
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; */
101
102 char *instr = (char *)This->desc.lpData + is;
103
104 /* Should check if the viewport was added or not to the device */
105
106 /* Activate the viewport */
107 lpViewport->active_device = lpDevice;
108 lpViewport->activate(lpViewport);
109
110 TRACE("ExecuteData :\n");
111 if (TRACE_ON(d3d7))
112 _dump_executedata(&(This->data));
113
114 while (1) {
115 LPD3DINSTRUCTION current = (LPD3DINSTRUCTION) instr;
116 BYTE size;
117 WORD count;
118
119 count = current->wCount;
120 size = current->bSize;
121 instr += sizeof(D3DINSTRUCTION);
122
123 switch (current->bOpcode) {
124 case D3DOP_POINT: {
125 WARN("POINT-s (%d)\n", count);
126 instr += count * size;
127 } break;
128
129 case D3DOP_LINE: {
130 WARN("LINE-s (%d)\n", count);
131 instr += count * size;
132 } break;
133
134 case D3DOP_TRIANGLE: {
135 int i;
136 D3DTLVERTEX *tl_vx = (D3DTLVERTEX *) This->vertex_data;
137 TRACE("TRIANGLE (%d)\n", count);
138
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);
143 }
144
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)) {
150 /* Wireframe */
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 ");
157 /* Strips / Fans */
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);
166 TRACE_(d3d7)("\n");
167 }
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;
171 instr += size;
172 }
173 /* IDirect3DDevices have color keying always enabled -
174 * enable it before drawing. This overwrites any ALPHA*
175 * render state
176 */
177 IWineD3DDevice_SetRenderState(lpDevice->wineD3DDevice,
178 WINED3DRS_COLORKEYENABLE,
179 1);
180 IDirect3DDevice7_DrawIndexedPrimitive(ICOM_INTERFACE(lpDevice,IDirect3DDevice7),
181 D3DPT_TRIANGLELIST,D3DFVF_TLVERTEX,tl_vx,0,This->indices,count*3,0);
182 } break;
183
184 case D3DOP_MATRIXLOAD:
185 WARN("MATRIXLOAD-s (%d)\n", count);
186 instr += count * size;
187 break;
188
189 case D3DOP_MATRIXMULTIPLY: {
190 int i;
191 TRACE("MATRIXMULTIPLY (%d)\n", count);
192
193 for (i = 0; i < count; i++) {
194 LPD3DMATRIXMULTIPLY ci = (LPD3DMATRIXMULTIPLY) instr;
195 LPD3DMATRIX a, b, c;
196
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");
205 } else {
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",
210 a, b, c);
211 multiply_matrix(a,c,b);
212 }
213
214 instr += size;
215 }
216 } break;
217
218 case D3DOP_STATETRANSFORM: {
219 int i;
220 TRACE("STATETRANSFORM (%d)\n", count);
221
222 for (i = 0; i < count; i++) {
223 LPD3DSTATE ci = (LPD3DSTATE) instr;
224
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 %ld 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 %ld is not a matrix handle\n", ci->u2.dwArg[0]);
231 } else {
232 IDirect3DDevice7_SetTransform(ICOM_INTERFACE(lpDevice, IDirect3DDevice7),
233 ci->u1.drstRenderStateType, (LPD3DMATRIX) lpDevice->Handles[ci->u2.dwArg[0] - 1].ptr);
234 }
235 instr += size;
236 }
237 } break;
238
239 case D3DOP_STATELIGHT: {
240 int i;
241 TRACE("STATELIGHT (%d)\n", count);
242
243 for (i = 0; i < count; i++) {
244 LPD3DSTATE ci = (LPD3DSTATE) instr;
245
246 TRACE("(%08x,%08lx)\n",ci->u1.dlstLightStateType, ci->u2.dwArg[0]);
247
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];
252
253 if (mat != NULL) {
254 mat->activate(mat);
255 } else {
256 FIXME(" D3DLIGHTSTATE_MATERIAL called with NULL material !!!\n");
257 }
258 }
259 else if (ci->u1.dlstLightStateType == D3DLIGHTSTATE_COLORMODEL /* 3 */) {
260 switch (ci->u2.dwArg[0]) {
261 case D3DCOLOR_MONO:
262 ERR("DDCOLOR_MONO should not happen!\n");
263 break;
264 case D3DCOLOR_RGB:
265 /* We are already in this mode */
266 break;
267 default:
268 ERR("Unknown color model!\n");
269 }
270 } else {
271 D3DRENDERSTATETYPE rs = 0;
272 switch (ci->u1.dlstLightStateType) {
273
274 case D3DLIGHTSTATE_AMBIENT: /* 2 */
275 rs = D3DRENDERSTATE_AMBIENT;
276 break;
277 case D3DLIGHTSTATE_FOGMODE: /* 4 */
278 rs = D3DRENDERSTATE_FOGVERTEXMODE;
279 break;
280 case D3DLIGHTSTATE_FOGSTART: /* 5 */
281 rs = D3DRENDERSTATE_FOGSTART;
282 break;
283 case D3DLIGHTSTATE_FOGEND: /* 6 */
284 rs = D3DRENDERSTATE_FOGEND;
285 break;
286 case D3DLIGHTSTATE_FOGDENSITY: /* 7 */
287 rs = D3DRENDERSTATE_FOGDENSITY;
288 break;
289 case D3DLIGHTSTATE_COLORVERTEX: /* 8 */
290 rs = D3DRENDERSTATE_COLORVERTEX;
291 break;
292 default:
293 break;
294 }
295
296 IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(lpDevice, IDirect3DDevice7),
297 rs,ci->u2.dwArg[0]);
298 }
299
300 instr += size;
301 }
302 } break;
303
304 case D3DOP_STATERENDER: {
305 int i;
306 TRACE("STATERENDER (%d)\n", count);
307
308 for (i = 0; i < count; i++) {
309 LPD3DSTATE ci = (LPD3DSTATE) instr;
310
311 IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(lpDevice, IDirect3DDevice7),
312 ci->u1.drstRenderStateType, ci->u2.dwArg[0]);
313
314 instr += size;
315 }
316 } break;
317
318 case D3DOP_PROCESSVERTICES:
319 {
320 /* TODO: Share code with IDirect3DVertexBuffer::ProcessVertices and / or
321 * IWineD3DDevice::ProcessVertices
322 */
323 int i;
324 D3DMATRIX view_mat, world_mat, proj_mat;
325 TRACE("PROCESSVERTICES (%d)\n", count);
326
327 /* Get the transform and world matrix */
328 IWineD3DDevice_GetTransform(lpDevice->wineD3DDevice,
329 D3DTRANSFORMSTATE_VIEW,
330 &view_mat);
331
332 IWineD3DDevice_GetTransform(lpDevice->wineD3DDevice,
333 D3DTRANSFORMSTATE_PROJECTION,
334 &proj_mat);
335
336 IWineD3DDevice_GetTransform(lpDevice->wineD3DDevice,
337 D3DTRANSFORMSTATE_WORLD,
338 &world_mat);
339
340 for (i = 0; i < count; i++) {
341 LPD3DPROCESSVERTICES ci = (LPD3DPROCESSVERTICES) instr;
342
343 TRACE(" Start : %d Dest : %d Count : %ld\n",
344 ci->wStart, ci->wDest, ci->dwCount);
345 TRACE(" Flags : ");
346 if (TRACE_ON(d3d7)) {
347 if (ci->dwFlags & D3DPROCESSVERTICES_COPY)
348 TRACE("COPY ");
349 if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
350 TRACE("NOCOLOR ");
351 if (ci->dwFlags == D3DPROCESSVERTICES_OPMASK)
352 TRACE("OPMASK ");
353 if (ci->dwFlags & D3DPROCESSVERTICES_TRANSFORM)
354 TRACE("TRANSFORM ");
355 if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT)
356 TRACE("TRANSFORMLIGHT ");
357 if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
358 TRACE("UPDATEEXTENTS ");
359 TRACE("\n");
360 }
361
362 /* This is where doing Direct3D on top on OpenGL is quite difficult.
363 This method transforms a set of vertices using the CURRENT state
364 (lighting, projection, ...) but does not rasterize them.
365 They will only be put on screen later (with the POINT / LINE and
366 TRIANGLE op-codes). The problem is that you can have a triangle
367 with each point having been transformed using another state...
368
369 In this implementation, I will emulate only ONE thing : each
370 vertex can have its own "WORLD" transformation (this is used in the
371 TWIST.EXE demo of the 5.2 SDK). I suppose that all vertices of the
372 execute buffer use the same state.
373
374 If I find applications that change other states, I will try to do a
375 more 'fine-tuned' state emulation (but I may become quite tricky if
376 it changes a light position in the middle of a triangle).
377
378 In this case, a 'direct' approach (i.e. without using OpenGL, but
379 writing our own 3D rasterizer) would be easier. */
380
381 /* The current method (with the hypothesis that only the WORLD matrix
382 will change between two points) is like this :
383 - I transform 'manually' all the vertices with the current WORLD
384 matrix and store them in the vertex buffer
385 - during the rasterization phase, the WORLD matrix will be set to
386 the Identity matrix */
387
388 /* Enough for the moment */
389 if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORMLIGHT) {
390 unsigned int nb;
391 D3DVERTEX *src = ((LPD3DVERTEX) ((char *)This->desc.lpData + vs)) + ci->wStart;
392 D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (This->vertex_data)) + ci->wDest;
393 D3DMATRIX *mat2 = &world_mat;
394 D3DMATRIX mat;
395 D3DVALUE nx,ny,nz;
396 D3DVIEWPORT* Viewport = &lpViewport->viewports.vp1;
397
398 if (TRACE_ON(d3d7)) {
399 TRACE(" Projection Matrix : (%p)\n", &proj_mat);
400 dump_D3DMATRIX(&proj_mat);
401 TRACE(" View Matrix : (%p)\n", &view_mat);
402 dump_D3DMATRIX(&view_mat);
403 TRACE(" World Matrix : (%p)\n", &world_mat);
404 dump_D3DMATRIX(&world_mat);
405 }
406
407 multiply_matrix(&mat,&view_mat,&world_mat);
408 multiply_matrix(&mat,&proj_mat,&mat);
409
410 for (nb = 0; nb < ci->dwCount; nb++) {
411 /* Normals transformation */
412 nx = (src->u4.nx * mat2->_11) + (src->u5.ny * mat2->_21) + (src->u6.nz * mat2->_31);
413 ny = (src->u4.nx * mat2->_12) + (src->u5.ny * mat2->_22) + (src->u6.nz * mat2->_32);
414 nz = (src->u4.nx * mat2->_13) + (src->u5.ny * mat2->_23) + (src->u6.nz * mat2->_33);
415
416 /* No lighting yet */
417 dst->u5.color = 0xFFFFFFFF; /* Opaque white */
418 dst->u6.specular = 0xFF000000; /* No specular and no fog factor */
419
420 dst->u7.tu = src->u7.tu;
421 dst->u8.tv = src->u8.tv;
422
423 /* Now, the matrix multiplication */
424 dst->u1.sx = (src->u1.x * mat._11) + (src->u2.y * mat._21) + (src->u3.z * mat._31) + (1.0 * mat._41);
425 dst->u2.sy = (src->u1.x * mat._12) + (src->u2.y * mat._22) + (src->u3.z * mat._32) + (1.0 * mat._42);
426 dst->u3.sz = (src->u1.x * mat._13) + (src->u2.y * mat._23) + (src->u3.z * mat._33) + (1.0 * mat._43);
427 dst->u4.rhw = (src->u1.x * mat._14) + (src->u2.y * mat._24) + (src->u3.z * mat._34) + (1.0 * mat._44);
428
429 dst->u1.sx = dst->u1.sx / dst->u4.rhw * Viewport->dwWidth / 2
430 + Viewport->dwX + Viewport->dwWidth / 2;
431 dst->u2.sy = dst->u2.sy / dst->u4.rhw * Viewport->dwHeight / 2
432 + Viewport->dwY + Viewport->dwHeight / 2;
433 dst->u3.sz /= dst->u4.rhw;
434 dst->u4.rhw = 1 / dst->u4.rhw;
435
436 src++;
437 dst++;
438
439 }
440 } else if (ci->dwFlags == D3DPROCESSVERTICES_TRANSFORM) {
441 unsigned int nb;
442 D3DLVERTEX *src = ((LPD3DLVERTEX) ((char *)This->desc.lpData + vs)) + ci->wStart;
443 D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (This->vertex_data)) + ci->wDest;
444 D3DMATRIX mat;
445 D3DVIEWPORT* Viewport = &lpViewport->viewports.vp1;
446
447 if (TRACE_ON(d3d7)) {
448 TRACE(" Projection Matrix : (%p)\n", &proj_mat);
449 dump_D3DMATRIX(&proj_mat);
450 TRACE(" View Matrix : (%p)\n",&view_mat);
451 dump_D3DMATRIX(&view_mat);
452 TRACE(" World Matrix : (%p)\n", &mat);
453 dump_D3DMATRIX(&mat);
454 }
455
456 multiply_matrix(&mat,&view_mat,&world_mat);
457 multiply_matrix(&mat,&proj_mat,&mat);
458
459 for (nb = 0; nb < ci->dwCount; nb++) {
460 dst->u5.color = src->u4.color;
461 dst->u6.specular = src->u5.specular;
462 dst->u7.tu = src->u6.tu;
463 dst->u8.tv = src->u7.tv;
464
465 /* Now, the matrix multiplication */
466 dst->u1.sx = (src->u1.x * mat._11) + (src->u2.y * mat._21) + (src->u3.z * mat._31) + (1.0 * mat._41);
467 dst->u2.sy = (src->u1.x * mat._12) + (src->u2.y * mat._22) + (src->u3.z * mat._32) + (1.0 * mat._42);
468 dst->u3.sz = (src->u1.x * mat._13) + (src->u2.y * mat._23) + (src->u3.z * mat._33) + (1.0 * mat._43);
469 dst->u4.rhw = (src->u1.x * mat._14) + (src->u2.y * mat._24) + (src->u3.z * mat._34) + (1.0 * mat._44);
470
471 dst->u1.sx /= dst->u4.rhw * Viewport->dvScaleX * Viewport->dwWidth / 2 + Viewport->dwX;
472 dst->u2.sy /= dst->u4.rhw * Viewport->dvScaleY * Viewport->dwHeight / 2 + Viewport->dwY;
473 dst->u3.sz /= dst->u4.rhw;
474 dst->u4.rhw = 1 / dst->u4.rhw;
475
476 src++;
477 dst++;
478 }
479 } else if (ci->dwFlags == D3DPROCESSVERTICES_COPY) {
480 D3DTLVERTEX *src = ((LPD3DTLVERTEX) ((char *)This->desc.lpData + vs)) + ci->wStart;
481 D3DTLVERTEX *dst = ((LPD3DTLVERTEX) (This->vertex_data)) + ci->wDest;
482
483 memcpy(dst, src, ci->dwCount * sizeof(D3DTLVERTEX));
484 } else {
485 ERR("Unhandled vertex processing !\n");
486 }
487
488 instr += size;
489 }
490 } break;
491
492 case D3DOP_TEXTURELOAD: {
493 WARN("TEXTURELOAD-s (%d)\n", count);
494
495 instr += count * size;
496 } break;
497
498 case D3DOP_EXIT: {
499 TRACE("EXIT (%d)\n", count);
500 /* We did this instruction */
501 instr += size;
502 /* Exit this loop */
503 goto end_of_buffer;
504 } break;
505
506 case D3DOP_BRANCHFORWARD: {
507 int i;
508 TRACE("BRANCHFORWARD (%d)\n", count);
509
510 for (i = 0; i < count; i++) {
511 LPD3DBRANCH ci = (LPD3DBRANCH) instr;
512
513 if ((This->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue) {
514 if (!ci->bNegate) {
515 TRACE(" Branch to %ld\n", ci->dwOffset);
516 instr = (char*)current + ci->dwOffset;
517 break;
518 }
519 } else {
520 if (ci->bNegate) {
521 TRACE(" Branch to %ld\n", ci->dwOffset);
522 instr = (char*)current + ci->dwOffset;
523 break;
524 }
525 }
526
527 instr += size;
528 }
529 } break;
530
531 case D3DOP_SPAN: {
532 WARN("SPAN-s (%d)\n", count);
533
534 instr += count * size;
535 } break;
536
537 case D3DOP_SETSTATUS: {
538 int i;
539 TRACE("SETSTATUS (%d)\n", count);
540
541 for (i = 0; i < count; i++) {
542 LPD3DSTATUS ci = (LPD3DSTATUS) instr;
543
544 This->data.dsStatus = *ci;
545
546 instr += size;
547 }
548 } break;
549
550 default:
551 ERR("Unhandled OpCode %d !!!\n",current->bOpcode);
552 /* Try to save ... */
553 instr += count * size;
554 break;
555 }
556 }
557
558 end_of_buffer:
559 ;
560 }
561
562 /*****************************************************************************
563 * IDirect3DExecuteBuffer::QueryInterface
564 *
565 * Well, a usual QueryInterface function. Don't know fur sure which
566 * interfaces it can Query.
567 *
568 * Params:
569 * riid: The interface ID queried for
570 * obj: Address to return the interface pointer at
571 *
572 * Returns:
573 * D3D_OK in case of a success (S_OK? Think it's the same)
574 * OLE_E_ENUM_NOMORE if the interface wasn't found.
575 * (E_NOINTERFACE?? Don't know what I really need)
576 *
577 *****************************************************************************/
578 static HRESULT WINAPI
579 IDirect3DExecuteBufferImpl_QueryInterface(IDirect3DExecuteBuffer *iface,
580 REFIID riid,
581 void **obj)
582 {
583 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
584 TRACE("(%p/%p)->(%s,%p)\n", This, iface, debugstr_guid(riid), obj);
585
586 *obj = NULL;
587
588 if ( IsEqualGUID( &IID_IUnknown, riid ) ) {
589 IDirect3DExecuteBuffer_AddRef(ICOM_INTERFACE(This, IDirect3DExecuteBuffer));
590 *obj = iface;
591 TRACE(" Creating IUnknown interface at %p.\n", *obj);
592 return S_OK;
593 }
594 if ( IsEqualGUID( &IID_IDirect3DMaterial, riid ) ) {
595 IDirect3DExecuteBuffer_AddRef(ICOM_INTERFACE(This, IDirect3DExecuteBuffer));
596 *obj = ICOM_INTERFACE(This, IDirect3DExecuteBuffer);
597 TRACE(" Creating IDirect3DExecuteBuffer interface %p\n", *obj);
598 return S_OK;
599 }
600 FIXME("(%p): interface for IID %s NOT found!\n", This, debugstr_guid(riid));
601 return E_NOINTERFACE;
602 }
603
604
605 /*****************************************************************************
606 * IDirect3DExecuteBuffer::AddRef
607 *
608 * A normal AddRef method, nothing special
609 *
610 * Returns:
611 * The new refcount
612 *
613 *****************************************************************************/
614 static ULONG WINAPI
615 IDirect3DExecuteBufferImpl_AddRef(IDirect3DExecuteBuffer *iface)
616 {
617 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
618 ULONG ref = InterlockedIncrement(&This->ref);
619
620 FIXME("(%p)->()incrementing from %lu.\n", This, ref - 1);
621
622 return ref;
623 }
624
625 /*****************************************************************************
626 * IDirect3DExecuteBuffer::Release
627 *
628 * A normal Release method, nothing special
629 *
630 * Returns:
631 * The new refcount
632 *
633 *****************************************************************************/
634 static ULONG WINAPI
635 IDirect3DExecuteBufferImpl_Release(IDirect3DExecuteBuffer *iface)
636 {
637 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
638 ULONG ref = InterlockedDecrement(&This->ref);
639
640 TRACE("(%p)->()decrementing from %lu.\n", This, ref + 1);
641
642 if (!ref) {
643 if (This->need_free)
644 HeapFree(GetProcessHeap(),0,This->desc.lpData);
645 HeapFree(GetProcessHeap(),0,This->vertex_data);
646 HeapFree(GetProcessHeap(),0,This->indices);
647 HeapFree(GetProcessHeap(),0,This);
648 return 0;
649 }
650
651 return ref;
652 }
653
654 /*****************************************************************************
655 * IDirect3DExecuteBuffer::Initialize
656 *
657 * Initializes the Execute Buffer. This method exists for COM compliance
658 * Nothing to do here.
659 *
660 * Returns:
661 * D3D_OK
662 *
663 *****************************************************************************/
664 static HRESULT WINAPI
665 IDirect3DExecuteBufferImpl_Initialize(IDirect3DExecuteBuffer *iface,
666 IDirect3DDevice *lpDirect3DDevice,
667 D3DEXECUTEBUFFERDESC *lpDesc)
668 {
669 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
670 TRACE("(%p)->(%p,%p) no-op....\n", This, lpDirect3DDevice, lpDesc);
671 return D3D_OK;
672 }
673
674 /*****************************************************************************
675 * IDirect3DExecuteBuffer::Lock
676 *
677 * Locks the buffer, so the app can write into it.
678 *
679 * Params:
680 * Desc: Pointer to return the buffer description. This Description contains
681 * a pointer to the buffer data.
682 *
683 * Returns:
684 * This implementation always returns D3D_OK
685 *
686 *****************************************************************************/
687 static HRESULT WINAPI
688 IDirect3DExecuteBufferImpl_Lock(IDirect3DExecuteBuffer *iface,
689 D3DEXECUTEBUFFERDESC *lpDesc)
690 {
691 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
692 DWORD dwSize;
693 TRACE("(%p)->(%p)\n", This, lpDesc);
694
695 dwSize = lpDesc->dwSize;
696 memset(lpDesc, 0, dwSize);
697 memcpy(lpDesc, &This->desc, dwSize);
698
699 if (TRACE_ON(d3d7)) {
700 TRACE(" Returning description :\n");
701 _dump_D3DEXECUTEBUFFERDESC(lpDesc);
702 }
703 return D3D_OK;
704 }
705
706 /*****************************************************************************
707 * IDirect3DExecuteBuffer::Unlock
708 *
709 * Unlocks the buffer. We don't have anything to do here
710 *
711 * Returns:
712 * This implementation always returns D3D_OK
713 *
714 *****************************************************************************/
715 static HRESULT WINAPI
716 IDirect3DExecuteBufferImpl_Unlock(IDirect3DExecuteBuffer *iface)
717 {
718 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
719 TRACE("(%p)->() no-op...\n", This);
720 return D3D_OK;
721 }
722
723 /*****************************************************************************
724 * IDirect3DExecuteBuffer::SetExecuteData
725 *
726 * Sets the execute data. This data is used to describe the buffer's content
727 *
728 * Params:
729 * Data: Pointer to a D3DEXECUTEDATA structure containing the data to
730 * assign
731 *
732 * Returns:
733 * D3D_OK on success
734 * DDERR_OUTOFMEMORY if the vertex buffer allocation failed
735 *
736 *****************************************************************************/
737 static HRESULT WINAPI
738 IDirect3DExecuteBufferImpl_SetExecuteData(IDirect3DExecuteBuffer *iface,
739 D3DEXECUTEDATA *lpData)
740 {
741 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
742 DWORD nbvert;
743 TRACE("(%p)->(%p)\n", This, lpData);
744
745 memcpy(&This->data, lpData, lpData->dwSize);
746
747 /* Get the number of vertices in the execute buffer */
748 nbvert = This->data.dwVertexCount;
749
750 /* Prepares the transformed vertex buffer */
751 HeapFree(GetProcessHeap(), 0, This->vertex_data);
752 This->vertex_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nbvert * sizeof(D3DTLVERTEX));
753
754 if (TRACE_ON(d3d7)) {
755 _dump_executedata(lpData);
756 }
757
758 return D3D_OK;
759 }
760
761 /*****************************************************************************
762 * IDirect3DExecuteBuffer::GetExecuteData
763 *
764 * Returns the data in the execute buffer
765 *
766 * Params:
767 * Data: Pointer to a D3DEXECUTEDATA structure used to return data
768 *
769 * Returns:
770 * D3D_OK on success
771 *
772 *****************************************************************************/
773 static HRESULT WINAPI
774 IDirect3DExecuteBufferImpl_GetExecuteData(IDirect3DExecuteBuffer *iface,
775 D3DEXECUTEDATA *lpData)
776 {
777 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
778 DWORD dwSize;
779 TRACE("(%p)->(%p): stub!\n", This, lpData);
780
781 dwSize = lpData->dwSize;
782 memset(lpData, 0, dwSize);
783 memcpy(lpData, &This->data, dwSize);
784
785 if (TRACE_ON(d3d7)) {
786 TRACE("Returning data :\n");
787 _dump_executedata(lpData);
788 }
789
790 return DD_OK;
791 }
792
793 /*****************************************************************************
794 * IDirect3DExecuteBuffer::Validate
795 *
796 * DirectX 5 SDK: "The IDirect3DExecuteBuffer::Validate method is not
797 * currently implemented"
798 *
799 * Params:
800 * ?
801 *
802 * Returns:
803 * DDERR_UNSUPPORTED, because it's not implemented in Windows.
804 *
805 *****************************************************************************/
806 static HRESULT WINAPI
807 IDirect3DExecuteBufferImpl_Validate(IDirect3DExecuteBuffer *iface,
808 DWORD *Offset,
809 LPD3DVALIDATECALLBACK Func,
810 void *UserArg,
811 DWORD Reserved)
812 {
813 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
814 TRACE("(%p)->(%p,%p,%p,%08lx): Unimplemented!\n", This, Offset, Func, UserArg, Reserved);
815 return DDERR_UNSUPPORTED; /* Unchecked */
816 }
817
818 /*****************************************************************************
819 * IDirect3DExecuteBuffer::Optimize
820 *
821 * DirectX5 SDK: "The IDirect3DExecuteBuffer::Optimize method is not
822 * currently supported"
823 *
824 * Params:
825 * Dummy: Seems to be an unused dummy ;)
826 *
827 * Returns:
828 * DDERR_UNSUPPORTED, because it's not implemented in Windows.
829 *
830 *****************************************************************************/
831 static HRESULT WINAPI
832 IDirect3DExecuteBufferImpl_Optimize(IDirect3DExecuteBuffer *iface,
833 DWORD Dummy)
834 {
835 ICOM_THIS_FROM(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, iface);
836 TRACE("(%p)->(%08lx): Unimplemented\n", This, Dummy);
837 return DDERR_UNSUPPORTED; /* Unchecked */
838 }
839
840 const IDirect3DExecuteBufferVtbl IDirect3DExecuteBuffer_Vtbl =
841 {
842 IDirect3DExecuteBufferImpl_QueryInterface,
843 IDirect3DExecuteBufferImpl_AddRef,
844 IDirect3DExecuteBufferImpl_Release,
845 IDirect3DExecuteBufferImpl_Initialize,
846 IDirect3DExecuteBufferImpl_Lock,
847 IDirect3DExecuteBufferImpl_Unlock,
848 IDirect3DExecuteBufferImpl_SetExecuteData,
849 IDirect3DExecuteBufferImpl_GetExecuteData,
850 IDirect3DExecuteBufferImpl_Validate,
851 IDirect3DExecuteBufferImpl_Optimize,
852 };
Windows API implementation