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