?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3drm: Use existing helper to manage child frames array.
[wine.git] / dlls / d3drm / frame.c
blobffe75060dbe0619fb4adbe330ae5fc87c8d36304
1 /*
2 * Implementation of IDirect3DRMFrame Interface
3 *
4 * Copyright 2011, 2012 André Hentschel
5 * Copyright 2012 Christian Costa
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include "d3drm_private.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
28
29 static D3DRMMATRIX4D identity = {
30 { 1.0f, 0.0f, 0.0f, 0.0f },
31 { 0.0f, 1.0f, 0.0f, 0.0f },
32 { 0.0f, 0.0f, 1.0f, 0.0f },
33 { 0.0f, 0.0f, 0.0f, 1.0f }
34 };
35
36 struct d3drm_frame_array
37 {
38 IDirect3DRMFrameArray IDirect3DRMFrameArray_iface;
39 LONG ref;
40 ULONG size;
41 IDirect3DRMFrame **frames;
42 };
43
44 struct d3drm_visual_array
45 {
46 IDirect3DRMVisualArray IDirect3DRMVisualArray_iface;
47 LONG ref;
48 ULONG size;
49 IDirect3DRMVisual **visuals;
50 };
51
52 struct d3drm_light_array
53 {
54 IDirect3DRMLightArray IDirect3DRMLightArray_iface;
55 LONG ref;
56 ULONG size;
57 IDirect3DRMLight **lights;
58 };
59
60 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame(IDirect3DRMFrame *iface)
61 {
62 return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame_iface);
63 }
64
65 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
66 {
67 return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame2_iface);
68 }
69
70 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
71 {
72 return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame3_iface);
73 }
74
75 static inline struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface);
76
77 static inline struct d3drm_frame_array *impl_from_IDirect3DRMFrameArray(IDirect3DRMFrameArray *iface)
78 {
79 return CONTAINING_RECORD(iface, struct d3drm_frame_array, IDirect3DRMFrameArray_iface);
80 }
81
82 static inline struct d3drm_visual_array *impl_from_IDirect3DRMVisualArray(IDirect3DRMVisualArray *iface)
83 {
84 return CONTAINING_RECORD(iface, struct d3drm_visual_array, IDirect3DRMVisualArray_iface);
85 }
86
87 static inline struct d3drm_light_array *impl_from_IDirect3DRMLightArray(IDirect3DRMLightArray *iface)
88 {
89 return CONTAINING_RECORD(iface, struct d3drm_light_array, IDirect3DRMLightArray_iface);
90 }
91
92 static inline struct d3drm_animation *impl_from_IDirect3DRMAnimation(IDirect3DRMAnimation *iface)
93 {
94 return CONTAINING_RECORD(iface, struct d3drm_animation, IDirect3DRMAnimation_iface);
95 }
96
97 static inline struct d3drm_animation *impl_from_IDirect3DRMAnimation2(IDirect3DRMAnimation2 *iface)
98 {
99 return CONTAINING_RECORD(iface, struct d3drm_animation, IDirect3DRMAnimation2_iface);
100 }
101
102 static HRESULT WINAPI d3drm_frame_array_QueryInterface(IDirect3DRMFrameArray *iface, REFIID riid, void **out)
103 {
104 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
105
106 if (IsEqualGUID(riid, &IID_IDirect3DRMFrameArray)
107 || IsEqualGUID(riid, &IID_IUnknown))
108 {
109 IDirect3DRMFrameArray_AddRef(iface);
110 *out = iface;
111 return S_OK;
112 }
113
114 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
115
116 *out = NULL;
117 return E_NOINTERFACE;
118 }
119
120 static ULONG WINAPI d3drm_frame_array_AddRef(IDirect3DRMFrameArray *iface)
121 {
122 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
123 ULONG refcount = InterlockedIncrement(&array->ref);
124
125 TRACE("%p increasing refcount to %u.\n", iface, refcount);
126
127 return refcount;
128 }
129
130 static ULONG WINAPI d3drm_frame_array_Release(IDirect3DRMFrameArray *iface)
131 {
132 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
133 ULONG refcount = InterlockedDecrement(&array->ref);
134 ULONG i;
135
136 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
137
138 if (!refcount)
139 {
140 for (i = 0; i < array->size; ++i)
141 {
142 IDirect3DRMFrame_Release(array->frames[i]);
143 }
144 HeapFree(GetProcessHeap(), 0, array->frames);
145 HeapFree(GetProcessHeap(), 0, array);
146 }
147
148 return refcount;
149 }
150
151 static DWORD WINAPI d3drm_frame_array_GetSize(IDirect3DRMFrameArray *iface)
152 {
153 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
154
155 TRACE("iface %p.\n", iface);
156
157 return array->size;
158 }
159
160 static HRESULT WINAPI d3drm_frame_array_GetElement(IDirect3DRMFrameArray *iface,
161 DWORD index, IDirect3DRMFrame **frame)
162 {
163 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
164
165 TRACE("iface %p, index %u, frame %p.\n", iface, index, frame);
166
167 if (!frame)
168 return D3DRMERR_BADVALUE;
169
170 if (index >= array->size)
171 {
172 *frame = NULL;
173 return D3DRMERR_BADVALUE;
174 }
175
176 IDirect3DRMFrame_AddRef(array->frames[index]);
177 *frame = array->frames[index];
178
179 return D3DRM_OK;
180 }
181
182 static const struct IDirect3DRMFrameArrayVtbl d3drm_frame_array_vtbl =
183 {
184 d3drm_frame_array_QueryInterface,
185 d3drm_frame_array_AddRef,
186 d3drm_frame_array_Release,
187 d3drm_frame_array_GetSize,
188 d3drm_frame_array_GetElement,
189 };
190
191 static struct d3drm_frame_array *d3drm_frame_array_create(unsigned int frame_count, IDirect3DRMFrame3 **frames)
192 {
193 struct d3drm_frame_array *array;
194 unsigned int i;
195
196 if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
197 return NULL;
198
199 array->IDirect3DRMFrameArray_iface.lpVtbl = &d3drm_frame_array_vtbl;
200 array->ref = 1;
201 array->size = frame_count;
202
203 if (frame_count)
204 {
205 if (!(array->frames = HeapAlloc(GetProcessHeap(), 0, frame_count * sizeof(*array->frames))))
206 {
207 HeapFree(GetProcessHeap(), 0, array);
208 return NULL;
209 }
210
211 for (i = 0; i < frame_count; ++i)
212 {
213 IDirect3DRMFrame3_QueryInterface(frames[i], &IID_IDirect3DRMFrame, (void **)&array->frames[i]);
214 }
215 }
216
217 return array;
218 }
219
220 static HRESULT WINAPI d3drm_visual_array_QueryInterface(IDirect3DRMVisualArray *iface, REFIID riid, void **out)
221 {
222 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
223
224 if (IsEqualGUID(riid, &IID_IDirect3DRMVisualArray)
225 || IsEqualGUID(riid, &IID_IUnknown))
226 {
227 IDirect3DRMVisualArray_AddRef(iface);
228 *out = iface;
229 return S_OK;
230 }
231
232 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
233
234 *out = NULL;
235 return E_NOINTERFACE;
236 }
237
238 static ULONG WINAPI d3drm_visual_array_AddRef(IDirect3DRMVisualArray *iface)
239 {
240 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
241 ULONG refcount = InterlockedIncrement(&array->ref);
242
243 TRACE("%p increasing refcount to %u.\n", iface, refcount);
244
245 return refcount;
246 }
247
248 static ULONG WINAPI d3drm_visual_array_Release(IDirect3DRMVisualArray *iface)
249 {
250 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
251 ULONG refcount = InterlockedDecrement(&array->ref);
252 ULONG i;
253
254 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
255
256 if (!refcount)
257 {
258 for (i = 0; i < array->size; ++i)
259 {
260 IDirect3DRMVisual_Release(array->visuals[i]);
261 }
262 HeapFree(GetProcessHeap(), 0, array->visuals);
263 HeapFree(GetProcessHeap(), 0, array);
264 }
265
266 return refcount;
267 }
268
269 static DWORD WINAPI d3drm_visual_array_GetSize(IDirect3DRMVisualArray *iface)
270 {
271 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
272
273 TRACE("iface %p.\n", iface);
274
275 return array->size;
276 }
277
278 static HRESULT WINAPI d3drm_visual_array_GetElement(IDirect3DRMVisualArray *iface,
279 DWORD index, IDirect3DRMVisual **visual)
280 {
281 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
282
283 TRACE("iface %p, index %u, visual %p.\n", iface, index, visual);
284
285 if (!visual)
286 return D3DRMERR_BADVALUE;
287
288 if (index >= array->size)
289 {
290 *visual = NULL;
291 return D3DRMERR_BADVALUE;
292 }
293
294 IDirect3DRMVisual_AddRef(array->visuals[index]);
295 *visual = array->visuals[index];
296
297 return D3DRM_OK;
298 }
299
300 static const struct IDirect3DRMVisualArrayVtbl d3drm_visual_array_vtbl =
301 {
302 d3drm_visual_array_QueryInterface,
303 d3drm_visual_array_AddRef,
304 d3drm_visual_array_Release,
305 d3drm_visual_array_GetSize,
306 d3drm_visual_array_GetElement,
307 };
308
309 static struct d3drm_visual_array *d3drm_visual_array_create(unsigned int visual_count, IDirect3DRMVisual **visuals)
310 {
311 struct d3drm_visual_array *array;
312 unsigned int i;
313
314 if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
315 return NULL;
316
317 array->IDirect3DRMVisualArray_iface.lpVtbl = &d3drm_visual_array_vtbl;
318 array->ref = 1;
319 array->size = visual_count;
320
321 if (visual_count)
322 {
323 if (!(array->visuals = HeapAlloc(GetProcessHeap(), 0, visual_count * sizeof(*array->visuals))))
324 {
325 HeapFree(GetProcessHeap(), 0, array);
326 return NULL;
327 }
328
329 for (i = 0; i < visual_count; ++i)
330 {
331 array->visuals[i] = visuals[i];
332 IDirect3DRMVisual_AddRef(array->visuals[i]);
333 }
334 }
335
336 return array;
337 }
338
339 static HRESULT WINAPI d3drm_light_array_QueryInterface(IDirect3DRMLightArray *iface, REFIID riid, void **out)
340 {
341 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
342
343 if (IsEqualGUID(riid, &IID_IDirect3DRMLightArray)
344 || IsEqualGUID(riid, &IID_IUnknown))
345 {
346 IDirect3DRMLightArray_AddRef(iface);
347 *out = iface;
348 return S_OK;
349 }
350
351 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
352
353 *out = NULL;
354 return E_NOINTERFACE;
355 }
356
357 static ULONG WINAPI d3drm_light_array_AddRef(IDirect3DRMLightArray *iface)
358 {
359 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
360 ULONG refcount = InterlockedIncrement(&array->ref);
361
362 TRACE("%p increasing refcount to %u.\n", iface, refcount);
363
364 return refcount;
365 }
366
367 static ULONG WINAPI d3drm_light_array_Release(IDirect3DRMLightArray *iface)
368 {
369 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
370 ULONG refcount = InterlockedDecrement(&array->ref);
371 ULONG i;
372
373 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
374
375 if (!refcount)
376 {
377 for (i = 0; i < array->size; ++i)
378 {
379 IDirect3DRMLight_Release(array->lights[i]);
380 }
381 HeapFree(GetProcessHeap(), 0, array->lights);
382 HeapFree(GetProcessHeap(), 0, array);
383 }
384
385 return refcount;
386 }
387
388 static DWORD WINAPI d3drm_light_array_GetSize(IDirect3DRMLightArray *iface)
389 {
390 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
391
392 TRACE("iface %p.\n", iface);
393
394 return array->size;
395 }
396
397 static HRESULT WINAPI d3drm_light_array_GetElement(IDirect3DRMLightArray *iface,
398 DWORD index, IDirect3DRMLight **light)
399 {
400 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
401
402 TRACE("iface %p, index %u, light %p.\n", iface, index, light);
403
404 if (!light)
405 return D3DRMERR_BADVALUE;
406
407 if (index >= array->size)
408 {
409 *light = NULL;
410 return D3DRMERR_BADVALUE;
411 }
412
413 IDirect3DRMLight_AddRef(array->lights[index]);
414 *light = array->lights[index];
415
416 return D3DRM_OK;
417 }
418
419 static const struct IDirect3DRMLightArrayVtbl d3drm_light_array_vtbl =
420 {
421 d3drm_light_array_QueryInterface,
422 d3drm_light_array_AddRef,
423 d3drm_light_array_Release,
424 d3drm_light_array_GetSize,
425 d3drm_light_array_GetElement,
426 };
427
428 static struct d3drm_light_array *d3drm_light_array_create(unsigned int light_count, IDirect3DRMLight **lights)
429 {
430 struct d3drm_light_array *array;
431 unsigned int i;
432
433 if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
434 return NULL;
435
436 array->IDirect3DRMLightArray_iface.lpVtbl = &d3drm_light_array_vtbl;
437 array->ref = 1;
438 array->size = light_count;
439
440 if (light_count)
441 {
442 if (!(array->lights = HeapAlloc(GetProcessHeap(), 0, light_count * sizeof(*array->lights))))
443 {
444 HeapFree(GetProcessHeap(), 0, array);
445 return NULL;
446 }
447
448 for (i = 0; i < light_count; ++i)
449 {
450 array->lights[i] = lights[i];
451 IDirect3DRMLight_AddRef(array->lights[i]);
452 }
453 }
454
455 return array;
456 }
457
458 static HRESULT WINAPI d3drm_frame3_QueryInterface(IDirect3DRMFrame3 *iface, REFIID riid, void **out)
459 {
460 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
461
462 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
463
464 if (IsEqualGUID(riid, &IID_IDirect3DRMFrame)
465 || IsEqualGUID(riid, &IID_IDirect3DRMObject)
466 || IsEqualGUID(riid, &IID_IDirect3DRMVisual)
467 || IsEqualGUID(riid, &IID_IUnknown))
468 {
469 *out = &frame->IDirect3DRMFrame_iface;
470 }
471 else if (IsEqualGUID(riid, &IID_IDirect3DRMFrame2))
472 {
473 *out = &frame->IDirect3DRMFrame2_iface;
474 }
475 else if (IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
476 {
477 *out = &frame->IDirect3DRMFrame3_iface;
478 }
479 else
480 {
481 *out = NULL;
482 WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
483 return CLASS_E_CLASSNOTAVAILABLE;
484 }
485
486 IUnknown_AddRef((IUnknown *)*out);
487 return S_OK;
488 }
489
490 static HRESULT WINAPI d3drm_frame2_QueryInterface(IDirect3DRMFrame2 *iface, REFIID riid, void **out)
491 {
492 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
493
494 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
495
496 return d3drm_frame3_QueryInterface(&frame->IDirect3DRMFrame3_iface, riid, out);
497 }
498
499 static HRESULT WINAPI d3drm_frame1_QueryInterface(IDirect3DRMFrame *iface, REFIID riid, void **out)
500 {
501 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
502
503 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
504
505 return d3drm_frame3_QueryInterface(&frame->IDirect3DRMFrame3_iface, riid, out);
506 }
507
508 static ULONG WINAPI d3drm_frame3_AddRef(IDirect3DRMFrame3 *iface)
509 {
510 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
511 ULONG refcount = InterlockedIncrement(&frame->ref);
512
513 TRACE("%p increasing refcount to %u.\n", iface, refcount);
514
515 return refcount;
516 }
517
518 static ULONG WINAPI d3drm_frame2_AddRef(IDirect3DRMFrame2 *iface)
519 {
520 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
521
522 TRACE("iface %p.\n", iface);
523
524 return d3drm_frame3_AddRef(&frame->IDirect3DRMFrame3_iface);
525 }
526
527 static ULONG WINAPI d3drm_frame1_AddRef(IDirect3DRMFrame *iface)
528 {
529 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
530
531 TRACE("iface %p.\n", iface);
532
533 return d3drm_frame3_AddRef(&frame->IDirect3DRMFrame3_iface);
534 }
535
536 static ULONG WINAPI d3drm_frame3_Release(IDirect3DRMFrame3 *iface)
537 {
538 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
539 ULONG refcount = InterlockedDecrement(&frame->ref);
540 ULONG i;
541
542 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
543
544 if (!refcount)
545 {
546 d3drm_object_cleanup((IDirect3DRMObject *)&frame->IDirect3DRMFrame_iface, &frame->obj);
547 for (i = 0; i < frame->nb_children; ++i)
548 {
549 IDirect3DRMFrame3_Release(frame->children[i]);
550 }
551 HeapFree(GetProcessHeap(), 0, frame->children);
552 for (i = 0; i < frame->nb_visuals; ++i)
553 {
554 IDirect3DRMVisual_Release(frame->visuals[i]);
555 }
556 HeapFree(GetProcessHeap(), 0, frame->visuals);
557 for (i = 0; i < frame->nb_lights; ++i)
558 {
559 IDirect3DRMLight_Release(frame->lights[i]);
560 }
561 HeapFree(GetProcessHeap(), 0, frame->lights);
562 IDirect3DRM_Release(frame->d3drm);
563 HeapFree(GetProcessHeap(), 0, frame);
564 }
565
566 return refcount;
567 }
568
569 static ULONG WINAPI d3drm_frame2_Release(IDirect3DRMFrame2 *iface)
570 {
571 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
572
573 TRACE("iface %p.\n", iface);
574
575 return d3drm_frame3_Release(&frame->IDirect3DRMFrame3_iface);
576 }
577
578 static ULONG WINAPI d3drm_frame1_Release(IDirect3DRMFrame *iface)
579 {
580 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
581
582 TRACE("iface %p.\n", iface);
583
584 return d3drm_frame3_Release(&frame->IDirect3DRMFrame3_iface);
585 }
586
587 static HRESULT WINAPI d3drm_frame3_Clone(IDirect3DRMFrame3 *iface,
588 IUnknown *outer, REFIID iid, void **out)
589 {
590 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
591
592 return E_NOTIMPL;
593 }
594
595 static HRESULT WINAPI d3drm_frame2_Clone(IDirect3DRMFrame2 *iface,
596 IUnknown *outer, REFIID iid, void **out)
597 {
598 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
599
600 return E_NOTIMPL;
601 }
602
603 static HRESULT WINAPI d3drm_frame1_Clone(IDirect3DRMFrame *iface,
604 IUnknown *outer, REFIID iid, void **out)
605 {
606 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
607
608 return E_NOTIMPL;
609 }
610
611 static HRESULT WINAPI d3drm_frame3_AddDestroyCallback(IDirect3DRMFrame3 *iface,
612 D3DRMOBJECTCALLBACK cb, void *ctx)
613 {
614 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
615
616 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
617
618 return d3drm_object_add_destroy_callback(&frame->obj, cb, ctx);
619 }
620
621 static HRESULT WINAPI d3drm_frame2_AddDestroyCallback(IDirect3DRMFrame2 *iface,
622 D3DRMOBJECTCALLBACK cb, void *ctx)
623 {
624 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
625
626 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
627
628 return IDirect3DRMFrame3_AddDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
629 }
630
631 static HRESULT WINAPI d3drm_frame1_AddDestroyCallback(IDirect3DRMFrame *iface,
632 D3DRMOBJECTCALLBACK cb, void *ctx)
633 {
634 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
635
636 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
637
638 return IDirect3DRMFrame3_AddDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
639 }
640
641 static HRESULT WINAPI d3drm_frame3_DeleteDestroyCallback(IDirect3DRMFrame3 *iface,
642 D3DRMOBJECTCALLBACK cb, void *ctx)
643 {
644 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
645
646 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
647
648 return d3drm_object_delete_destroy_callback(&frame->obj, cb, ctx);
649 }
650
651 static HRESULT WINAPI d3drm_frame2_DeleteDestroyCallback(IDirect3DRMFrame2 *iface,
652 D3DRMOBJECTCALLBACK cb, void *ctx)
653 {
654 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
655
656 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
657
658 return IDirect3DRMFrame3_DeleteDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
659 }
660
661 static HRESULT WINAPI d3drm_frame1_DeleteDestroyCallback(IDirect3DRMFrame *iface,
662 D3DRMOBJECTCALLBACK cb, void *ctx)
663 {
664 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
665
666 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
667
668 return IDirect3DRMFrame3_DeleteDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
669 }
670
671 static HRESULT WINAPI d3drm_frame3_SetAppData(IDirect3DRMFrame3 *iface, DWORD data)
672 {
673 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
674
675 TRACE("iface %p, data %#x.\n", iface, data);
676
677 frame->obj.appdata = data;
678
679 return D3DRM_OK;
680 }
681
682 static HRESULT WINAPI d3drm_frame2_SetAppData(IDirect3DRMFrame2 *iface, DWORD data)
683 {
684 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
685
686 TRACE("iface %p, data %#x.\n", iface, data);
687
688 return d3drm_frame3_SetAppData(&frame->IDirect3DRMFrame3_iface, data);
689 }
690
691 static HRESULT WINAPI d3drm_frame1_SetAppData(IDirect3DRMFrame *iface, DWORD data)
692 {
693 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
694
695 TRACE("iface %p, data %#x.\n", iface, data);
696
697 return d3drm_frame3_SetAppData(&frame->IDirect3DRMFrame3_iface, data);
698 }
699
700 static DWORD WINAPI d3drm_frame3_GetAppData(IDirect3DRMFrame3 *iface)
701 {
702 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
703
704 TRACE("iface %p.\n", iface);
705
706 return frame->obj.appdata;
707 }
708
709 static DWORD WINAPI d3drm_frame2_GetAppData(IDirect3DRMFrame2 *iface)
710 {
711 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
712
713 TRACE("iface %p.\n", iface);
714
715 return d3drm_frame3_GetAppData(&frame->IDirect3DRMFrame3_iface);
716 }
717
718 static DWORD WINAPI d3drm_frame1_GetAppData(IDirect3DRMFrame *iface)
719 {
720 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
721
722 TRACE("iface %p.\n", iface);
723
724 return d3drm_frame3_GetAppData(&frame->IDirect3DRMFrame3_iface);
725 }
726
727 static HRESULT WINAPI d3drm_frame3_SetName(IDirect3DRMFrame3 *iface, const char *name)
728 {
729 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
730
731 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
732
733 return d3drm_object_set_name(&frame->obj, name);
734 }
735
736 static HRESULT WINAPI d3drm_frame2_SetName(IDirect3DRMFrame2 *iface, const char *name)
737 {
738 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
739
740 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
741
742 return d3drm_frame3_SetName(&frame->IDirect3DRMFrame3_iface, name);
743 }
744
745 static HRESULT WINAPI d3drm_frame1_SetName(IDirect3DRMFrame *iface, const char *name)
746 {
747 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
748
749 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
750
751 return d3drm_frame3_SetName(&frame->IDirect3DRMFrame3_iface, name);
752 }
753
754 static HRESULT WINAPI d3drm_frame3_GetName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
755 {
756 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
757
758 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
759
760 return d3drm_object_get_name(&frame->obj, size, name);
761 }
762
763 static HRESULT WINAPI d3drm_frame2_GetName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
764 {
765 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
766
767 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
768
769 return d3drm_frame3_GetName(&frame->IDirect3DRMFrame3_iface, size, name);
770 }
771
772 static HRESULT WINAPI d3drm_frame1_GetName(IDirect3DRMFrame *iface, DWORD *size, char *name)
773 {
774 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
775
776 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
777
778 return d3drm_frame3_GetName(&frame->IDirect3DRMFrame3_iface, size, name);
779 }
780
781 static HRESULT WINAPI d3drm_frame3_GetClassName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
782 {
783 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
784
785 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
786
787 return d3drm_object_get_class_name(&frame->obj, size, name);
788 }
789
790 static HRESULT WINAPI d3drm_frame2_GetClassName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
791 {
792 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
793
794 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
795
796 return d3drm_frame3_GetClassName(&frame->IDirect3DRMFrame3_iface, size, name);
797 }
798
799 static HRESULT WINAPI d3drm_frame1_GetClassName(IDirect3DRMFrame *iface, DWORD *size, char *name)
800 {
801 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
802
803 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
804
805 return d3drm_frame3_GetClassName(&frame->IDirect3DRMFrame3_iface, size, name);
806 }
807
808 static HRESULT WINAPI d3drm_frame3_AddChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
809 {
810 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
811 struct d3drm_frame *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
812
813 TRACE("iface %p, child %p.\n", iface, child);
814
815 if (!child_obj)
816 return D3DRMERR_BADOBJECT;
817
818 if (child_obj->parent)
819 {
820 IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
821
822 if (parent == iface)
823 {
824 /* Passed frame is already a child so return success */
825 return D3DRM_OK;
826 }
827 else
828 {
829 /* Remove parent and continue */
830 IDirect3DRMFrame3_DeleteChild(parent, child);
831 }
832 }
833
834 if (!d3drm_array_reserve((void **)&frame->children, &frame->children_size,
835 frame->nb_children + 1, sizeof(*frame->children)))
836 return E_OUTOFMEMORY;
837
838 frame->children[frame->nb_children++] = child;
839 IDirect3DRMFrame3_AddRef(child);
840 child_obj->parent = frame;
841
842 return D3DRM_OK;
843 }
844
845 static HRESULT WINAPI d3drm_frame2_AddChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
846 {
847 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
848 IDirect3DRMFrame3 *child3;
849 HRESULT hr;
850
851 TRACE("iface %p, child %p.\n", iface, child);
852
853 if (!child)
854 return D3DRMERR_BADOBJECT;
855 hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3);
856 if (hr != S_OK)
857 return D3DRMERR_BADOBJECT;
858 IDirect3DRMFrame_Release(child);
859
860 return d3drm_frame3_AddChild(&frame->IDirect3DRMFrame3_iface, child3);
861 }
862
863 static HRESULT WINAPI d3drm_frame1_AddChild(IDirect3DRMFrame *iface, IDirect3DRMFrame *child)
864 {
865 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
866 struct d3drm_frame *child_frame = unsafe_impl_from_IDirect3DRMFrame(child);
867
868 TRACE("iface %p, child %p.\n", iface, child);
869
870 if (!child_frame)
871 return D3DRMERR_BADOBJECT;
872
873 return d3drm_frame3_AddChild(&frame->IDirect3DRMFrame3_iface, &child_frame->IDirect3DRMFrame3_iface);
874 }
875
876 static HRESULT WINAPI d3drm_frame3_AddLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
877 {
878 struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
879 ULONG i;
880 IDirect3DRMLight** lights;
881
882 TRACE("iface %p, light %p.\n", iface, light);
883
884 if (!light)
885 return D3DRMERR_BADOBJECT;
886
887 /* Check if already existing and return gracefully without increasing ref count */
888 for (i = 0; i < This->nb_lights; i++)
889 if (This->lights[i] == light)
890 return D3DRM_OK;
891
892 if ((This->nb_lights + 1) > This->lights_capacity)
893 {
894 ULONG new_capacity;
895
896 if (!This->lights_capacity)
897 {
898 new_capacity = 16;
899 lights = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMLight*));
900 }
901 else
902 {
903 new_capacity = This->lights_capacity * 2;
904 lights = HeapReAlloc(GetProcessHeap(), 0, This->lights, new_capacity * sizeof(IDirect3DRMLight*));
905 }
906
907 if (!lights)
908 return E_OUTOFMEMORY;
909
910 This->lights_capacity = new_capacity;
911 This->lights = lights;
912 }
913
914 This->lights[This->nb_lights++] = light;
915 IDirect3DRMLight_AddRef(light);
916
917 return D3DRM_OK;
918 }
919
920 static HRESULT WINAPI d3drm_frame2_AddLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
921 {
922 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
923
924 TRACE("iface %p, light %p.\n", iface, light);
925
926 return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
927 }
928
929 static HRESULT WINAPI d3drm_frame1_AddLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
930 {
931 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
932
933 TRACE("iface %p, light %p.\n", iface, light);
934
935 return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
936 }
937
938 static HRESULT WINAPI d3drm_frame3_AddMoveCallback(IDirect3DRMFrame3 *iface,
939 D3DRMFRAME3MOVECALLBACK cb, void *ctx, DWORD flags)
940 {
941 FIXME("iface %p, cb %p, ctx %p flags %#x stub!\n", iface, cb, ctx, flags);
942
943 return E_NOTIMPL;
944 }
945
946 static HRESULT WINAPI d3drm_frame2_AddMoveCallback(IDirect3DRMFrame2 *iface,
947 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
948 {
949 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
950
951 return E_NOTIMPL;
952 }
953
954 static HRESULT WINAPI d3drm_frame1_AddMoveCallback(IDirect3DRMFrame *iface,
955 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
956 {
957 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
958
959 return E_NOTIMPL;
960 }
961
962 static HRESULT WINAPI d3drm_frame3_AddTransform(IDirect3DRMFrame3 *iface,
963 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
964 {
965 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
966
967 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
968
969 switch (type)
970 {
971 case D3DRMCOMBINE_REPLACE:
972 memcpy(frame->transform, matrix, sizeof(D3DRMMATRIX4D));
973 break;
974
975 case D3DRMCOMBINE_BEFORE:
976 FIXME("D3DRMCOMBINE_BEFORE not supported yet\n");
977 break;
978
979 case D3DRMCOMBINE_AFTER:
980 FIXME("D3DRMCOMBINE_AFTER not supported yet\n");
981 break;
982
983 default:
984 WARN("Unknown Combine Type %u\n", type);
985 return D3DRMERR_BADVALUE;
986 }
987
988 return S_OK;
989 }
990
991 static HRESULT WINAPI d3drm_frame2_AddTransform(IDirect3DRMFrame2 *iface,
992 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
993 {
994 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
995
996 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
997
998 return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
999 }
1000
1001 static HRESULT WINAPI d3drm_frame1_AddTransform(IDirect3DRMFrame *iface,
1002 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
1003 {
1004 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1005
1006 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
1007
1008 return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
1009 }
1010
1011 static HRESULT WINAPI d3drm_frame3_AddTranslation(IDirect3DRMFrame3 *iface,
1012 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1013 {
1014 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
1015
1016 return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI d3drm_frame2_AddTranslation(IDirect3DRMFrame2 *iface,
1020 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1021 {
1022 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
1023
1024 return E_NOTIMPL;
1025 }
1026
1027 static HRESULT WINAPI d3drm_frame1_AddTranslation(IDirect3DRMFrame *iface,
1028 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1029 {
1030 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
1031
1032 return E_NOTIMPL;
1033 }
1034
1035 static HRESULT WINAPI d3drm_frame3_AddScale(IDirect3DRMFrame3 *iface,
1036 D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1037 {
1038 FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1039
1040 return E_NOTIMPL;
1041 }
1042
1043 static HRESULT WINAPI d3drm_frame2_AddScale(IDirect3DRMFrame2 *iface,
1044 D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1045 {
1046 FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1047
1048 return E_NOTIMPL;
1049 }
1050
1051 static HRESULT WINAPI d3drm_frame1_AddScale(IDirect3DRMFrame *iface,
1052 D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1053 {
1054 FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1055
1056 return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI d3drm_frame3_AddRotation(IDirect3DRMFrame3 *iface,
1060 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1061 {
1062 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
1063 iface, type, x, y, z, theta);
1064
1065 return E_NOTIMPL;
1066 }
1067
1068 static HRESULT WINAPI d3drm_frame2_AddRotation(IDirect3DRMFrame2 *iface,
1069 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1070 {
1071 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n", iface, type, x, y, z, theta);
1072
1073 return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI d3drm_frame1_AddRotation(IDirect3DRMFrame *iface,
1077 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1078 {
1079 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n", iface, type, x, y, z, theta);
1080
1081 return E_NOTIMPL;
1082 }
1083
1084 static HRESULT WINAPI d3drm_frame3_AddVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1085 {
1086 struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
1087 ULONG i;
1088 IDirect3DRMVisual** visuals;
1089
1090 TRACE("iface %p, visual %p.\n", iface, visual);
1091
1092 if (!visual)
1093 return D3DRMERR_BADOBJECT;
1094
1095 /* Check if already existing and return gracefully without increasing ref count */
1096 for (i = 0; i < This->nb_visuals; i++)
1097 if (This->visuals[i] == (IDirect3DRMVisual *)visual)
1098 return D3DRM_OK;
1099
1100 if ((This->nb_visuals + 1) > This->visuals_capacity)
1101 {
1102 ULONG new_capacity;
1103
1104 if (!This->visuals_capacity)
1105 {
1106 new_capacity = 16;
1107 visuals = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMVisual*));
1108 }
1109 else
1110 {
1111 new_capacity = This->visuals_capacity * 2;
1112 visuals = HeapReAlloc(GetProcessHeap(), 0, This->visuals, new_capacity * sizeof(IDirect3DRMVisual*));
1113 }
1114
1115 if (!visuals)
1116 return E_OUTOFMEMORY;
1117
1118 This->visuals_capacity = new_capacity;
1119 This->visuals = visuals;
1120 }
1121
1122 This->visuals[This->nb_visuals++] = (IDirect3DRMVisual *)visual;
1123 IDirect3DRMVisual_AddRef(visual);
1124
1125 return D3DRM_OK;
1126 }
1127
1128 static HRESULT WINAPI d3drm_frame2_AddVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1129 {
1130 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1131
1132 TRACE("iface %p, visual %p.\n", iface, visual);
1133
1134 return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1135 }
1136
1137 static HRESULT WINAPI d3drm_frame1_AddVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1138 {
1139 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1140
1141 TRACE("iface %p, visual %p.\n", iface, visual);
1142
1143 return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1144 }
1145
1146 static HRESULT WINAPI d3drm_frame3_GetChildren(IDirect3DRMFrame3 *iface, IDirect3DRMFrameArray **children)
1147 {
1148 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1149 struct d3drm_frame_array *array;
1150
1151 TRACE("iface %p, children %p.\n", iface, children);
1152
1153 if (!children)
1154 return D3DRMERR_BADVALUE;
1155
1156 if (!(array = d3drm_frame_array_create(frame->nb_children, frame->children)))
1157 return E_OUTOFMEMORY;
1158
1159 *children = &array->IDirect3DRMFrameArray_iface;
1160
1161 return D3DRM_OK;
1162 }
1163
1164 static HRESULT WINAPI d3drm_frame2_GetChildren(IDirect3DRMFrame2 *iface, IDirect3DRMFrameArray **children)
1165 {
1166 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1167
1168 TRACE("iface %p, children %p.\n", iface, children);
1169
1170 return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1171 }
1172
1173 static HRESULT WINAPI d3drm_frame1_GetChildren(IDirect3DRMFrame *iface, IDirect3DRMFrameArray **children)
1174 {
1175 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1176
1177 TRACE("iface %p, children %p.\n", iface, children);
1178
1179 return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1180 }
1181
1182 static D3DCOLOR WINAPI d3drm_frame3_GetColor(IDirect3DRMFrame3 *iface)
1183 {
1184 FIXME("iface %p stub!\n", iface);
1185
1186 return 0;
1187 }
1188
1189 static D3DCOLOR WINAPI d3drm_frame2_GetColor(IDirect3DRMFrame2 *iface)
1190 {
1191 FIXME("iface %p stub!\n", iface);
1192
1193 return 0;
1194 }
1195
1196 static D3DCOLOR WINAPI d3drm_frame1_GetColor(IDirect3DRMFrame *iface)
1197 {
1198 FIXME("iface %p stub!\n", iface);
1199
1200 return 0;
1201 }
1202
1203 static HRESULT WINAPI d3drm_frame3_GetLights(IDirect3DRMFrame3 *iface, IDirect3DRMLightArray **lights)
1204 {
1205 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1206 struct d3drm_light_array *array;
1207
1208 TRACE("iface %p, lights %p.\n", iface, lights);
1209
1210 if (!lights)
1211 return D3DRMERR_BADVALUE;
1212
1213 if (!(array = d3drm_light_array_create(frame->nb_lights, frame->lights)))
1214 return E_OUTOFMEMORY;
1215
1216 *lights = &array->IDirect3DRMLightArray_iface;
1217
1218 return D3DRM_OK;
1219 }
1220
1221 static HRESULT WINAPI d3drm_frame2_GetLights(IDirect3DRMFrame2 *iface, IDirect3DRMLightArray **lights)
1222 {
1223 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1224
1225 TRACE("iface %p, lights %p.\n", iface, lights);
1226
1227 return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1228 }
1229
1230 static HRESULT WINAPI d3drm_frame1_GetLights(IDirect3DRMFrame *iface, IDirect3DRMLightArray **lights)
1231 {
1232 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1233
1234 TRACE("iface %p, lights %p.\n", iface, lights);
1235
1236 return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1237 }
1238
1239 static D3DRMMATERIALMODE WINAPI d3drm_frame3_GetMaterialMode(IDirect3DRMFrame3 *iface)
1240 {
1241 FIXME("iface %p stub!\n", iface);
1242
1243 return D3DRMMATERIAL_FROMPARENT;
1244 }
1245
1246 static D3DRMMATERIALMODE WINAPI d3drm_frame2_GetMaterialMode(IDirect3DRMFrame2 *iface)
1247 {
1248 FIXME("iface %p stub!\n", iface);
1249
1250 return D3DRMMATERIAL_FROMPARENT;
1251 }
1252
1253 static D3DRMMATERIALMODE WINAPI d3drm_frame1_GetMaterialMode(IDirect3DRMFrame *iface)
1254 {
1255 FIXME("iface %p stub!\n", iface);
1256
1257 return D3DRMMATERIAL_FROMPARENT;
1258 }
1259
1260 static HRESULT WINAPI d3drm_frame3_GetParent(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **parent)
1261 {
1262 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1263
1264 TRACE("iface %p, parent %p.\n", iface, parent);
1265
1266 if (!parent)
1267 return D3DRMERR_BADVALUE;
1268
1269 if (frame->parent)
1270 {
1271 *parent = &frame->parent->IDirect3DRMFrame3_iface;
1272 IDirect3DRMFrame_AddRef(*parent);
1273 }
1274 else
1275 {
1276 *parent = NULL;
1277 }
1278
1279 return D3DRM_OK;
1280 }
1281
1282 static HRESULT WINAPI d3drm_frame2_GetParent(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **parent)
1283 {
1284 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1285
1286 TRACE("iface %p, parent %p.\n", iface, parent);
1287
1288 if (!parent)
1289 return D3DRMERR_BADVALUE;
1290
1291 if (frame->parent)
1292 {
1293 *parent = &frame->parent->IDirect3DRMFrame_iface;
1294 IDirect3DRMFrame_AddRef(*parent);
1295 }
1296 else
1297 {
1298 *parent = NULL;
1299 }
1300
1301 return D3DRM_OK;
1302 }
1303
1304 static HRESULT WINAPI d3drm_frame1_GetParent(IDirect3DRMFrame *iface, IDirect3DRMFrame **parent)
1305 {
1306 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1307
1308 TRACE("iface %p, parent %p.\n", iface, parent);
1309
1310 return d3drm_frame2_GetParent(&frame->IDirect3DRMFrame2_iface, parent);
1311 }
1312
1313 static HRESULT WINAPI d3drm_frame3_GetPosition(IDirect3DRMFrame3 *iface,
1314 IDirect3DRMFrame3 *reference, D3DVECTOR *position)
1315 {
1316 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1317
1318 return E_NOTIMPL;
1319 }
1320
1321 static HRESULT WINAPI d3drm_frame2_GetPosition(IDirect3DRMFrame2 *iface,
1322 IDirect3DRMFrame *reference, D3DVECTOR *position)
1323 {
1324 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1325
1326 return E_NOTIMPL;
1327 }
1328
1329 static HRESULT WINAPI d3drm_frame1_GetPosition(IDirect3DRMFrame *iface,
1330 IDirect3DRMFrame *reference, D3DVECTOR *position)
1331 {
1332 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1333
1334 return E_NOTIMPL;
1335 }
1336
1337
1338 static HRESULT WINAPI d3drm_frame3_GetRotation(IDirect3DRMFrame3 *iface,
1339 IDirect3DRMFrame3 *reference, D3DVECTOR *axis, D3DVALUE *theta)
1340 {
1341 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1342
1343 return E_NOTIMPL;
1344 }
1345
1346 static HRESULT WINAPI d3drm_frame2_GetRotation(IDirect3DRMFrame2 *iface,
1347 IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1348 {
1349 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1350
1351 return E_NOTIMPL;
1352 }
1353
1354 static HRESULT WINAPI d3drm_frame1_GetRotation(IDirect3DRMFrame *iface,
1355 IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1356 {
1357 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1358
1359 return E_NOTIMPL;
1360 }
1361
1362 static HRESULT WINAPI d3drm_frame3_GetScene(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **scene)
1363 {
1364 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1365
1366 TRACE("iface %p, scene %p.\n", iface, scene);
1367
1368 if (!scene)
1369 return D3DRMERR_BADVALUE;
1370
1371 while (frame->parent)
1372 frame = frame->parent;
1373
1374 *scene = &frame->IDirect3DRMFrame3_iface;
1375 IDirect3DRMFrame3_AddRef(*scene);
1376
1377 return D3DRM_OK;
1378 }
1379
1380 static HRESULT WINAPI d3drm_frame2_GetScene(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **scene)
1381 {
1382 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1383 IDirect3DRMFrame3 *frame3;
1384 HRESULT hr;
1385
1386 TRACE("iface %p, scene %p.\n", iface, scene);
1387
1388 if (!scene)
1389 return D3DRMERR_BADVALUE;
1390
1391 hr = IDirect3DRMFrame3_GetScene(&frame->IDirect3DRMFrame3_iface, &frame3);
1392 if (FAILED(hr) || !frame3)
1393 {
1394 *scene = NULL;
1395 return hr;
1396 }
1397
1398 hr = IDirect3DRMFrame3_QueryInterface(frame3, &IID_IDirect3DRMFrame, (void **)scene);
1399 IDirect3DRMFrame3_Release(frame3);
1400
1401 return hr;
1402 }
1403
1404 static HRESULT WINAPI d3drm_frame1_GetScene(IDirect3DRMFrame *iface, IDirect3DRMFrame **scene)
1405 {
1406 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1407
1408 TRACE("iface %p, scene %p.\n", iface, scene);
1409
1410 return d3drm_frame2_GetScene(&frame->IDirect3DRMFrame2_iface, scene);
1411 }
1412
1413 static D3DRMSORTMODE WINAPI d3drm_frame3_GetSortMode(IDirect3DRMFrame3 *iface)
1414 {
1415 FIXME("iface %p stub!\n", iface);
1416
1417 return D3DRMSORT_FROMPARENT;
1418 }
1419
1420 static D3DRMSORTMODE WINAPI d3drm_frame2_GetSortMode(IDirect3DRMFrame2 *iface)
1421 {
1422 FIXME("iface %p stub!\n", iface);
1423
1424 return D3DRMSORT_FROMPARENT;
1425 }
1426
1427 static D3DRMSORTMODE WINAPI d3drm_frame1_GetSortMode(IDirect3DRMFrame *iface)
1428 {
1429 FIXME("iface %p stub!\n", iface);
1430
1431 return D3DRMSORT_FROMPARENT;
1432 }
1433
1434 static HRESULT WINAPI d3drm_frame3_GetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 **texture)
1435 {
1436 FIXME("iface %p, texture %p stub!\n", iface, texture);
1437
1438 return E_NOTIMPL;
1439 }
1440
1441 static HRESULT WINAPI d3drm_frame2_GetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture **texture)
1442 {
1443 FIXME("iface %p, texture %p stub!\n", iface, texture);
1444
1445 return E_NOTIMPL;
1446 }
1447
1448 static HRESULT WINAPI d3drm_frame1_GetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture **texture)
1449 {
1450 FIXME("iface %p, texture %p stub!\n", iface, texture);
1451
1452 return E_NOTIMPL;
1453 }
1454
1455 static HRESULT WINAPI d3drm_frame3_GetTransform(IDirect3DRMFrame3 *iface,
1456 IDirect3DRMFrame3 *reference, D3DRMMATRIX4D matrix)
1457 {
1458 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1459
1460 TRACE("iface %p, reference %p, matrix %p.\n", iface, reference, matrix);
1461
1462 if (reference)
1463 FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1464
1465 memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
1466
1467 return D3DRM_OK;
1468 }
1469
1470 static HRESULT WINAPI d3drm_frame2_GetTransform(IDirect3DRMFrame2 *iface, D3DRMMATRIX4D matrix)
1471 {
1472 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1473
1474 TRACE("iface %p, matrix %p.\n", iface, matrix);
1475
1476 memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
1477
1478 return D3DRM_OK;
1479 }
1480
1481 static HRESULT WINAPI d3drm_frame1_GetTransform(IDirect3DRMFrame *iface, D3DRMMATRIX4D matrix)
1482 {
1483 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1484
1485 TRACE("iface %p, matrix %p.\n", iface, matrix);
1486
1487 return d3drm_frame2_GetTransform(&frame->IDirect3DRMFrame2_iface, matrix);
1488 }
1489
1490 static HRESULT WINAPI d3drm_frame3_GetVelocity(IDirect3DRMFrame3 *iface,
1491 IDirect3DRMFrame3 *reference, D3DVECTOR *velocity, BOOL with_rotation)
1492 {
1493 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1494 iface, reference, velocity, with_rotation);
1495
1496 return E_NOTIMPL;
1497 }
1498
1499 static HRESULT WINAPI d3drm_frame2_GetVelocity(IDirect3DRMFrame2 *iface,
1500 IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1501 {
1502 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1503 iface, reference, velocity, with_rotation);
1504
1505 return E_NOTIMPL;
1506 }
1507
1508 static HRESULT WINAPI d3drm_frame1_GetVelocity(IDirect3DRMFrame *iface,
1509 IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1510 {
1511 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1512 iface, reference, velocity, with_rotation);
1513
1514 return E_NOTIMPL;
1515 }
1516
1517 static HRESULT WINAPI d3drm_frame3_GetOrientation(IDirect3DRMFrame3 *iface,
1518 IDirect3DRMFrame3 *reference, D3DVECTOR *dir, D3DVECTOR *up)
1519 {
1520 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1521
1522 return E_NOTIMPL;
1523 }
1524
1525 static HRESULT WINAPI d3drm_frame2_GetOrientation(IDirect3DRMFrame2 *iface,
1526 IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1527 {
1528 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1529
1530 return E_NOTIMPL;
1531 }
1532
1533 static HRESULT WINAPI d3drm_frame1_GetOrientation(IDirect3DRMFrame *iface,
1534 IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1535 {
1536 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1537
1538 return E_NOTIMPL;
1539 }
1540
1541 static HRESULT WINAPI d3drm_frame3_GetVisuals(IDirect3DRMFrame3 *iface, DWORD *count, IUnknown **visuals)
1542 {
1543 FIXME("iface %p, count %p, visuals %p stub!\n", iface, count, visuals);
1544
1545 return E_NOTIMPL;
1546 }
1547
1548 static HRESULT WINAPI d3drm_frame2_GetVisuals(IDirect3DRMFrame2 *iface, IDirect3DRMVisualArray **visuals)
1549 {
1550 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1551 struct d3drm_visual_array *array;
1552
1553 TRACE("iface %p, visuals %p.\n", iface, visuals);
1554
1555 if (!visuals)
1556 return D3DRMERR_BADVALUE;
1557
1558 if (!(array = d3drm_visual_array_create(frame->nb_visuals, frame->visuals)))
1559 return E_OUTOFMEMORY;
1560
1561 *visuals = &array->IDirect3DRMVisualArray_iface;
1562
1563 return D3DRM_OK;
1564 }
1565
1566 static HRESULT WINAPI d3drm_frame1_GetVisuals(IDirect3DRMFrame *iface, IDirect3DRMVisualArray **visuals)
1567 {
1568 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1569
1570 TRACE("iface %p, visuals %p.\n", iface, visuals);
1571
1572 return d3drm_frame2_GetVisuals(&frame->IDirect3DRMFrame2_iface, visuals);
1573 }
1574
1575 static HRESULT WINAPI d3drm_frame2_GetTextureTopology(IDirect3DRMFrame2 *iface, BOOL *wrap_u, BOOL *wrap_v)
1576 {
1577 FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1578
1579 return E_NOTIMPL;
1580 }
1581
1582 static HRESULT WINAPI d3drm_frame1_GetTextureTopology(IDirect3DRMFrame *iface, BOOL *wrap_u, BOOL *wrap_v)
1583 {
1584 FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1585
1586 return E_NOTIMPL;
1587 }
1588
1589 static HRESULT WINAPI d3drm_frame3_InverseTransform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
1590 {
1591 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1592
1593 return E_NOTIMPL;
1594 }
1595
1596 static HRESULT WINAPI d3drm_frame2_InverseTransform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
1597 {
1598 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1599
1600 return E_NOTIMPL;
1601 }
1602
1603 static HRESULT WINAPI d3drm_frame1_InverseTransform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
1604 {
1605 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1606
1607 return E_NOTIMPL;
1608 }
1609
1610 static HRESULT WINAPI d3drm_frame3_Load(IDirect3DRMFrame3 *iface, void *filename,
1611 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURE3CALLBACK cb, void *ctx)
1612 {
1613 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1614 iface, filename, name, flags, cb, ctx);
1615
1616 return E_NOTIMPL;
1617 }
1618
1619 static HRESULT WINAPI d3drm_frame2_Load(IDirect3DRMFrame2 *iface, void *filename,
1620 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1621 {
1622 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1623 iface, filename, name, flags, cb, ctx);
1624
1625 return E_NOTIMPL;
1626 }
1627
1628 static HRESULT WINAPI d3drm_frame1_Load(IDirect3DRMFrame *iface, void *filename,
1629 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1630 {
1631 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1632 iface, filename, name, flags, cb, ctx);
1633
1634 return E_NOTIMPL;
1635 }
1636
1637 static HRESULT WINAPI d3drm_frame3_LookAt(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *target,
1638 IDirect3DRMFrame3 *reference, D3DRMFRAMECONSTRAINT constraint)
1639 {
1640 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1641
1642 return E_NOTIMPL;
1643 }
1644
1645 static HRESULT WINAPI d3drm_frame2_LookAt(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *target,
1646 IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1647 {
1648 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1649
1650 return E_NOTIMPL;
1651 }
1652
1653 static HRESULT WINAPI d3drm_frame1_LookAt(IDirect3DRMFrame *iface, IDirect3DRMFrame *target,
1654 IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1655 {
1656 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1657
1658 return E_NOTIMPL;
1659 }
1660
1661 static HRESULT WINAPI d3drm_frame3_Move(IDirect3DRMFrame3 *iface, D3DVALUE delta)
1662 {
1663 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1664
1665 return E_NOTIMPL;
1666 }
1667
1668 static HRESULT WINAPI d3drm_frame2_Move(IDirect3DRMFrame2 *iface, D3DVALUE delta)
1669 {
1670 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1671
1672 return E_NOTIMPL;
1673 }
1674
1675 static HRESULT WINAPI d3drm_frame1_Move(IDirect3DRMFrame *iface, D3DVALUE delta)
1676 {
1677 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1678
1679 return E_NOTIMPL;
1680 }
1681
1682 static HRESULT WINAPI d3drm_frame3_DeleteChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
1683 {
1684 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1685 struct d3drm_frame *child_impl = unsafe_impl_from_IDirect3DRMFrame3(child);
1686 ULONG i;
1687
1688 TRACE("iface %p, child %p.\n", iface, child);
1689
1690 if (!child_impl)
1691 return D3DRMERR_BADOBJECT;
1692
1693 /* Check if child exists */
1694 for (i = 0; i < frame->nb_children; ++i)
1695 {
1696 if (frame->children[i] == child)
1697 break;
1698 }
1699
1700 if (i == frame->nb_children)
1701 return D3DRMERR_BADVALUE;
1702
1703 memmove(frame->children + i, frame->children + i + 1, sizeof(*frame->children) * (frame->nb_children - 1 - i));
1704 IDirect3DRMFrame3_Release(child);
1705 child_impl->parent = NULL;
1706 --frame->nb_children;
1707
1708 return D3DRM_OK;
1709 }
1710
1711 static HRESULT WINAPI d3drm_frame2_DeleteChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
1712 {
1713 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1714 IDirect3DRMFrame3 *child3;
1715 HRESULT hr;
1716
1717 TRACE("iface %p, child %p.\n", iface, child);
1718
1719 if (!child)
1720 return D3DRMERR_BADOBJECT;
1721 if (FAILED(hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3)))
1722 return D3DRMERR_BADOBJECT;
1723 IDirect3DRMFrame_Release(child);
1724
1725 return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, child3);
1726 }
1727
1728 static HRESULT WINAPI d3drm_frame1_DeleteChild(IDirect3DRMFrame *iface, IDirect3DRMFrame *child)
1729 {
1730 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1731 struct d3drm_frame *child_frame = unsafe_impl_from_IDirect3DRMFrame(child);
1732
1733 TRACE("iface %p, child %p.\n", iface, child);
1734
1735 if (!child_frame)
1736 return D3DRMERR_BADOBJECT;
1737
1738 return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, &child_frame->IDirect3DRMFrame3_iface);
1739 }
1740
1741 static HRESULT WINAPI d3drm_frame3_DeleteLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1742 {
1743 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1744 ULONG i;
1745
1746 TRACE("iface %p, light %p.\n", iface, light);
1747
1748 if (!light)
1749 return D3DRMERR_BADOBJECT;
1750
1751 /* Check if visual exists */
1752 for (i = 0; i < frame->nb_lights; ++i)
1753 {
1754 if (frame->lights[i] == light)
1755 break;
1756 }
1757
1758 if (i == frame->nb_lights)
1759 return D3DRMERR_BADVALUE;
1760
1761 memmove(frame->lights + i, frame->lights + i + 1, sizeof(*frame->lights) * (frame->nb_lights - 1 - i));
1762 IDirect3DRMLight_Release(light);
1763 --frame->nb_lights;
1764
1765 return D3DRM_OK;
1766 }
1767
1768 static HRESULT WINAPI d3drm_frame2_DeleteLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
1769 {
1770 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1771
1772 TRACE("iface %p, light %p.\n", iface, light);
1773
1774 return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1775 }
1776
1777 static HRESULT WINAPI d3drm_frame1_DeleteLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
1778 {
1779 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1780
1781 TRACE("iface %p, light %p.\n", iface, light);
1782
1783 return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1784 }
1785
1786 static HRESULT WINAPI d3drm_frame3_DeleteMoveCallback(IDirect3DRMFrame3 *iface,
1787 D3DRMFRAME3MOVECALLBACK cb, void *ctx)
1788 {
1789 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1790
1791 return E_NOTIMPL;
1792 }
1793
1794 static HRESULT WINAPI d3drm_frame2_DeleteMoveCallback(IDirect3DRMFrame2 *iface,
1795 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1796 {
1797 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1798
1799 return E_NOTIMPL;
1800 }
1801
1802 static HRESULT WINAPI d3drm_frame1_DeleteMoveCallback(IDirect3DRMFrame *iface,
1803 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1804 {
1805 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1806
1807 return E_NOTIMPL;
1808 }
1809
1810 static HRESULT WINAPI d3drm_frame3_DeleteVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1811 {
1812 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1813 ULONG i;
1814
1815 TRACE("iface %p, visual %p.\n", iface, visual);
1816
1817 if (!visual)
1818 return D3DRMERR_BADOBJECT;
1819
1820 /* Check if visual exists */
1821 for (i = 0; i < frame->nb_visuals; ++i)
1822 {
1823 if (frame->visuals[i] == (IDirect3DRMVisual *)visual)
1824 break;
1825 }
1826
1827 if (i == frame->nb_visuals)
1828 return D3DRMERR_BADVALUE;
1829
1830 memmove(frame->visuals + i, frame->visuals + i + 1, sizeof(*frame->visuals) * (frame->nb_visuals - 1 - i));
1831 IDirect3DRMVisual_Release(visual);
1832 --frame->nb_visuals;
1833
1834 return D3DRM_OK;
1835 }
1836
1837 static HRESULT WINAPI d3drm_frame2_DeleteVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1838 {
1839 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1840
1841 TRACE("iface %p, visual %p.\n", iface, visual);
1842
1843 return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1844 }
1845
1846 static HRESULT WINAPI d3drm_frame1_DeleteVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1847 {
1848 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1849
1850 TRACE("iface %p, visual %p.\n", iface, visual);
1851
1852 return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1853 }
1854
1855 static D3DCOLOR WINAPI d3drm_frame3_GetSceneBackground(IDirect3DRMFrame3 *iface)
1856 {
1857 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1858
1859 TRACE("iface %p.\n", iface);
1860
1861 return frame->scenebackground;
1862 }
1863
1864 static D3DCOLOR WINAPI d3drm_frame2_GetSceneBackground(IDirect3DRMFrame2 *iface)
1865 {
1866 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1867
1868 TRACE("iface %p.\n", iface);
1869
1870 return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
1871 }
1872
1873 static D3DCOLOR WINAPI d3drm_frame1_GetSceneBackground(IDirect3DRMFrame *iface)
1874 {
1875 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1876
1877 TRACE("iface %p.\n", iface);
1878
1879 return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
1880 }
1881
1882 static HRESULT WINAPI d3drm_frame3_GetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
1883 IDirectDrawSurface **surface)
1884 {
1885 FIXME("iface %p, surface %p stub!\n", iface, surface);
1886
1887 return E_NOTIMPL;
1888 }
1889
1890 static HRESULT WINAPI d3drm_frame2_GetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
1891 IDirectDrawSurface **surface)
1892 {
1893 FIXME("iface %p, surface %p stub!\n", iface, surface);
1894
1895 return E_NOTIMPL;
1896 }
1897
1898 static HRESULT WINAPI d3drm_frame1_GetSceneBackgroundDepth(IDirect3DRMFrame *iface,
1899 IDirectDrawSurface **surface)
1900 {
1901 FIXME("iface %p, surface %p stub!\n", iface, surface);
1902
1903 return E_NOTIMPL;
1904 }
1905
1906 static D3DCOLOR WINAPI d3drm_frame3_GetSceneFogColor(IDirect3DRMFrame3 *iface)
1907 {
1908 FIXME("iface %p stub!\n", iface);
1909
1910 return 0;
1911 }
1912
1913 static D3DCOLOR WINAPI d3drm_frame2_GetSceneFogColor(IDirect3DRMFrame2 *iface)
1914 {
1915 FIXME("iface %p stub!\n", iface);
1916
1917 return 0;
1918 }
1919
1920 static D3DCOLOR WINAPI d3drm_frame1_GetSceneFogColor(IDirect3DRMFrame *iface)
1921 {
1922 FIXME("iface %p stub!\n", iface);
1923
1924 return 0;
1925 }
1926
1927 static BOOL WINAPI d3drm_frame3_GetSceneFogEnable(IDirect3DRMFrame3 *iface)
1928 {
1929 FIXME("iface %p stub!\n", iface);
1930
1931 return FALSE;
1932 }
1933
1934 static BOOL WINAPI d3drm_frame2_GetSceneFogEnable(IDirect3DRMFrame2 *iface)
1935 {
1936 FIXME("iface %p stub!\n", iface);
1937
1938 return FALSE;
1939 }
1940
1941 static BOOL WINAPI d3drm_frame1_GetSceneFogEnable(IDirect3DRMFrame *iface)
1942 {
1943 FIXME("iface %p stub!\n", iface);
1944
1945 return FALSE;
1946 }
1947
1948 static D3DRMFOGMODE WINAPI d3drm_frame3_GetSceneFogMode(IDirect3DRMFrame3 *iface)
1949 {
1950 FIXME("iface %p stub!\n", iface);
1951
1952 return D3DRMFOG_LINEAR;
1953 }
1954
1955 static D3DRMFOGMODE WINAPI d3drm_frame2_GetSceneFogMode(IDirect3DRMFrame2 *iface)
1956 {
1957 FIXME("iface %p stub!\n", iface);
1958
1959 return D3DRMFOG_LINEAR;
1960 }
1961
1962 static D3DRMFOGMODE WINAPI d3drm_frame1_GetSceneFogMode(IDirect3DRMFrame *iface)
1963 {
1964 FIXME("iface %p stub!\n", iface);
1965
1966 return D3DRMFOG_LINEAR;
1967 }
1968
1969 static HRESULT WINAPI d3drm_frame3_GetSceneFogParams(IDirect3DRMFrame3 *iface,
1970 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1971 {
1972 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1973
1974 return E_NOTIMPL;
1975 }
1976
1977 static HRESULT WINAPI d3drm_frame2_GetSceneFogParams(IDirect3DRMFrame2 *iface,
1978 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1979 {
1980 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1981
1982 return E_NOTIMPL;
1983 }
1984
1985 static HRESULT WINAPI d3drm_frame1_GetSceneFogParams(IDirect3DRMFrame *iface,
1986 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1987 {
1988 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1989
1990 return E_NOTIMPL;
1991 }
1992
1993 static HRESULT WINAPI d3drm_frame3_SetSceneBackground(IDirect3DRMFrame3 *iface, D3DCOLOR color)
1994 {
1995 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1996
1997 TRACE("iface %p, color 0x%08x.\n", iface, color);
1998
1999 frame->scenebackground = color;
2000
2001 return D3DRM_OK;
2002 }
2003
2004 static HRESULT WINAPI d3drm_frame2_SetSceneBackground(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2005 {
2006 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2007
2008 TRACE("iface %p, color 0x%08x.\n", iface, color);
2009
2010 return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
2011 }
2012
2013 static HRESULT WINAPI d3drm_frame1_SetSceneBackground(IDirect3DRMFrame *iface, D3DCOLOR color)
2014 {
2015 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2016
2017 TRACE("iface %p, color 0x%08x.\n", iface, color);
2018
2019 return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
2020 }
2021
2022 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundRGB(IDirect3DRMFrame3 *iface,
2023 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2024 {
2025 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2026
2027 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2028
2029 d3drm_set_color(&frame->scenebackground, red, green, blue, 1.0f);
2030
2031 return D3DRM_OK;
2032 }
2033
2034 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundRGB(IDirect3DRMFrame2 *iface,
2035 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2036 {
2037 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2038
2039 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2040
2041 return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2042 }
2043
2044 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundRGB(IDirect3DRMFrame *iface,
2045 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2046 {
2047 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2048
2049 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2050
2051 return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2052 }
2053
2054 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
2055 IDirectDrawSurface *surface)
2056 {
2057 FIXME("iface %p, surface %p stub!\n", iface, surface);
2058
2059 return E_NOTIMPL;
2060 }
2061
2062 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
2063 IDirectDrawSurface *surface)
2064 {
2065 FIXME("iface %p, surface %p stub!\n", iface, surface);
2066
2067 return E_NOTIMPL;
2068 }
2069
2070 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundDepth(IDirect3DRMFrame *iface,
2071 IDirectDrawSurface *surface)
2072 {
2073 FIXME("iface %p, surface %p stub!\n", iface, surface);
2074
2075 return E_NOTIMPL;
2076 }
2077
2078 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundImage(IDirect3DRMFrame3 *iface,
2079 IDirect3DRMTexture3 *texture)
2080 {
2081 FIXME("iface %p, texture %p stub!\n", iface, texture);
2082
2083 return E_NOTIMPL;
2084 }
2085
2086 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundImage(IDirect3DRMFrame2 *iface,
2087 IDirect3DRMTexture *texture)
2088 {
2089 FIXME("iface %p, texture %p stub!\n", iface, texture);
2090
2091 return E_NOTIMPL;
2092 }
2093
2094 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundImage(IDirect3DRMFrame *iface,
2095 IDirect3DRMTexture *texture)
2096 {
2097 FIXME("iface %p, texture %p stub!\n", iface, texture);
2098
2099 return E_NOTIMPL;
2100 }
2101
2102 static HRESULT WINAPI d3drm_frame3_SetSceneFogEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2103 {
2104 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2105
2106 return E_NOTIMPL;
2107 }
2108
2109 static HRESULT WINAPI d3drm_frame2_SetSceneFogEnable(IDirect3DRMFrame2 *iface, BOOL enable)
2110 {
2111 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2112
2113 return E_NOTIMPL;
2114 }
2115
2116 static HRESULT WINAPI d3drm_frame1_SetSceneFogEnable(IDirect3DRMFrame *iface, BOOL enable)
2117 {
2118 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2119
2120 return E_NOTIMPL;
2121 }
2122
2123 static HRESULT WINAPI d3drm_frame3_SetSceneFogColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2124 {
2125 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2126
2127 return E_NOTIMPL;
2128 }
2129
2130 static HRESULT WINAPI d3drm_frame2_SetSceneFogColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2131 {
2132 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2133
2134 return E_NOTIMPL;
2135 }
2136
2137 static HRESULT WINAPI d3drm_frame1_SetSceneFogColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2138 {
2139 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2140
2141 return E_NOTIMPL;
2142 }
2143
2144 static HRESULT WINAPI d3drm_frame3_SetSceneFogMode(IDirect3DRMFrame3 *iface, D3DRMFOGMODE mode)
2145 {
2146 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2147
2148 return E_NOTIMPL;
2149 }
2150
2151 static HRESULT WINAPI d3drm_frame2_SetSceneFogMode(IDirect3DRMFrame2 *iface, D3DRMFOGMODE mode)
2152 {
2153 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2154
2155 return E_NOTIMPL;
2156 }
2157
2158 static HRESULT WINAPI d3drm_frame1_SetSceneFogMode(IDirect3DRMFrame *iface, D3DRMFOGMODE mode)
2159 {
2160 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2161
2162 return E_NOTIMPL;
2163 }
2164
2165 static HRESULT WINAPI d3drm_frame3_SetSceneFogParams(IDirect3DRMFrame3 *iface,
2166 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2167 {
2168 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2169
2170 return E_NOTIMPL;
2171 }
2172
2173 static HRESULT WINAPI d3drm_frame2_SetSceneFogParams(IDirect3DRMFrame2 *iface,
2174 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2175 {
2176 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2177
2178 return E_NOTIMPL;
2179 }
2180
2181 static HRESULT WINAPI d3drm_frame1_SetSceneFogParams(IDirect3DRMFrame *iface,
2182 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2183 {
2184 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2185
2186 return E_NOTIMPL;
2187 }
2188
2189 static HRESULT WINAPI d3drm_frame3_SetColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2190 {
2191 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2192
2193 return E_NOTIMPL;
2194 }
2195
2196 static HRESULT WINAPI d3drm_frame2_SetColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2197 {
2198 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2199
2200 return E_NOTIMPL;
2201 }
2202
2203 static HRESULT WINAPI d3drm_frame1_SetColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2204 {
2205 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2206
2207 return E_NOTIMPL;
2208 }
2209
2210 static HRESULT WINAPI d3drm_frame3_SetColorRGB(IDirect3DRMFrame3 *iface,
2211 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2212 {
2213 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2214
2215 return E_NOTIMPL;
2216 }
2217
2218 static HRESULT WINAPI d3drm_frame2_SetColorRGB(IDirect3DRMFrame2 *iface,
2219 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2220 {
2221 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2222
2223 return E_NOTIMPL;
2224 }
2225
2226 static HRESULT WINAPI d3drm_frame1_SetColorRGB(IDirect3DRMFrame *iface,
2227 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2228 {
2229 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2230
2231 return E_NOTIMPL;
2232 }
2233
2234 static D3DRMZBUFFERMODE WINAPI d3drm_frame3_GetZbufferMode(IDirect3DRMFrame3 *iface)
2235 {
2236 FIXME("iface %p stub!\n", iface);
2237
2238 return D3DRMZBUFFER_FROMPARENT;
2239 }
2240
2241 static D3DRMZBUFFERMODE WINAPI d3drm_frame2_GetZbufferMode(IDirect3DRMFrame2 *iface)
2242 {
2243 FIXME("iface %p stub!\n", iface);
2244
2245 return D3DRMZBUFFER_FROMPARENT;
2246 }
2247
2248 static D3DRMZBUFFERMODE WINAPI d3drm_frame1_GetZbufferMode(IDirect3DRMFrame *iface)
2249 {
2250 FIXME("iface %p stub!\n", iface);
2251
2252 return D3DRMZBUFFER_FROMPARENT;
2253 }
2254
2255 static HRESULT WINAPI d3drm_frame3_SetMaterialMode(IDirect3DRMFrame3 *iface, D3DRMMATERIALMODE mode)
2256 {
2257 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2258
2259 return E_NOTIMPL;
2260 }
2261
2262 static HRESULT WINAPI d3drm_frame2_SetMaterialMode(IDirect3DRMFrame2 *iface, D3DRMMATERIALMODE mode)
2263 {
2264 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2265
2266 return E_NOTIMPL;
2267 }
2268
2269 static HRESULT WINAPI d3drm_frame1_SetMaterialMode(IDirect3DRMFrame *iface, D3DRMMATERIALMODE mode)
2270 {
2271 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2272
2273 return E_NOTIMPL;
2274 }
2275
2276 static HRESULT WINAPI d3drm_frame3_SetOrientation(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2277 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2278 {
2279 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2280 iface, reference, dx, dy, dz, ux, uy, uz);
2281
2282 return E_NOTIMPL;
2283 }
2284
2285 static HRESULT WINAPI d3drm_frame2_SetOrientation(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *reference,
2286 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2287 {
2288 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2289 iface, reference, dx, dy, dz, ux, uy, uz);
2290
2291 return E_NOTIMPL;
2292 }
2293
2294 static HRESULT WINAPI d3drm_frame1_SetOrientation(IDirect3DRMFrame *iface, IDirect3DRMFrame *reference,
2295 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2296 {
2297 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2298 iface, reference, dx, dy, dz, ux, uy, uz);
2299
2300 return E_NOTIMPL;
2301 }
2302
2303 static HRESULT WINAPI d3drm_frame3_SetPosition(IDirect3DRMFrame3 *iface,
2304 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2305 {
2306 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2307
2308 return E_NOTIMPL;
2309 }
2310
2311 static HRESULT WINAPI d3drm_frame2_SetPosition(IDirect3DRMFrame2 *iface,
2312 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2313 {
2314 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2315
2316 return E_NOTIMPL;
2317 }
2318
2319 static HRESULT WINAPI d3drm_frame1_SetPosition(IDirect3DRMFrame *iface,
2320 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2321 {
2322 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2323
2324 return E_NOTIMPL;
2325 }
2326
2327 static HRESULT WINAPI d3drm_frame3_SetRotation(IDirect3DRMFrame3 *iface,
2328 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2329 {
2330 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2331 iface, reference, x, y, z, theta);
2332
2333 return E_NOTIMPL;
2334 }
2335
2336 static HRESULT WINAPI d3drm_frame2_SetRotation(IDirect3DRMFrame2 *iface,
2337 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2338 {
2339 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2340 iface, reference, x, y, z, theta);
2341
2342 return E_NOTIMPL;
2343 }
2344
2345 static HRESULT WINAPI d3drm_frame1_SetRotation(IDirect3DRMFrame *iface,
2346 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2347 {
2348 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2349 iface, reference, x, y, z, theta);
2350
2351 return E_NOTIMPL;
2352 }
2353
2354 static HRESULT WINAPI d3drm_frame3_SetSortMode(IDirect3DRMFrame3 *iface, D3DRMSORTMODE mode)
2355 {
2356 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2357
2358 return E_NOTIMPL;
2359 }
2360
2361 static HRESULT WINAPI d3drm_frame2_SetSortMode(IDirect3DRMFrame2 *iface, D3DRMSORTMODE mode)
2362 {
2363 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2364
2365 return E_NOTIMPL;
2366 }
2367
2368 static HRESULT WINAPI d3drm_frame1_SetSortMode(IDirect3DRMFrame *iface, D3DRMSORTMODE mode)
2369 {
2370 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2371
2372 return E_NOTIMPL;
2373 }
2374
2375 static HRESULT WINAPI d3drm_frame3_SetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 *texture)
2376 {
2377 FIXME("iface %p, texture %p stub!\n", iface, texture);
2378
2379 return E_NOTIMPL;
2380 }
2381
2382 static HRESULT WINAPI d3drm_frame2_SetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture *texture)
2383 {
2384 FIXME("iface %p, texture %p stub!\n", iface, texture);
2385
2386 return E_NOTIMPL;
2387 }
2388
2389 static HRESULT WINAPI d3drm_frame1_SetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture *texture)
2390 {
2391 FIXME("iface %p, texture %p stub!\n", iface, texture);
2392
2393 return E_NOTIMPL;
2394 }
2395
2396 static HRESULT WINAPI d3drm_frame2_SetTextureTopology(IDirect3DRMFrame2 *iface, BOOL wrap_u, BOOL wrap_v)
2397 {
2398 FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2399
2400 return E_NOTIMPL;
2401 }
2402
2403 static HRESULT WINAPI d3drm_frame1_SetTextureTopology(IDirect3DRMFrame *iface, BOOL wrap_u, BOOL wrap_v)
2404 {
2405 FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2406
2407 return E_NOTIMPL;
2408 }
2409
2410 static HRESULT WINAPI d3drm_frame3_SetVelocity(IDirect3DRMFrame3 *iface,
2411 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2412 {
2413 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x.\n",
2414 iface, reference, x, y, z, with_rotation);
2415
2416 return E_NOTIMPL;
2417 }
2418
2419 static HRESULT WINAPI d3drm_frame2_SetVelocity(IDirect3DRMFrame2 *iface,
2420 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2421 {
2422 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2423 iface, reference, x, y, z, with_rotation);
2424
2425 return E_NOTIMPL;
2426 }
2427
2428 static HRESULT WINAPI d3drm_frame1_SetVelocity(IDirect3DRMFrame *iface,
2429 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2430 {
2431 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2432 iface, reference, x, y, z, with_rotation);
2433
2434 return E_NOTIMPL;
2435 }
2436
2437 static HRESULT WINAPI d3drm_frame3_SetZbufferMode(IDirect3DRMFrame3 *iface, D3DRMZBUFFERMODE mode)
2438 {
2439 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2440
2441 return E_NOTIMPL;
2442 }
2443
2444 static HRESULT WINAPI d3drm_frame2_SetZbufferMode(IDirect3DRMFrame2 *iface, D3DRMZBUFFERMODE mode)
2445 {
2446 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2447
2448 return E_NOTIMPL;
2449 }
2450
2451 static HRESULT WINAPI d3drm_frame1_SetZbufferMode(IDirect3DRMFrame *iface, D3DRMZBUFFERMODE mode)
2452 {
2453 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2454
2455 return E_NOTIMPL;
2456 }
2457
2458 static HRESULT WINAPI d3drm_frame3_Transform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
2459 {
2460 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2461
2462 return E_NOTIMPL;
2463 }
2464
2465 static HRESULT WINAPI d3drm_frame2_Transform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
2466 {
2467 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2468
2469 return E_NOTIMPL;
2470 }
2471
2472 static HRESULT WINAPI d3drm_frame1_Transform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
2473 {
2474 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2475
2476 return E_NOTIMPL;
2477 }
2478
2479 static HRESULT WINAPI d3drm_frame2_AddMoveCallback2(IDirect3DRMFrame2 *iface,
2480 D3DRMFRAMEMOVECALLBACK cb, void *ctx, DWORD flags)
2481 {
2482 FIXME("iface %p, cb %p, ctx %p, flags %#x stub!\n", iface, cb, ctx, flags);
2483
2484 return E_NOTIMPL;
2485 }
2486
2487 static HRESULT WINAPI d3drm_frame3_GetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2488 {
2489 FIXME("iface %p, box %p stub!\n", iface, box);
2490
2491 return E_NOTIMPL;
2492 }
2493
2494 static HRESULT WINAPI d3drm_frame2_GetBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2495 {
2496 FIXME("iface %p, box %p stub!\n", iface, box);
2497
2498 return E_NOTIMPL;
2499 }
2500
2501 static BOOL WINAPI d3drm_frame3_GetBoxEnable(IDirect3DRMFrame3 *iface)
2502 {
2503 FIXME("iface %p stub!\n", iface);
2504
2505 return FALSE;
2506 }
2507
2508 static BOOL WINAPI d3drm_frame2_GetBoxEnable(IDirect3DRMFrame2 *iface)
2509 {
2510 FIXME("iface %p stub!\n", iface);
2511
2512 return FALSE;
2513 }
2514
2515 static HRESULT WINAPI d3drm_frame3_GetAxes(IDirect3DRMFrame3 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2516 {
2517 FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2518
2519 return E_NOTIMPL;
2520 }
2521
2522 static HRESULT WINAPI d3drm_frame2_GetAxes(IDirect3DRMFrame2 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2523 {
2524 FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2525
2526 return E_NOTIMPL;
2527 }
2528
2529 static HRESULT WINAPI d3drm_frame3_GetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 **material)
2530 {
2531 FIXME("iface %p, material %p stub!\n", iface, material);
2532
2533 return E_NOTIMPL;
2534 }
2535
2536 static HRESULT WINAPI d3drm_frame2_GetMaterial(IDirect3DRMFrame2 *iface, IDirect3DRMMaterial **material)
2537 {
2538 FIXME("iface %p, material %p stub!\n", iface, material);
2539
2540 return E_NOTIMPL;
2541 }
2542
2543 static BOOL WINAPI d3drm_frame3_GetInheritAxes(IDirect3DRMFrame3 *iface)
2544 {
2545 FIXME("iface %p stub!\n", iface);
2546
2547 return FALSE;
2548 }
2549
2550 static BOOL WINAPI d3drm_frame2_GetInheritAxes(IDirect3DRMFrame2 *iface)
2551 {
2552 FIXME("iface %p stub!\n", iface);
2553
2554 return FALSE;
2555 }
2556
2557 static HRESULT WINAPI d3drm_frame3_GetHierarchyBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2558 {
2559 FIXME("iface %p, box %p stub!\n", iface, box);
2560
2561 return E_NOTIMPL;
2562 }
2563
2564 static HRESULT WINAPI d3drm_frame2_GetHierarchyBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2565 {
2566 FIXME("iface %p, box %p stub!\n", iface, box);
2567
2568 return E_NOTIMPL;
2569 }
2570
2571 static HRESULT WINAPI d3drm_frame3_SetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2572 {
2573 FIXME("iface %p, box %p stub!\n", iface, box);
2574
2575 return E_NOTIMPL;
2576 }
2577
2578 static HRESULT WINAPI d3drm_frame3_SetBoxEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2579 {
2580 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2581
2582 return E_NOTIMPL;
2583 }
2584
2585 static HRESULT WINAPI d3drm_frame3_SetAxes(IDirect3DRMFrame3 *iface,
2586 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2587 {
2588 FIXME("iface %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2589 iface, dx, dy, dz, ux, uy, uz);
2590
2591 return E_NOTIMPL;
2592 }
2593
2594 static HRESULT WINAPI d3drm_frame3_SetInheritAxes(IDirect3DRMFrame3 *iface, BOOL inherit)
2595 {
2596 FIXME("iface %p, inherit %#x stub!\n", iface, inherit);
2597
2598 return E_NOTIMPL;
2599 }
2600
2601 static HRESULT WINAPI d3drm_frame3_SetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 *material)
2602 {
2603 FIXME("iface %p, material %p stub!\n", iface, material);
2604
2605 return E_NOTIMPL;
2606 }
2607
2608 static HRESULT WINAPI d3drm_frame3_SetQuaternion(IDirect3DRMFrame3 *iface,
2609 IDirect3DRMFrame3 *reference, D3DRMQUATERNION *q)
2610 {
2611 FIXME("iface %p, reference %p, q %p stub!\n", iface, reference, q);
2612
2613 return E_NOTIMPL;
2614 }
2615
2616 static HRESULT WINAPI d3drm_frame3_RayPick(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2617 D3DRMRAY *ray, DWORD flags, IDirect3DRMPicked2Array **visuals)
2618 {
2619 FIXME("iface %p, reference %p, ray %p, flags %#x, visuals %p stub!\n",
2620 iface, reference, ray, flags, visuals);
2621
2622 return E_NOTIMPL;
2623 }
2624
2625 static HRESULT WINAPI d3drm_frame3_Save(IDirect3DRMFrame3 *iface,
2626 const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags)
2627 {
2628 FIXME("iface %p, filename %s, format %#x, flags %#x stub!\n",
2629 iface, debugstr_a(filename), format, flags);
2630
2631 return E_NOTIMPL;
2632 }
2633
2634 static HRESULT WINAPI d3drm_frame3_TransformVectors(IDirect3DRMFrame3 *iface,
2635 IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2636 {
2637 FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2638
2639 return E_NOTIMPL;
2640 }
2641
2642 static HRESULT WINAPI d3drm_frame3_InverseTransformVectors(IDirect3DRMFrame3 *iface,
2643 IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2644 {
2645 FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2646
2647 return E_NOTIMPL;
2648 }
2649
2650 static HRESULT WINAPI d3drm_frame3_SetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD options)
2651 {
2652 static const DWORD supported_options = D3DRMFRAME_RENDERENABLE | D3DRMFRAME_PICKENABLE;
2653 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2654
2655 TRACE("iface %p, options %#x.\n", iface, options);
2656
2657 if (options & ~supported_options)
2658 return D3DRMERR_BADVALUE;
2659
2660 frame->traversal_options = options;
2661
2662 return D3DRM_OK;
2663 }
2664
2665 static HRESULT WINAPI d3drm_frame3_GetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD *options)
2666 {
2667 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2668
2669 TRACE("iface %p, options %p.\n", iface, options);
2670
2671 if (!options)
2672 return D3DRMERR_BADVALUE;
2673
2674 *options = frame->traversal_options;
2675
2676 return D3DRM_OK;
2677 }
2678
2679 static HRESULT WINAPI d3drm_frame3_SetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD flags)
2680 {
2681 FIXME("iface %p, flags %#x stub!\n", iface, flags);
2682
2683 return E_NOTIMPL;
2684 }
2685
2686 static HRESULT WINAPI d3drm_frame3_GetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD *fog_mode)
2687 {
2688 FIXME("iface %p, fog_mode %p stub!\n", iface, fog_mode);
2689
2690 return E_NOTIMPL;
2691 }
2692
2693 static HRESULT WINAPI d3drm_frame3_SetMaterialOverride(IDirect3DRMFrame3 *iface,
2694 D3DRMMATERIALOVERRIDE *override)
2695 {
2696 FIXME("iface %p, override %p stub!\n", iface, override);
2697
2698 return E_NOTIMPL;
2699 }
2700
2701 static HRESULT WINAPI d3drm_frame3_GetMaterialOverride(IDirect3DRMFrame3 *iface,
2702 D3DRMMATERIALOVERRIDE *override)
2703 {
2704 FIXME("iface %p, override %p stub!\n", iface, override);
2705
2706 return E_NOTIMPL;
2707 }
2708
2709 static const struct IDirect3DRMFrame3Vtbl d3drm_frame3_vtbl =
2710 {
2711 d3drm_frame3_QueryInterface,
2712 d3drm_frame3_AddRef,
2713 d3drm_frame3_Release,
2714 d3drm_frame3_Clone,
2715 d3drm_frame3_AddDestroyCallback,
2716 d3drm_frame3_DeleteDestroyCallback,
2717 d3drm_frame3_SetAppData,
2718 d3drm_frame3_GetAppData,
2719 d3drm_frame3_SetName,
2720 d3drm_frame3_GetName,
2721 d3drm_frame3_GetClassName,
2722 d3drm_frame3_AddChild,
2723 d3drm_frame3_AddLight,
2724 d3drm_frame3_AddMoveCallback,
2725 d3drm_frame3_AddTransform,
2726 d3drm_frame3_AddTranslation,
2727 d3drm_frame3_AddScale,
2728 d3drm_frame3_AddRotation,
2729 d3drm_frame3_AddVisual,
2730 d3drm_frame3_GetChildren,
2731 d3drm_frame3_GetColor,
2732 d3drm_frame3_GetLights,
2733 d3drm_frame3_GetMaterialMode,
2734 d3drm_frame3_GetParent,
2735 d3drm_frame3_GetPosition,
2736 d3drm_frame3_GetRotation,
2737 d3drm_frame3_GetScene,
2738 d3drm_frame3_GetSortMode,
2739 d3drm_frame3_GetTexture,
2740 d3drm_frame3_GetTransform,
2741 d3drm_frame3_GetVelocity,
2742 d3drm_frame3_GetOrientation,
2743 d3drm_frame3_GetVisuals,
2744 d3drm_frame3_InverseTransform,
2745 d3drm_frame3_Load,
2746 d3drm_frame3_LookAt,
2747 d3drm_frame3_Move,
2748 d3drm_frame3_DeleteChild,
2749 d3drm_frame3_DeleteLight,
2750 d3drm_frame3_DeleteMoveCallback,
2751 d3drm_frame3_DeleteVisual,
2752 d3drm_frame3_GetSceneBackground,
2753 d3drm_frame3_GetSceneBackgroundDepth,
2754 d3drm_frame3_GetSceneFogColor,
2755 d3drm_frame3_GetSceneFogEnable,
2756 d3drm_frame3_GetSceneFogMode,
2757 d3drm_frame3_GetSceneFogParams,
2758 d3drm_frame3_SetSceneBackground,
2759 d3drm_frame3_SetSceneBackgroundRGB,
2760 d3drm_frame3_SetSceneBackgroundDepth,
2761 d3drm_frame3_SetSceneBackgroundImage,
2762 d3drm_frame3_SetSceneFogEnable,
2763 d3drm_frame3_SetSceneFogColor,
2764 d3drm_frame3_SetSceneFogMode,
2765 d3drm_frame3_SetSceneFogParams,
2766 d3drm_frame3_SetColor,
2767 d3drm_frame3_SetColorRGB,
2768 d3drm_frame3_GetZbufferMode,
2769 d3drm_frame3_SetMaterialMode,
2770 d3drm_frame3_SetOrientation,
2771 d3drm_frame3_SetPosition,
2772 d3drm_frame3_SetRotation,
2773 d3drm_frame3_SetSortMode,
2774 d3drm_frame3_SetTexture,
2775 d3drm_frame3_SetVelocity,
2776 d3drm_frame3_SetZbufferMode,
2777 d3drm_frame3_Transform,
2778 d3drm_frame3_GetBox,
2779 d3drm_frame3_GetBoxEnable,
2780 d3drm_frame3_GetAxes,
2781 d3drm_frame3_GetMaterial,
2782 d3drm_frame3_GetInheritAxes,
2783 d3drm_frame3_GetHierarchyBox,
2784 d3drm_frame3_SetBox,
2785 d3drm_frame3_SetBoxEnable,
2786 d3drm_frame3_SetAxes,
2787 d3drm_frame3_SetInheritAxes,
2788 d3drm_frame3_SetMaterial,
2789 d3drm_frame3_SetQuaternion,
2790 d3drm_frame3_RayPick,
2791 d3drm_frame3_Save,
2792 d3drm_frame3_TransformVectors,
2793 d3drm_frame3_InverseTransformVectors,
2794 d3drm_frame3_SetTraversalOptions,
2795 d3drm_frame3_GetTraversalOptions,
2796 d3drm_frame3_SetSceneFogMethod,
2797 d3drm_frame3_GetSceneFogMethod,
2798 d3drm_frame3_SetMaterialOverride,
2799 d3drm_frame3_GetMaterialOverride,
2800 };
2801
2802 static const struct IDirect3DRMFrame2Vtbl d3drm_frame2_vtbl =
2803 {
2804 d3drm_frame2_QueryInterface,
2805 d3drm_frame2_AddRef,
2806 d3drm_frame2_Release,
2807 d3drm_frame2_Clone,
2808 d3drm_frame2_AddDestroyCallback,
2809 d3drm_frame2_DeleteDestroyCallback,
2810 d3drm_frame2_SetAppData,
2811 d3drm_frame2_GetAppData,
2812 d3drm_frame2_SetName,
2813 d3drm_frame2_GetName,
2814 d3drm_frame2_GetClassName,
2815 d3drm_frame2_AddChild,
2816 d3drm_frame2_AddLight,
2817 d3drm_frame2_AddMoveCallback,
2818 d3drm_frame2_AddTransform,
2819 d3drm_frame2_AddTranslation,
2820 d3drm_frame2_AddScale,
2821 d3drm_frame2_AddRotation,
2822 d3drm_frame2_AddVisual,
2823 d3drm_frame2_GetChildren,
2824 d3drm_frame2_GetColor,
2825 d3drm_frame2_GetLights,
2826 d3drm_frame2_GetMaterialMode,
2827 d3drm_frame2_GetParent,
2828 d3drm_frame2_GetPosition,
2829 d3drm_frame2_GetRotation,
2830 d3drm_frame2_GetScene,
2831 d3drm_frame2_GetSortMode,
2832 d3drm_frame2_GetTexture,
2833 d3drm_frame2_GetTransform,
2834 d3drm_frame2_GetVelocity,
2835 d3drm_frame2_GetOrientation,
2836 d3drm_frame2_GetVisuals,
2837 d3drm_frame2_GetTextureTopology,
2838 d3drm_frame2_InverseTransform,
2839 d3drm_frame2_Load,
2840 d3drm_frame2_LookAt,
2841 d3drm_frame2_Move,
2842 d3drm_frame2_DeleteChild,
2843 d3drm_frame2_DeleteLight,
2844 d3drm_frame2_DeleteMoveCallback,
2845 d3drm_frame2_DeleteVisual,
2846 d3drm_frame2_GetSceneBackground,
2847 d3drm_frame2_GetSceneBackgroundDepth,
2848 d3drm_frame2_GetSceneFogColor,
2849 d3drm_frame2_GetSceneFogEnable,
2850 d3drm_frame2_GetSceneFogMode,
2851 d3drm_frame2_GetSceneFogParams,
2852 d3drm_frame2_SetSceneBackground,
2853 d3drm_frame2_SetSceneBackgroundRGB,
2854 d3drm_frame2_SetSceneBackgroundDepth,
2855 d3drm_frame2_SetSceneBackgroundImage,
2856 d3drm_frame2_SetSceneFogEnable,
2857 d3drm_frame2_SetSceneFogColor,
2858 d3drm_frame2_SetSceneFogMode,
2859 d3drm_frame2_SetSceneFogParams,
2860 d3drm_frame2_SetColor,
2861 d3drm_frame2_SetColorRGB,
2862 d3drm_frame2_GetZbufferMode,
2863 d3drm_frame2_SetMaterialMode,
2864 d3drm_frame2_SetOrientation,
2865 d3drm_frame2_SetPosition,
2866 d3drm_frame2_SetRotation,
2867 d3drm_frame2_SetSortMode,
2868 d3drm_frame2_SetTexture,
2869 d3drm_frame2_SetTextureTopology,
2870 d3drm_frame2_SetVelocity,
2871 d3drm_frame2_SetZbufferMode,
2872 d3drm_frame2_Transform,
2873 d3drm_frame2_AddMoveCallback2,
2874 d3drm_frame2_GetBox,
2875 d3drm_frame2_GetBoxEnable,
2876 d3drm_frame2_GetAxes,
2877 d3drm_frame2_GetMaterial,
2878 d3drm_frame2_GetInheritAxes,
2879 d3drm_frame2_GetHierarchyBox,
2880 };
2881
2882 static const struct IDirect3DRMFrameVtbl d3drm_frame1_vtbl =
2883 {
2884 d3drm_frame1_QueryInterface,
2885 d3drm_frame1_AddRef,
2886 d3drm_frame1_Release,
2887 d3drm_frame1_Clone,
2888 d3drm_frame1_AddDestroyCallback,
2889 d3drm_frame1_DeleteDestroyCallback,
2890 d3drm_frame1_SetAppData,
2891 d3drm_frame1_GetAppData,
2892 d3drm_frame1_SetName,
2893 d3drm_frame1_GetName,
2894 d3drm_frame1_GetClassName,
2895 d3drm_frame1_AddChild,
2896 d3drm_frame1_AddLight,
2897 d3drm_frame1_AddMoveCallback,
2898 d3drm_frame1_AddTransform,
2899 d3drm_frame1_AddTranslation,
2900 d3drm_frame1_AddScale,
2901 d3drm_frame1_AddRotation,
2902 d3drm_frame1_AddVisual,
2903 d3drm_frame1_GetChildren,
2904 d3drm_frame1_GetColor,
2905 d3drm_frame1_GetLights,
2906 d3drm_frame1_GetMaterialMode,
2907 d3drm_frame1_GetParent,
2908 d3drm_frame1_GetPosition,
2909 d3drm_frame1_GetRotation,
2910 d3drm_frame1_GetScene,
2911 d3drm_frame1_GetSortMode,
2912 d3drm_frame1_GetTexture,
2913 d3drm_frame1_GetTransform,
2914 d3drm_frame1_GetVelocity,
2915 d3drm_frame1_GetOrientation,
2916 d3drm_frame1_GetVisuals,
2917 d3drm_frame1_GetTextureTopology,
2918 d3drm_frame1_InverseTransform,
2919 d3drm_frame1_Load,
2920 d3drm_frame1_LookAt,
2921 d3drm_frame1_Move,
2922 d3drm_frame1_DeleteChild,
2923 d3drm_frame1_DeleteLight,
2924 d3drm_frame1_DeleteMoveCallback,
2925 d3drm_frame1_DeleteVisual,
2926 d3drm_frame1_GetSceneBackground,
2927 d3drm_frame1_GetSceneBackgroundDepth,
2928 d3drm_frame1_GetSceneFogColor,
2929 d3drm_frame1_GetSceneFogEnable,
2930 d3drm_frame1_GetSceneFogMode,
2931 d3drm_frame1_GetSceneFogParams,
2932 d3drm_frame1_SetSceneBackground,
2933 d3drm_frame1_SetSceneBackgroundRGB,
2934 d3drm_frame1_SetSceneBackgroundDepth,
2935 d3drm_frame1_SetSceneBackgroundImage,
2936 d3drm_frame1_SetSceneFogEnable,
2937 d3drm_frame1_SetSceneFogColor,
2938 d3drm_frame1_SetSceneFogMode,
2939 d3drm_frame1_SetSceneFogParams,
2940 d3drm_frame1_SetColor,
2941 d3drm_frame1_SetColorRGB,
2942 d3drm_frame1_GetZbufferMode,
2943 d3drm_frame1_SetMaterialMode,
2944 d3drm_frame1_SetOrientation,
2945 d3drm_frame1_SetPosition,
2946 d3drm_frame1_SetRotation,
2947 d3drm_frame1_SetSortMode,
2948 d3drm_frame1_SetTexture,
2949 d3drm_frame1_SetTextureTopology,
2950 d3drm_frame1_SetVelocity,
2951 d3drm_frame1_SetZbufferMode,
2952 d3drm_frame1_Transform,
2953 };
2954
2955 static inline struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2956 {
2957 if (!iface)
2958 return NULL;
2959 assert(iface->lpVtbl == &d3drm_frame3_vtbl);
2960
2961 return impl_from_IDirect3DRMFrame3(iface);
2962 }
2963
2964 struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame(IDirect3DRMFrame *iface)
2965 {
2966 if (!iface)
2967 return NULL;
2968 assert(iface->lpVtbl == &d3drm_frame1_vtbl);
2969
2970 return impl_from_IDirect3DRMFrame(iface);
2971 }
2972
2973 HRESULT d3drm_frame_create(struct d3drm_frame **frame, IUnknown *parent_frame, IDirect3DRM *d3drm)
2974 {
2975 static const char classname[] = "Frame";
2976 struct d3drm_frame *object;
2977 HRESULT hr = D3DRM_OK;
2978
2979 TRACE("frame %p, parent_frame %p, d3drm %p.\n", frame, parent_frame, d3drm);
2980
2981 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2982 return E_OUTOFMEMORY;
2983
2984 object->IDirect3DRMFrame_iface.lpVtbl = &d3drm_frame1_vtbl;
2985 object->IDirect3DRMFrame2_iface.lpVtbl = &d3drm_frame2_vtbl;
2986 object->IDirect3DRMFrame3_iface.lpVtbl = &d3drm_frame3_vtbl;
2987 object->d3drm = d3drm;
2988 object->ref = 1;
2989 d3drm_set_color(&object->scenebackground, 0.0f, 0.0f, 0.0f, 1.0f);
2990 object->traversal_options = D3DRMFRAME_RENDERENABLE | D3DRMFRAME_PICKENABLE;
2991
2992 d3drm_object_init(&object->obj, classname);
2993
2994 memcpy(object->transform, identity, sizeof(D3DRMMATRIX4D));
2995
2996 if (parent_frame)
2997 {
2998 IDirect3DRMFrame3 *p;
2999
3000 if (FAILED(hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&p)))
3001 {
3002 HeapFree(GetProcessHeap(), 0, object);
3003 return hr;
3004 }
3005 IDirect3DRMFrame_Release(parent_frame);
3006 IDirect3DRMFrame3_AddChild(p, &object->IDirect3DRMFrame3_iface);
3007 }
3008
3009 IDirect3DRM_AddRef(object->d3drm);
3010
3011 *frame = object;
3012
3013 return hr;
3014 }
3015
3016 static HRESULT WINAPI d3drm_animation2_QueryInterface(IDirect3DRMAnimation2 *iface, REFIID riid, void **out)
3017 {
3018 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3019
3020 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
3021
3022 if (IsEqualGUID(riid, &IID_IDirect3DRMAnimation)
3023 || IsEqualGUID(riid, &IID_IDirect3DRMObject)
3024 || IsEqualGUID(riid, &IID_IUnknown))
3025 {
3026 *out = &animation->IDirect3DRMAnimation_iface;
3027 }
3028 else if (IsEqualGUID(riid, &IID_IDirect3DRMAnimation2))
3029 {
3030 *out = &animation->IDirect3DRMAnimation2_iface;
3031 }
3032 else
3033 {
3034 *out = NULL;
3035 WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
3036 return CLASS_E_CLASSNOTAVAILABLE;
3037 }
3038
3039 IUnknown_AddRef((IUnknown *)*out);
3040 return S_OK;
3041 }
3042
3043 static HRESULT WINAPI d3drm_animation1_QueryInterface(IDirect3DRMAnimation *iface, REFIID riid, void **out)
3044 {
3045 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3046
3047 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
3048
3049 return IDirect3DRMAnimation2_QueryInterface(&animation->IDirect3DRMAnimation2_iface, riid, out);
3050 }
3051
3052 static ULONG WINAPI d3drm_animation2_AddRef(IDirect3DRMAnimation2 *iface)
3053 {
3054 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3055 ULONG refcount = InterlockedIncrement(&animation->ref);
3056
3057 TRACE("%p increasing refcount to %u.\n", iface, refcount);
3058
3059 return refcount;
3060 }
3061
3062 static ULONG WINAPI d3drm_animation1_AddRef(IDirect3DRMAnimation *iface)
3063 {
3064 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3065 return IDirect3DRMAnimation2_AddRef(&animation->IDirect3DRMAnimation2_iface);
3066 }
3067
3068 static ULONG WINAPI d3drm_animation2_Release(IDirect3DRMAnimation2 *iface)
3069 {
3070 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3071 ULONG refcount = InterlockedDecrement(&animation->ref);
3072
3073 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
3074
3075 if (!refcount)
3076 {
3077 d3drm_object_cleanup((IDirect3DRMObject *)&animation->IDirect3DRMAnimation_iface, &animation->obj);
3078 IDirect3DRM_Release(animation->d3drm);
3079 HeapFree(GetProcessHeap(), 0, animation->rotate.keys);
3080 HeapFree(GetProcessHeap(), 0, animation->scale.keys);
3081 HeapFree(GetProcessHeap(), 0, animation->position.keys);
3082 HeapFree(GetProcessHeap(), 0, animation);
3083 }
3084
3085 return refcount;
3086 }
3087
3088 static ULONG WINAPI d3drm_animation1_Release(IDirect3DRMAnimation *iface)
3089 {
3090 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3091
3092 return IDirect3DRMAnimation2_Release(&animation->IDirect3DRMAnimation2_iface);
3093 }
3094
3095 static HRESULT WINAPI d3drm_animation2_Clone(IDirect3DRMAnimation2 *iface, IUnknown *outer, REFIID iid, void **out)
3096 {
3097 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
3098
3099 return E_NOTIMPL;
3100 }
3101
3102 static HRESULT WINAPI d3drm_animation1_Clone(IDirect3DRMAnimation *iface, IUnknown *outer, REFIID iid, void **out)
3103 {
3104 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
3105
3106 return E_NOTIMPL;
3107 }
3108
3109 static HRESULT WINAPI d3drm_animation2_AddDestroyCallback(IDirect3DRMAnimation2 *iface,
3110 D3DRMOBJECTCALLBACK cb, void *ctx)
3111 {
3112 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3113
3114 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3115
3116 return d3drm_object_add_destroy_callback(&animation->obj, cb, ctx);
3117 }
3118
3119 static HRESULT WINAPI d3drm_animation1_AddDestroyCallback(IDirect3DRMAnimation *iface,
3120 D3DRMOBJECTCALLBACK cb, void *ctx)
3121 {
3122 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3123
3124 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3125
3126 return IDirect3DRMAnimation2_AddDestroyCallback(&animation->IDirect3DRMAnimation2_iface, cb, ctx);
3127 }
3128
3129 static HRESULT WINAPI d3drm_animation2_DeleteDestroyCallback(IDirect3DRMAnimation2 *iface,
3130 D3DRMOBJECTCALLBACK cb, void *ctx)
3131 {
3132 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3133
3134 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3135
3136 return d3drm_object_delete_destroy_callback(&animation->obj, cb, ctx);
3137 }
3138
3139 static HRESULT WINAPI d3drm_animation1_DeleteDestroyCallback(IDirect3DRMAnimation *iface,
3140 D3DRMOBJECTCALLBACK cb, void *ctx)
3141 {
3142 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3143
3144 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3145
3146 return IDirect3DRMAnimation2_DeleteDestroyCallback(&animation->IDirect3DRMAnimation2_iface, cb, ctx);
3147 }
3148
3149 static HRESULT WINAPI d3drm_animation2_SetAppData(IDirect3DRMAnimation2 *iface, DWORD data)
3150 {
3151 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3152
3153 TRACE("iface %p, data %#x.\n", iface, data);
3154
3155 animation->obj.appdata = data;
3156
3157 return D3DRM_OK;
3158 }
3159
3160 static HRESULT WINAPI d3drm_animation1_SetAppData(IDirect3DRMAnimation *iface, DWORD data)
3161 {
3162 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3163
3164 TRACE("iface %p, data %#x.\n", iface, data);
3165
3166 return d3drm_animation2_SetAppData(&animation->IDirect3DRMAnimation2_iface, data);
3167 }
3168
3169 static DWORD WINAPI d3drm_animation2_GetAppData(IDirect3DRMAnimation2 *iface)
3170 {
3171 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3172
3173 TRACE("iface %p.\n", iface);
3174
3175 return animation->obj.appdata;
3176 }
3177
3178 static DWORD WINAPI d3drm_animation1_GetAppData(IDirect3DRMAnimation *iface)
3179 {
3180 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3181
3182 TRACE("iface %p.\n", iface);
3183
3184 return d3drm_animation2_GetAppData(&animation->IDirect3DRMAnimation2_iface);
3185 }
3186
3187 static HRESULT WINAPI d3drm_animation2_SetName(IDirect3DRMAnimation2 *iface, const char *name)
3188 {
3189 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3190
3191 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3192
3193 return d3drm_object_set_name(&animation->obj, name);
3194 }
3195
3196 static HRESULT WINAPI d3drm_animation1_SetName(IDirect3DRMAnimation *iface, const char *name)
3197 {
3198 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3199
3200 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3201
3202 return d3drm_animation2_SetName(&animation->IDirect3DRMAnimation2_iface, name);
3203 }
3204
3205 static HRESULT WINAPI d3drm_animation2_GetName(IDirect3DRMAnimation2 *iface, DWORD *size, char *name)
3206 {
3207 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3208
3209 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3210
3211 return d3drm_object_get_name(&animation->obj, size, name);
3212 }
3213
3214 static HRESULT WINAPI d3drm_animation1_GetName(IDirect3DRMAnimation *iface, DWORD *size, char *name)
3215 {
3216 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3217
3218 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3219
3220 return d3drm_animation2_GetName(&animation->IDirect3DRMAnimation2_iface, size, name);
3221 }
3222
3223 static HRESULT WINAPI d3drm_animation2_GetClassName(IDirect3DRMAnimation2 *iface, DWORD *size, char *name)
3224 {
3225 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3226
3227 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3228
3229 return d3drm_object_get_class_name(&animation->obj, size, name);
3230 }
3231
3232 static HRESULT WINAPI d3drm_animation1_GetClassName(IDirect3DRMAnimation *iface, DWORD *size, char *name)
3233 {
3234 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3235
3236 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3237
3238 return d3drm_animation2_GetClassName(&animation->IDirect3DRMAnimation2_iface, size, name);
3239 }
3240
3241 static HRESULT WINAPI d3drm_animation2_SetOptions(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONOPTIONS options)
3242 {
3243 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3244 static const DWORD supported_options = D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED | D3DRMANIMATION_LINEARPOSITION
3245 | D3DRMANIMATION_SPLINEPOSITION | D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION;
3246
3247 TRACE("iface %p, options %#x.\n", iface, options);
3248
3249 if (!(options & supported_options))
3250 return D3DRMERR_BADVALUE;
3251
3252 if ((options & (D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED)) == (D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED) ||
3253 (options & (D3DRMANIMATION_LINEARPOSITION | D3DRMANIMATION_SPLINEPOSITION)) ==
3254 (D3DRMANIMATION_LINEARPOSITION | D3DRMANIMATION_SPLINEPOSITION) ||
3255 (options & (D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION)) ==
3256 (D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION))
3257 {
3258 return D3DRMERR_BADVALUE;
3259 }
3260
3261 animation->options = options;
3262
3263 return D3DRM_OK;
3264 }
3265
3266 static HRESULT WINAPI d3drm_animation1_SetOptions(IDirect3DRMAnimation *iface, D3DRMANIMATIONOPTIONS options)
3267 {
3268 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3269
3270 TRACE("iface %p, %#x.\n", iface, options);
3271
3272 return d3drm_animation2_SetOptions(&animation->IDirect3DRMAnimation2_iface, options);
3273 }
3274
3275 static SIZE_T d3drm_animation_lookup_key(const struct d3drm_animation_key *keys,
3276 SIZE_T count, D3DVALUE time)
3277 {
3278 SIZE_T start = 0, cur = 0, end = count;
3279
3280 while (start < end)
3281 {
3282 cur = start + (end - start) / 2;
3283
3284 if (time == keys[cur].time)
3285 return cur;
3286
3287 if (time < keys[cur].time)
3288 end = cur;
3289 else
3290 start = cur + 1;
3291 }
3292
3293 return cur;
3294 }
3295
3296 static SIZE_T d3drm_animation_get_index_min(const struct d3drm_animation_key *keys, SIZE_T count, D3DVALUE time)
3297 {
3298 SIZE_T i;
3299
3300 i = d3drm_animation_lookup_key(keys, count, time);
3301 while (i > 0 && keys[i - 1].time == time)
3302 --i;
3303
3304 return i;
3305 }
3306
3307 static SIZE_T d3drm_animation_get_index_max(const struct d3drm_animation_key *keys, SIZE_T count, D3DVALUE time)
3308 {
3309 SIZE_T i;
3310
3311 i = d3drm_animation_lookup_key(keys, count, time);
3312 while (i < count - 1 && keys[i + 1].time == time)
3313 ++i;
3314
3315 return i;
3316 }
3317
3318 static SIZE_T d3drm_animation_get_insert_position(const struct d3drm_animation_keys *keys, D3DVALUE time)
3319 {
3320 if (!keys->count || time < keys->keys[0].time)
3321 return 0;
3322
3323 if (time >= keys->keys[keys->count - 1].time)
3324 return keys->count;
3325
3326 return d3drm_animation_get_index_max(keys->keys, keys->count, time);
3327 }
3328
3329 static const struct d3drm_animation_key *d3drm_animation_get_range(const struct d3drm_animation_keys *keys,
3330 D3DVALUE time_min, D3DVALUE time_max, SIZE_T *count)
3331 {
3332 SIZE_T min;
3333
3334 if (!keys->count || time_max < keys->keys[0].time
3335 || time_min > keys->keys[keys->count - 1].time)
3336 return NULL;
3337
3338 min = d3drm_animation_get_index_min(keys->keys, keys->count, time_min);
3339 if (count)
3340 *count = d3drm_animation_get_index_max(&keys->keys[min], keys->count - min, time_max) - min + 1;
3341
3342 return &keys->keys[min];
3343 }
3344
3345 static HRESULT WINAPI d3drm_animation2_AddKey(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONKEY *key)
3346 {
3347 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3348 struct d3drm_animation_keys *keys;
3349 SIZE_T index;
3350
3351 TRACE("iface %p, key %p.\n", iface, key);
3352
3353 if (!key || key->dwSize != sizeof(*key))
3354 return E_INVALIDARG;
3355
3356 switch (key->dwKeyType)
3357 {
3358 case D3DRMANIMATION_POSITIONKEY:
3359 keys = &animation->position;
3360 break;
3361 case D3DRMANIMATION_SCALEKEY:
3362 keys = &animation->scale;
3363 break;
3364 case D3DRMANIMATION_ROTATEKEY:
3365 keys = &animation->rotate;
3366 break;
3367 default:
3368 return E_INVALIDARG;
3369 }
3370
3371 index = d3drm_animation_get_insert_position(keys, key->dvTime);
3372
3373 if (!d3drm_array_reserve((void **)&keys->keys, &keys->size, keys->count + 1, sizeof(*keys->keys)))
3374 return E_OUTOFMEMORY;
3375
3376 if (index < keys->count)
3377 memmove(&keys->keys[index + 1], &keys->keys[index], sizeof(*keys->keys) * (keys->count - index));
3378 keys->keys[index].time = key->dvTime;
3379 switch (key->dwKeyType)
3380 {
3381 case D3DRMANIMATION_POSITIONKEY:
3382 keys->keys[index].u.position = key->u.dvPositionKey;
3383 break;
3384 case D3DRMANIMATION_SCALEKEY:
3385 keys->keys[index].u.scale = key->u.dvScaleKey;
3386 break;
3387 case D3DRMANIMATION_ROTATEKEY:
3388 keys->keys[index].u.rotate = key->u.dqRotateKey;
3389 break;
3390 }
3391 ++keys->count;
3392
3393 return D3DRM_OK;
3394 }
3395
3396 static HRESULT WINAPI d3drm_animation2_AddRotateKey(IDirect3DRMAnimation2 *iface, D3DVALUE time, D3DRMQUATERNION *q)
3397 {
3398 D3DRMANIMATIONKEY key;
3399
3400 TRACE("iface %p, time %.8e, q %p.\n", iface, time, q);
3401
3402 key.dwSize = sizeof(key);
3403 key.dwKeyType = D3DRMANIMATION_ROTATEKEY;
3404 key.dvTime = time;
3405 key.dwID = 0;
3406 key.u.dqRotateKey = *q;
3407
3408 return d3drm_animation2_AddKey(iface, &key);
3409 }
3410
3411 static HRESULT WINAPI d3drm_animation1_AddRotateKey(IDirect3DRMAnimation *iface, D3DVALUE time, D3DRMQUATERNION *q)
3412 {
3413 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3414
3415 TRACE("iface %p, time %.8e, q %p.\n", iface, time, q);
3416
3417 return d3drm_animation2_AddRotateKey(&animation->IDirect3DRMAnimation2_iface, time, q);
3418 }
3419
3420 static HRESULT WINAPI d3drm_animation2_AddPositionKey(IDirect3DRMAnimation2 *iface, D3DVALUE time,
3421 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3422 {
3423 D3DRMANIMATIONKEY key;
3424
3425 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3426
3427 key.dwSize = sizeof(key);
3428 key.dwKeyType = D3DRMANIMATION_POSITIONKEY;
3429 key.dvTime = time;
3430 key.dwID = 0;
3431 key.u.dvPositionKey.u1.x = x;
3432 key.u.dvPositionKey.u2.y = y;
3433 key.u.dvPositionKey.u3.z = z;
3434
3435 return d3drm_animation2_AddKey(iface, &key);
3436 }
3437
3438 static HRESULT WINAPI d3drm_animation1_AddPositionKey(IDirect3DRMAnimation *iface, D3DVALUE time,
3439 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3440 {
3441 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3442
3443 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3444
3445 return d3drm_animation2_AddPositionKey(&animation->IDirect3DRMAnimation2_iface, time, x, y, z);
3446 }
3447
3448 static HRESULT WINAPI d3drm_animation2_AddScaleKey(IDirect3DRMAnimation2 *iface, D3DVALUE time,
3449 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3450 {
3451 D3DRMANIMATIONKEY key;
3452
3453 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3454
3455 key.dwSize = sizeof(key);
3456 key.dwKeyType = D3DRMANIMATION_SCALEKEY;
3457 key.dvTime = time;
3458 key.dwID = 0;
3459 key.u.dvScaleKey.u1.x = x;
3460 key.u.dvScaleKey.u2.y = y;
3461 key.u.dvScaleKey.u3.z = z;
3462
3463 return d3drm_animation2_AddKey(iface, &key);
3464 }
3465
3466 static HRESULT WINAPI d3drm_animation1_AddScaleKey(IDirect3DRMAnimation *iface, D3DVALUE time,
3467 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3468 {
3469 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3470
3471 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3472
3473 return d3drm_animation2_AddScaleKey(&animation->IDirect3DRMAnimation2_iface, time, x, y, z);
3474 }
3475
3476 static void d3drm_animation_delete_key(struct d3drm_animation_keys *keys, const struct d3drm_animation_key *key)
3477 {
3478 SIZE_T index = key - keys->keys;
3479
3480 if (index < keys->count - 1)
3481 memmove(&keys->keys[index], &keys->keys[index + 1], sizeof(*keys->keys) * (keys->count - index - 1));
3482 --keys->count;
3483 }
3484
3485 static HRESULT WINAPI d3drm_animation2_DeleteKey(IDirect3DRMAnimation2 *iface, D3DVALUE time)
3486 {
3487 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3488 const struct d3drm_animation_key *key;
3489
3490 TRACE("iface %p, time %.8e.\n", iface, time);
3491
3492 if ((key = d3drm_animation_get_range(&animation->rotate, time, time, NULL)))
3493 d3drm_animation_delete_key(&animation->rotate, key);
3494
3495 if ((key = d3drm_animation_get_range(&animation->position, time, time, NULL)))
3496 d3drm_animation_delete_key(&animation->position, key);
3497
3498 if ((key = d3drm_animation_get_range(&animation->scale, time, time, NULL)))
3499 d3drm_animation_delete_key(&animation->scale, key);
3500
3501 return D3DRM_OK;
3502 }
3503
3504 static HRESULT WINAPI d3drm_animation1_DeleteKey(IDirect3DRMAnimation *iface, D3DVALUE time)
3505 {
3506 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3507
3508 TRACE("iface %p, time %.8e.\n", iface, time);
3509
3510 return d3drm_animation2_DeleteKey(&animation->IDirect3DRMAnimation2_iface, time);
3511 }
3512
3513 static HRESULT WINAPI d3drm_animation1_SetFrame(IDirect3DRMAnimation *iface, IDirect3DRMFrame *frame)
3514 {
3515 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3516 HRESULT hr = D3DRM_OK;
3517
3518 TRACE("iface %p, frame %p.\n", iface, frame);
3519
3520 if (frame)
3521 {
3522 hr = IDirect3DRMFrame_QueryInterface(frame, &IID_IDirect3DRMFrame3, (void **)&animation->frame);
3523 if (SUCCEEDED(hr))
3524 IDirect3DRMFrame3_Release(animation->frame);
3525 }
3526 else
3527 animation->frame = NULL;
3528
3529 return hr;
3530 }
3531
3532 static HRESULT WINAPI d3drm_animation1_SetTime(IDirect3DRMAnimation *iface, D3DVALUE time)
3533 {
3534 FIXME("iface %p, time %.8e.\n", iface, time);
3535
3536 return E_NOTIMPL;
3537 }
3538
3539 static D3DRMANIMATIONOPTIONS WINAPI d3drm_animation2_GetOptions(IDirect3DRMAnimation2 *iface)
3540 {
3541 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3542
3543 TRACE("iface %p.\n", iface);
3544
3545 return animation->options;
3546 }
3547
3548 static D3DRMANIMATIONOPTIONS WINAPI d3drm_animation1_GetOptions(IDirect3DRMAnimation *iface)
3549 {
3550 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3551
3552 TRACE("iface %p.\n", iface);
3553
3554 return d3drm_animation2_GetOptions(&animation->IDirect3DRMAnimation2_iface);
3555 }
3556
3557 static HRESULT WINAPI d3drm_animation2_SetFrame(IDirect3DRMAnimation2 *iface, IDirect3DRMFrame3 *frame)
3558 {
3559 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3560
3561 TRACE("iface %p, frame %p.\n", iface, frame);
3562
3563 animation->frame = frame;
3564
3565 return D3DRM_OK;
3566 }
3567
3568 static HRESULT WINAPI d3drm_animation2_SetTime(IDirect3DRMAnimation2 *iface, D3DVALUE time)
3569 {
3570 FIXME("iface %p, time %.8e.\n", iface, time);
3571
3572 return E_NOTIMPL;
3573 }
3574
3575 static HRESULT WINAPI d3drm_animation2_GetFrame(IDirect3DRMAnimation2 *iface, IDirect3DRMFrame3 **frame)
3576 {
3577 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3578
3579 TRACE("iface %p, frame %p.\n", iface, frame);
3580
3581 if (!frame)
3582 return D3DRMERR_BADVALUE;
3583
3584 *frame = animation->frame;
3585 if (*frame)
3586 IDirect3DRMFrame3_AddRef(*frame);
3587
3588 return D3DRM_OK;
3589 }
3590
3591 static HRESULT WINAPI d3drm_animation2_DeleteKeyByID(IDirect3DRMAnimation2 *iface, DWORD id)
3592 {
3593 FIXME("iface %p, id %#x.\n", iface, id);
3594
3595 return E_NOTIMPL;
3596 }
3597
3598 static HRESULT WINAPI d3drm_animation2_ModifyKey(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONKEY *key)
3599 {
3600 FIXME("iface %p, key %p.\n", iface, key);
3601
3602 return E_NOTIMPL;
3603 }
3604
3605 static HRESULT WINAPI d3drm_animation2_GetKeys(IDirect3DRMAnimation2 *iface, D3DVALUE time_min, D3DVALUE time_max,
3606 DWORD *key_count, D3DRMANIMATIONKEY *keys)
3607 {
3608 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3609 const struct d3drm_animation_key *key;
3610 SIZE_T count, i;
3611
3612 TRACE("iface %p, time min %.8e, time max %.8e, key_count %p, keys %p.\n",
3613 iface, time_min, time_max, key_count, keys);
3614
3615 if (!key_count)
3616 return D3DRMERR_BADVALUE;
3617
3618 *key_count = 0;
3619
3620 if ((key = d3drm_animation_get_range(&animation->rotate, time_min, time_max, &count)))
3621 {
3622 if (keys)
3623 {
3624 for (i = 0; i < count; ++i)
3625 {
3626 keys[i].dwSize = sizeof(*keys);
3627 keys[i].dwKeyType = D3DRMANIMATION_ROTATEKEY;
3628 keys[i].dvTime = key[i].time;
3629 keys[i].dwID = 0; /* FIXME */
3630 keys[i].u.dqRotateKey = key[i].u.rotate;
3631 }
3632 keys += count;
3633 }
3634 *key_count += count;
3635 }
3636
3637 if ((key = d3drm_animation_get_range(&animation->position, time_min, time_max, &count)))
3638 {
3639 if (keys)
3640 {
3641 for (i = 0; i < count; ++i)
3642 {
3643 keys[i].dwSize = sizeof(*keys);
3644 keys[i].dwKeyType = D3DRMANIMATION_POSITIONKEY;
3645 keys[i].dvTime = key[i].time;
3646 keys[i].dwID = 0; /* FIXME */
3647 keys[i].u.dvPositionKey = key[i].u.position;
3648 }
3649 keys += count;
3650 }
3651 *key_count += count;
3652 }
3653
3654 if ((key = d3drm_animation_get_range(&animation->scale, time_min, time_max, &count)))
3655 {
3656 if (keys)
3657 {
3658 for (i = 0; keys && i < count; ++i)
3659 {
3660 keys[i].dwSize = sizeof(*keys);
3661 keys[i].dwKeyType = D3DRMANIMATION_SCALEKEY;
3662 keys[i].dvTime = key[i].time;
3663 keys[i].dwID = 0; /* FIXME */
3664 keys[i].u.dvScaleKey = key[i].u.scale;
3665 }
3666 keys += count;
3667 }
3668 *key_count += count;
3669 }
3670
3671 return *key_count ? D3DRM_OK : D3DRMERR_NOSUCHKEY;
3672 }
3673
3674 static const struct IDirect3DRMAnimationVtbl d3drm_animation1_vtbl =
3675 {
3676 d3drm_animation1_QueryInterface,
3677 d3drm_animation1_AddRef,
3678 d3drm_animation1_Release,
3679 d3drm_animation1_Clone,
3680 d3drm_animation1_AddDestroyCallback,
3681 d3drm_animation1_DeleteDestroyCallback,
3682 d3drm_animation1_SetAppData,
3683 d3drm_animation1_GetAppData,
3684 d3drm_animation1_SetName,
3685 d3drm_animation1_GetName,
3686 d3drm_animation1_GetClassName,
3687 d3drm_animation1_SetOptions,
3688 d3drm_animation1_AddRotateKey,
3689 d3drm_animation1_AddPositionKey,
3690 d3drm_animation1_AddScaleKey,
3691 d3drm_animation1_DeleteKey,
3692 d3drm_animation1_SetFrame,
3693 d3drm_animation1_SetTime,
3694 d3drm_animation1_GetOptions,
3695 };
3696
3697 static const struct IDirect3DRMAnimation2Vtbl d3drm_animation2_vtbl =
3698 {
3699 d3drm_animation2_QueryInterface,
3700 d3drm_animation2_AddRef,
3701 d3drm_animation2_Release,
3702 d3drm_animation2_Clone,
3703 d3drm_animation2_AddDestroyCallback,
3704 d3drm_animation2_DeleteDestroyCallback,
3705 d3drm_animation2_SetAppData,
3706 d3drm_animation2_GetAppData,
3707 d3drm_animation2_SetName,
3708 d3drm_animation2_GetName,
3709 d3drm_animation2_GetClassName,
3710 d3drm_animation2_SetOptions,
3711 d3drm_animation2_AddRotateKey,
3712 d3drm_animation2_AddPositionKey,
3713 d3drm_animation2_AddScaleKey,
3714 d3drm_animation2_DeleteKey,
3715 d3drm_animation2_SetFrame,
3716 d3drm_animation2_SetTime,
3717 d3drm_animation2_GetOptions,
3718 d3drm_animation2_GetFrame,
3719 d3drm_animation2_DeleteKeyByID,
3720 d3drm_animation2_AddKey,
3721 d3drm_animation2_ModifyKey,
3722 d3drm_animation2_GetKeys,
3723 };
3724
3725 HRESULT d3drm_animation_create(struct d3drm_animation **animation, IDirect3DRM *d3drm)
3726 {
3727 static const char classname[] = "Animation";
3728 struct d3drm_animation *object;
3729 HRESULT hr = D3DRM_OK;
3730
3731 TRACE("animation %p, d3drm %p.\n", animation, d3drm);
3732
3733 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
3734 return E_OUTOFMEMORY;
3735
3736 object->IDirect3DRMAnimation_iface.lpVtbl = &d3drm_animation1_vtbl;
3737 object->IDirect3DRMAnimation2_iface.lpVtbl = &d3drm_animation2_vtbl;
3738 object->d3drm = d3drm;
3739 object->ref = 1;
3740 object->options = D3DRMANIMATION_CLOSED | D3DRMANIMATION_LINEARPOSITION;
3741
3742 d3drm_object_init(&object->obj, classname);
3743
3744 IDirect3DRM_AddRef(object->d3drm);
3745
3746 *animation = object;
3747
3748 return hr;
3749 }
Windows API implementation