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