?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ddraw: Use d3d buffers for executebuffer data.
[wine.git] / dlls / ddraw / executebuffer.c
blob5c53f2b9068e811c03dbec6338cba22b0cc9d0d5
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 library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include "ddraw_private.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
27
28 /*****************************************************************************
29 * _dump_executedata
30 * _dump_D3DEXECUTEBUFFERDESC
31 *
32 * Debug functions which write the executebuffer data to the console
33 *
34 *****************************************************************************/
35
36 static void _dump_executedata(const D3DEXECUTEDATA *lpData) {
37 TRACE("dwSize : %d\n", lpData->dwSize);
38 TRACE("Vertex Offset : %d Count : %d\n", lpData->dwVertexOffset, lpData->dwVertexCount);
39 TRACE("Instruction Offset : %d Length : %d\n", lpData->dwInstructionOffset, lpData->dwInstructionLength);
40 TRACE("HVertex Offset : %d\n", lpData->dwHVertexOffset);
41 }
42
43 static void _dump_D3DEXECUTEBUFFERDESC(const D3DEXECUTEBUFFERDESC *lpDesc) {
44 TRACE("dwSize : %d\n", lpDesc->dwSize);
45 TRACE("dwFlags : %x\n", lpDesc->dwFlags);
46 TRACE("dwCaps : %x\n", lpDesc->dwCaps);
47 TRACE("dwBufferSize : %d\n", lpDesc->dwBufferSize);
48 TRACE("lpData : %p\n", lpDesc->lpData);
49 }
50
51 static void transform_vertex(D3DTLVERTEX *dst, const D3DMATRIX *mat,
52 const D3DVIEWPORT *vp, float x, float y, float z)
53 {
54 dst->u1.sx = (x * mat->_11) + (y * mat->_21) + (z * mat->_31) + mat->_41;
55 dst->u2.sy = (x * mat->_12) + (y * mat->_22) + (z * mat->_32) + mat->_42;
56 dst->u3.sz = (x * mat->_13) + (y * mat->_23) + (z * mat->_33) + mat->_43;
57 dst->u4.rhw = (x * mat->_14) + (y * mat->_24) + (z * mat->_34) + mat->_44;
58
59 dst->u4.rhw = 1.0f / dst->u4.rhw;
60
61 dst->u1.sx = (dst->u1.sx * dst->u4.rhw + 1.0f) * vp->dwWidth * 0.5 + vp->dwX;
62 dst->u2.sy = (-dst->u2.sy * dst->u4.rhw + 1.0f) * vp->dwHeight * 0.5 + vp->dwY;
63 dst->u3.sz *= dst->u4.rhw;
64 }
65
66 HRESULT d3d_execute_buffer_execute(struct d3d_execute_buffer *buffer,
67 struct d3d_device *device, struct d3d_viewport *viewport)
68 {
69 DWORD vs = buffer->data.dwVertexOffset;
70 DWORD is = buffer->data.dwInstructionOffset;
71 char *instr = (char *)buffer->desc.lpData + is;
72 unsigned int i;
73 struct wined3d_map_desc map_desc;
74 struct wined3d_box box = {0};
75 HRESULT hr;
76
77 if (viewport->active_device != device)
78 {
79 WARN("Viewport %p active device is %p.\n",
80 viewport, viewport->active_device);
81 return DDERR_INVALIDPARAMS;
82 }
83
84 /* Activate the viewport */
85 viewport_activate(viewport, FALSE);
86
87 TRACE("ExecuteData :\n");
88 if (TRACE_ON(ddraw))
89 _dump_executedata(&(buffer->data));
90
91 for (;;)
92 {
93 D3DINSTRUCTION *current = (D3DINSTRUCTION *)instr;
94 BYTE size;
95 WORD count;
96
97 count = current->wCount;
98 size = current->bSize;
99 instr += sizeof(D3DINSTRUCTION);
100
101 switch (current->bOpcode) {
102 case D3DOP_POINT: {
103 WARN("POINT-s (%d)\n", count);
104 instr += count * size;
105 } break;
106
107 case D3DOP_LINE: {
108 WARN("LINE-s (%d)\n", count);
109 instr += count * size;
110 } break;
111
112 case D3DOP_TRIANGLE:
113 {
114 WORD *indices;
115 TRACE("TRIANGLE (%d)\n", count);
116
117 if (!count)
118 break;
119
120 if (buffer->index_size < count * 3)
121 {
122 struct wined3d_buffer *new_buffer;
123 unsigned int new_size = max(buffer->index_size * 2, count * 3);
124
125 hr = wined3d_buffer_create_ib(device->wined3d_device, new_size * sizeof(*indices),
126 WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY, WINED3D_POOL_DEFAULT,
127 NULL, &ddraw_null_wined3d_parent_ops, &new_buffer);
128 if (FAILED(hr))
129 return hr;
130
131 buffer->index_size = new_size;
132 if (buffer->index_buffer)
133 wined3d_buffer_decref(buffer->index_buffer);
134 buffer->index_buffer = new_buffer;
135 }
136
137 box.left = 0;
138 box.right = count * 3 * sizeof(*indices);
139 hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->index_buffer), 0,
140 &map_desc, &box, WINED3D_MAP_DISCARD);
141 if (FAILED(hr))
142 return hr;
143 indices = map_desc.data;
144
145 for (i = 0; i < count; ++i)
146 {
147 D3DTRIANGLE *ci = (D3DTRIANGLE *)instr;
148 TRACE(" v1: %d v2: %d v3: %d\n",ci->u1.v1, ci->u2.v2, ci->u3.v3);
149 TRACE(" Flags : ");
150 if (TRACE_ON(ddraw))
151 {
152 /* Wireframe */
153 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
154 TRACE("EDGEENABLE1 ");
155 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE2)
156 TRACE("EDGEENABLE2 ");
157 if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
158 TRACE("EDGEENABLE3 ");
159 /* Strips / Fans */
160 if (ci->wFlags == D3DTRIFLAG_EVEN)
161 TRACE("EVEN ");
162 if (ci->wFlags == D3DTRIFLAG_ODD)
163 TRACE("ODD ");
164 if (ci->wFlags == D3DTRIFLAG_START)
165 TRACE("START ");
166 if ((ci->wFlags > 0) && (ci->wFlags < 30))
167 TRACE("STARTFLAT(%u) ", ci->wFlags);
168 TRACE("\n");
169 }
170 indices[(i * 3) ] = ci->u1.v1;
171 indices[(i * 3) + 1] = ci->u2.v2;
172 indices[(i * 3) + 2] = ci->u3.v3;
173 instr += size;
174 }
175
176 wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->index_buffer), 0);
177
178 wined3d_device_set_stream_source(device->wined3d_device, 0,
179 buffer->dst_vertex_buffer, 0, sizeof(D3DTLVERTEX));
180 wined3d_device_set_vertex_declaration(device->wined3d_device,
181 ddraw_find_decl(device->ddraw, D3DFVF_TLVERTEX));
182 wined3d_device_set_index_buffer(device->wined3d_device, buffer->index_buffer, WINED3DFMT_R16_UINT, 0);
183 wined3d_device_set_primitive_type(device->wined3d_device, WINED3D_PT_TRIANGLELIST);
184 wined3d_device_draw_indexed_primitive(device->wined3d_device, 0, count * 3);
185 } break;
186
187 case D3DOP_MATRIXLOAD:
188 WARN("MATRIXLOAD-s (%d)\n", count);
189 instr += count * size;
190 break;
191
192 case D3DOP_MATRIXMULTIPLY:
193 TRACE("MATRIXMULTIPLY (%d)\n", count);
194 for (i = 0; i < count; ++i)
195 {
196 D3DMATRIXMULTIPLY *ci = (D3DMATRIXMULTIPLY *)instr;
197 D3DMATRIX *a, *b, *c;
198
199 a = ddraw_get_object(&device->handle_table, ci->hDestMatrix - 1, DDRAW_HANDLE_MATRIX);
200 b = ddraw_get_object(&device->handle_table, ci->hSrcMatrix1 - 1, DDRAW_HANDLE_MATRIX);
201 c = ddraw_get_object(&device->handle_table, ci->hSrcMatrix2 - 1, DDRAW_HANDLE_MATRIX);
202
203 if (!a || !b || !c)
204 {
205 ERR("Invalid matrix handle (a %#x -> %p, b %#x -> %p, c %#x -> %p).\n",
206 ci->hDestMatrix, a, ci->hSrcMatrix1, b, ci->hSrcMatrix2, c);
207 }
208 else
209 {
210 TRACE("dst %p, src1 %p, src2 %p.\n", a, b, c);
211 multiply_matrix(a, c, b);
212 }
213
214 instr += size;
215 }
216 break;
217
218 case D3DOP_STATETRANSFORM:
219 TRACE("STATETRANSFORM (%d)\n", count);
220 for (i = 0; i < count; ++i)
221 {
222 D3DSTATE *ci = (D3DSTATE *)instr;
223 D3DMATRIX *m;
224
225 m = ddraw_get_object(&device->handle_table, ci->u2.dwArg[0] - 1, DDRAW_HANDLE_MATRIX);
226 if (!m)
227 {
228 ERR("Invalid matrix handle %#x.\n", ci->u2.dwArg[0]);
229 }
230 else
231 {
232 if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_WORLD)
233 device->world = ci->u2.dwArg[0];
234 if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_VIEW)
235 device->view = ci->u2.dwArg[0];
236 if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_PROJECTION)
237 device->proj = ci->u2.dwArg[0];
238 IDirect3DDevice3_SetTransform(&device->IDirect3DDevice3_iface,
239 ci->u1.dtstTransformStateType, m);
240 }
241
242 instr += size;
243 }
244 break;
245
246 case D3DOP_STATELIGHT:
247 TRACE("STATELIGHT (%d)\n", count);
248 for (i = 0; i < count; ++i)
249 {
250 D3DSTATE *ci = (D3DSTATE *)instr;
251
252 if (FAILED(IDirect3DDevice3_SetLightState(&device->IDirect3DDevice3_iface,
253 ci->u1.dlstLightStateType, ci->u2.dwArg[0])))
254 WARN("Failed to set light state.\n");
255
256 instr += size;
257 }
258 break;
259
260 case D3DOP_STATERENDER:
261 TRACE("STATERENDER (%d)\n", count);
262 for (i = 0; i < count; ++i)
263 {
264 D3DSTATE *ci = (D3DSTATE *)instr;
265
266 if (FAILED(IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface,
267 ci->u1.drstRenderStateType, ci->u2.dwArg[0])))
268 WARN("Failed to set render state.\n");
269
270 instr += size;
271 }
272 break;
273
274 case D3DOP_PROCESSVERTICES:
275 {
276 /* TODO: Share code with d3d_vertex_buffer7_ProcessVertices()
277 * and / or wined3d_device_process_vertices(). */
278 D3DMATRIX view_mat, world_mat, proj_mat, mat;
279
280 TRACE("PROCESSVERTICES (%d)\n", count);
281
282 /* Note that the projection set in wined3d has the legacy clip space
283 * adjustment built in. */
284 wined3d_device_get_transform(device->wined3d_device,
285 D3DTRANSFORMSTATE_VIEW, (struct wined3d_matrix *)&view_mat);
286 wined3d_device_get_transform(device->wined3d_device,
287 D3DTRANSFORMSTATE_PROJECTION, (struct wined3d_matrix *)&proj_mat);
288 wined3d_device_get_transform(device->wined3d_device,
289 WINED3D_TS_WORLD_MATRIX(0), (struct wined3d_matrix *)&world_mat);
290
291 if (TRACE_ON(ddraw))
292 {
293 TRACE(" Projection Matrix:\n");
294 dump_D3DMATRIX(&proj_mat);
295 TRACE(" View Matrix:\n");
296 dump_D3DMATRIX(&view_mat);
297 TRACE(" World Matrix:\n");
298 dump_D3DMATRIX(&world_mat);
299 }
300
301 multiply_matrix(&mat, &view_mat, &world_mat);
302 multiply_matrix(&mat, &proj_mat, &mat);
303
304 for (i = 0; i < count; ++i)
305 {
306 D3DPROCESSVERTICES *ci = (D3DPROCESSVERTICES *)instr;
307 DWORD op = ci->dwFlags & D3DPROCESSVERTICES_OPMASK;
308 D3DTLVERTEX *src, *dst;
309
310 TRACE(" start %u, dest %u, count %u, flags %#x.\n",
311 ci->wStart, ci->wDest, ci->dwCount, ci->dwFlags);
312
313 if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
314 FIXME("D3DPROCESSVERTICES_UPDATEEXTENTS not implemented.\n");
315 if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
316 FIXME("D3DPROCESSVERTICES_NOCOLOR not implemented.\n");
317
318 switch (op)
319 {
320 case D3DPROCESSVERTICES_TRANSFORMLIGHT:
321 {
322 const D3DVERTEX *src = (D3DVERTEX *)((char *)buffer->desc.lpData + vs) + ci->wStart;
323 unsigned int vtx_idx;
324 static unsigned int once;
325
326 if (!once++)
327 FIXME("Lighting not implemented.\n");
328
329 box.left = ci->wDest * sizeof(*dst);
330 box.right = (ci->wDest + ci->dwCount) * sizeof(*dst);
331 hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->dst_vertex_buffer), 0,
332 &map_desc, &box, 0);
333 if (FAILED(hr))
334 return hr;
335 dst = map_desc.data;
336
337 for (vtx_idx = 0; vtx_idx < ci->dwCount; ++vtx_idx)
338 {
339 transform_vertex(&dst[vtx_idx], &mat, &viewport->viewports.vp1,
340 src[vtx_idx].u1.x, src[vtx_idx].u2.y, src[vtx_idx].u3.z);
341 /* No lighting yet */
342 dst[vtx_idx].u5.color = 0xffffffff; /* Opaque white */
343 dst[vtx_idx].u6.specular = 0xff000000; /* No specular and no fog factor */
344 dst[vtx_idx].u7.tu = src[vtx_idx].u7.tu;
345 dst[vtx_idx].u8.tv = src[vtx_idx].u8.tv;
346 }
347
348 wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->dst_vertex_buffer), 0);
349
350 break;
351 }
352
353 case D3DPROCESSVERTICES_TRANSFORM:
354 {
355 const D3DLVERTEX *src = (D3DLVERTEX *)((char *)buffer->desc.lpData + vs) + ci->wStart;
356 unsigned int vtx_idx;
357
358 box.left = ci->wDest * sizeof(*dst);
359 box.right = (ci->wDest + ci->dwCount) * sizeof(*dst);
360 hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->dst_vertex_buffer), 0,
361 &map_desc, &box, 0);
362 if (FAILED(hr))
363 return hr;
364 dst = map_desc.data;
365
366 for (vtx_idx = 0; vtx_idx < ci->dwCount; ++vtx_idx)
367 {
368 transform_vertex(&dst[vtx_idx], &mat, &viewport->viewports.vp1,
369 src[vtx_idx].u1.x, src[vtx_idx].u2.y, src[vtx_idx].u3.z);
370 dst[vtx_idx].u5.color = src[vtx_idx].u4.color;
371 dst[vtx_idx].u6.specular = src[vtx_idx].u5.specular;
372 dst[vtx_idx].u7.tu = src[vtx_idx].u6.tu;
373 dst[vtx_idx].u8.tv = src[vtx_idx].u7.tv;
374 }
375
376 wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->dst_vertex_buffer), 0);
377
378 break;
379 }
380
381 case D3DPROCESSVERTICES_COPY:
382 box.left = ci->wDest * sizeof(*src);
383 box.right = (ci->wDest + ci->dwCount) * sizeof(*src);
384 hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->dst_vertex_buffer), 0,
385 &map_desc, &box, 0);
386 if (FAILED(hr))
387 return hr;
388
389 src = (D3DTLVERTEX *)((char *)buffer->desc.lpData + vs) + ci->wStart;
390 memcpy(map_desc.data, src, ci->dwCount * sizeof(*src));
391
392 wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->dst_vertex_buffer), 0);
393 break;
394
395 default:
396 FIXME("Unhandled vertex processing op %#x.\n", op);
397 break;
398 }
399
400 instr += size;
401 }
402 break;
403 }
404
405 case D3DOP_TEXTURELOAD: {
406 WARN("TEXTURELOAD-s (%d)\n", count);
407
408 instr += count * size;
409 } break;
410
411 case D3DOP_EXIT: {
412 TRACE("EXIT (%d)\n", count);
413 /* We did this instruction */
414 instr += size;
415 /* Exit this loop */
416 goto end_of_buffer;
417 } break;
418
419 case D3DOP_BRANCHFORWARD:
420 TRACE("BRANCHFORWARD (%d)\n", count);
421 for (i = 0; i < count; ++i)
422 {
423 D3DBRANCH *ci = (D3DBRANCH *)instr;
424
425 if ((buffer->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue)
426 {
427 if (!ci->bNegate)
428 {
429 TRACE(" Branch to %d\n", ci->dwOffset);
430 if (ci->dwOffset) {
431 instr = (char*)current + ci->dwOffset;
432 break;
433 }
434 }
435 } else {
436 if (ci->bNegate) {
437 TRACE(" Branch to %d\n", ci->dwOffset);
438 if (ci->dwOffset) {
439 instr = (char*)current + ci->dwOffset;
440 break;
441 }
442 }
443 }
444
445 instr += size;
446 }
447 break;
448
449 case D3DOP_SPAN: {
450 WARN("SPAN-s (%d)\n", count);
451
452 instr += count * size;
453 } break;
454
455 case D3DOP_SETSTATUS:
456 TRACE("SETSTATUS (%d)\n", count);
457 for (i = 0; i < count; ++i)
458 {
459 buffer->data.dsStatus = *(D3DSTATUS *)instr;
460 instr += size;
461 }
462 break;
463
464 default:
465 ERR("Unhandled OpCode %d !!!\n",current->bOpcode);
466 /* Try to save ... */
467 instr += count * size;
468 break;
469 }
470 }
471
472 end_of_buffer:
473 return D3D_OK;
474 }
475
476 static inline struct d3d_execute_buffer *impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface)
477 {
478 return CONTAINING_RECORD(iface, struct d3d_execute_buffer, IDirect3DExecuteBuffer_iface);
479 }
480
481 static HRESULT WINAPI d3d_execute_buffer_QueryInterface(IDirect3DExecuteBuffer *iface, REFIID iid, void **out)
482 {
483 TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
484
485 if (IsEqualGUID(&IID_IDirect3DExecuteBuffer, iid)
486 || IsEqualGUID(&IID_IUnknown, iid))
487 {
488 IDirect3DExecuteBuffer_AddRef(iface);
489 *out = iface;
490 return S_OK;
491 }
492
493 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
494
495 *out = NULL;
496 return E_NOINTERFACE;
497 }
498
499 /*****************************************************************************
500 * IDirect3DExecuteBuffer::AddRef
501 *
502 * A normal AddRef method, nothing special
503 *
504 * Returns:
505 * The new refcount
506 *
507 *****************************************************************************/
508 static ULONG WINAPI d3d_execute_buffer_AddRef(IDirect3DExecuteBuffer *iface)
509 {
510 struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
511 ULONG ref = InterlockedIncrement(&buffer->ref);
512
513 TRACE("%p increasing refcount to %u.\n", buffer, ref);
514
515 return ref;
516 }
517
518 /*****************************************************************************
519 * IDirect3DExecuteBuffer::Release
520 *
521 * A normal Release method, nothing special
522 *
523 * Returns:
524 * The new refcount
525 *
526 *****************************************************************************/
527 static ULONG WINAPI d3d_execute_buffer_Release(IDirect3DExecuteBuffer *iface)
528 {
529 struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
530 ULONG ref = InterlockedDecrement(&buffer->ref);
531
532 TRACE("%p decreasing refcount to %u.\n", buffer, ref);
533
534 if (!ref)
535 {
536 if (buffer->need_free)
537 HeapFree(GetProcessHeap(), 0, buffer->desc.lpData);
538 if (buffer->index_buffer)
539 wined3d_buffer_decref(buffer->index_buffer);
540 if (buffer->dst_vertex_buffer)
541 wined3d_buffer_decref(buffer->dst_vertex_buffer);
542 HeapFree(GetProcessHeap(), 0, buffer);
543 }
544
545 return ref;
546 }
547
548 /*****************************************************************************
549 * IDirect3DExecuteBuffer::Initialize
550 *
551 * Initializes the Execute Buffer. This method exists for COM compliance
552 * Nothing to do here.
553 *
554 * Returns:
555 * D3D_OK
556 *
557 *****************************************************************************/
558 static HRESULT WINAPI d3d_execute_buffer_Initialize(IDirect3DExecuteBuffer *iface,
559 IDirect3DDevice *device, D3DEXECUTEBUFFERDESC *desc)
560 {
561 TRACE("iface %p, device %p, desc %p.\n", iface, device, desc);
562
563 return D3D_OK;
564 }
565
566 /*****************************************************************************
567 * IDirect3DExecuteBuffer::Lock
568 *
569 * Locks the buffer, so the app can write into it.
570 *
571 * Params:
572 * Desc: Pointer to return the buffer description. This Description contains
573 * a pointer to the buffer data.
574 *
575 * Returns:
576 * This implementation always returns D3D_OK
577 *
578 *****************************************************************************/
579 static HRESULT WINAPI d3d_execute_buffer_Lock(IDirect3DExecuteBuffer *iface, D3DEXECUTEBUFFERDESC *desc)
580 {
581 struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
582 DWORD dwSize;
583
584 TRACE("iface %p, desc %p.\n", iface, desc);
585
586 dwSize = desc->dwSize;
587 memcpy(desc, &buffer->desc, dwSize);
588
589 if (TRACE_ON(ddraw))
590 {
591 TRACE(" Returning description :\n");
592 _dump_D3DEXECUTEBUFFERDESC(desc);
593 }
594 return D3D_OK;
595 }
596
597 /*****************************************************************************
598 * IDirect3DExecuteBuffer::Unlock
599 *
600 * Unlocks the buffer. We don't have anything to do here
601 *
602 * Returns:
603 * This implementation always returns D3D_OK
604 *
605 *****************************************************************************/
606 static HRESULT WINAPI d3d_execute_buffer_Unlock(IDirect3DExecuteBuffer *iface)
607 {
608 TRACE("iface %p.\n", iface);
609
610 return D3D_OK;
611 }
612
613 /*****************************************************************************
614 * IDirect3DExecuteBuffer::SetExecuteData
615 *
616 * Sets the execute data. This data is used to describe the buffer's content
617 *
618 * Params:
619 * Data: Pointer to a D3DEXECUTEDATA structure containing the data to
620 * assign
621 *
622 * Returns:
623 * D3D_OK on success
624 * DDERR_OUTOFMEMORY if the vertex buffer allocation failed
625 *
626 *****************************************************************************/
627 static HRESULT WINAPI d3d_execute_buffer_SetExecuteData(IDirect3DExecuteBuffer *iface, D3DEXECUTEDATA *data)
628 {
629 struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
630
631 TRACE("iface %p, data %p.\n", iface, data);
632
633 memcpy(&buffer->data, data, data->dwSize);
634
635 if (buffer->vertex_size < data->dwVertexCount)
636 {
637 HRESULT hr;
638 unsigned int new_size = max(data->dwVertexCount, buffer->vertex_size * 2);
639 struct wined3d_buffer *dst_buffer;
640
641 hr = wined3d_buffer_create_vb(buffer->d3ddev->wined3d_device, new_size * sizeof(D3DTLVERTEX),
642 WINED3DUSAGE_STATICDECL, WINED3D_POOL_DEFAULT,
643 NULL, &ddraw_null_wined3d_parent_ops, &dst_buffer);
644 if (FAILED(hr))
645 return hr;
646
647 if (buffer->dst_vertex_buffer)
648 wined3d_buffer_decref(buffer->dst_vertex_buffer);
649 buffer->dst_vertex_buffer = dst_buffer;
650 buffer->vertex_size = new_size;
651 }
652
653 if (TRACE_ON(ddraw))
654 _dump_executedata(data);
655
656 return D3D_OK;
657 }
658
659 /*****************************************************************************
660 * IDirect3DExecuteBuffer::GetExecuteData
661 *
662 * Returns the data in the execute buffer
663 *
664 * Params:
665 * Data: Pointer to a D3DEXECUTEDATA structure used to return data
666 *
667 * Returns:
668 * D3D_OK on success
669 *
670 *****************************************************************************/
671 static HRESULT WINAPI d3d_execute_buffer_GetExecuteData(IDirect3DExecuteBuffer *iface, D3DEXECUTEDATA *data)
672 {
673 struct d3d_execute_buffer *buffer = impl_from_IDirect3DExecuteBuffer(iface);
674 DWORD dwSize;
675
676 TRACE("iface %p, data %p.\n", iface, data);
677
678 dwSize = data->dwSize;
679 memcpy(data, &buffer->data, dwSize);
680
681 if (TRACE_ON(ddraw))
682 {
683 TRACE("Returning data :\n");
684 _dump_executedata(data);
685 }
686
687 return DD_OK;
688 }
689
690 /*****************************************************************************
691 * IDirect3DExecuteBuffer::Validate
692 *
693 * DirectX 5 SDK: "The IDirect3DExecuteBuffer::Validate method is not
694 * currently implemented"
695 *
696 * Params:
697 * ?
698 *
699 * Returns:
700 * DDERR_UNSUPPORTED, because it's not implemented in Windows.
701 *
702 *****************************************************************************/
703 static HRESULT WINAPI d3d_execute_buffer_Validate(IDirect3DExecuteBuffer *iface,
704 DWORD *offset, LPD3DVALIDATECALLBACK callback, void *context, DWORD reserved)
705 {
706 TRACE("iface %p, offset %p, callback %p, context %p, reserved %#x.\n",
707 iface, offset, callback, context, reserved);
708
709 WARN("Not implemented.\n");
710
711 return DDERR_UNSUPPORTED; /* Unchecked */
712 }
713
714 /*****************************************************************************
715 * IDirect3DExecuteBuffer::Optimize
716 *
717 * DirectX5 SDK: "The IDirect3DExecuteBuffer::Optimize method is not
718 * currently supported"
719 *
720 * Params:
721 * Dummy: Seems to be an unused dummy ;)
722 *
723 * Returns:
724 * DDERR_UNSUPPORTED, because it's not implemented in Windows.
725 *
726 *****************************************************************************/
727 static HRESULT WINAPI d3d_execute_buffer_Optimize(IDirect3DExecuteBuffer *iface, DWORD reserved)
728 {
729 TRACE("iface %p, reserved %#x.\n", iface, reserved);
730
731 WARN("Not implemented.\n");
732
733 return DDERR_UNSUPPORTED; /* Unchecked */
734 }
735
736 static const struct IDirect3DExecuteBufferVtbl d3d_execute_buffer_vtbl =
737 {
738 d3d_execute_buffer_QueryInterface,
739 d3d_execute_buffer_AddRef,
740 d3d_execute_buffer_Release,
741 d3d_execute_buffer_Initialize,
742 d3d_execute_buffer_Lock,
743 d3d_execute_buffer_Unlock,
744 d3d_execute_buffer_SetExecuteData,
745 d3d_execute_buffer_GetExecuteData,
746 d3d_execute_buffer_Validate,
747 d3d_execute_buffer_Optimize,
748 };
749
750 HRESULT d3d_execute_buffer_init(struct d3d_execute_buffer *execute_buffer,
751 struct d3d_device *device, D3DEXECUTEBUFFERDESC *desc)
752 {
753 execute_buffer->IDirect3DExecuteBuffer_iface.lpVtbl = &d3d_execute_buffer_vtbl;
754 execute_buffer->ref = 1;
755 execute_buffer->d3ddev = device;
756
757 /* Initializes memory */
758 memcpy(&execute_buffer->desc, desc, desc->dwSize);
759
760 /* No buffer given */
761 if (!(execute_buffer->desc.dwFlags & D3DDEB_LPDATA))
762 execute_buffer->desc.lpData = NULL;
763
764 /* No buffer size given */
765 if (!(execute_buffer->desc.dwFlags & D3DDEB_BUFSIZE))
766 execute_buffer->desc.dwBufferSize = 0;
767
768 /* Create buffer if asked */
769 if (!execute_buffer->desc.lpData && execute_buffer->desc.dwBufferSize)
770 {
771 execute_buffer->need_free = TRUE;
772 execute_buffer->desc.lpData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, execute_buffer->desc.dwBufferSize);
773 if (!execute_buffer->desc.lpData)
774 {
775 ERR("Failed to allocate execute buffer data.\n");
776 return DDERR_OUTOFMEMORY;
777 }
778 }
779
780 execute_buffer->desc.dwFlags |= D3DDEB_LPDATA;
781
782 return D3D_OK;
783 }
784
785 struct d3d_execute_buffer *unsafe_impl_from_IDirect3DExecuteBuffer(IDirect3DExecuteBuffer *iface)
786 {
787 if (!iface)
788 return NULL;
789 assert(iface->lpVtbl == &d3d_execute_buffer_vtbl);
790
791 return impl_from_IDirect3DExecuteBuffer(iface);
792 }
Windows API implementation