?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ddraw/tests: Rewrite LimitTest().
[wine.git] / dlls / d3drm / frame.c
blobaa7633b07cc37b3f6f2e65f77c6adb8fbe86460e
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 *frame = impl_from_IDirect3DRMFrame3(iface);
879 ULONG i;
880
881 TRACE("iface %p, light %p.\n", iface, light);
882
883 if (!light)
884 return D3DRMERR_BADOBJECT;
885
886 /* Check if already existing and return gracefully without increasing ref count */
887 for (i = 0; i < frame->nb_lights; i++)
888 if (frame->lights[i] == light)
889 return D3DRM_OK;
890
891 if (!d3drm_array_reserve((void **)&frame->lights, &frame->lights_size,
892 frame->nb_lights + 1, sizeof(*frame->lights)))
893 return E_OUTOFMEMORY;
894
895 frame->lights[frame->nb_lights++] = light;
896 IDirect3DRMLight_AddRef(light);
897
898 return D3DRM_OK;
899 }
900
901 static HRESULT WINAPI d3drm_frame2_AddLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
902 {
903 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
904
905 TRACE("iface %p, light %p.\n", iface, light);
906
907 return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
908 }
909
910 static HRESULT WINAPI d3drm_frame1_AddLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
911 {
912 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
913
914 TRACE("iface %p, light %p.\n", iface, light);
915
916 return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
917 }
918
919 static HRESULT WINAPI d3drm_frame3_AddMoveCallback(IDirect3DRMFrame3 *iface,
920 D3DRMFRAME3MOVECALLBACK cb, void *ctx, DWORD flags)
921 {
922 FIXME("iface %p, cb %p, ctx %p flags %#x stub!\n", iface, cb, ctx, flags);
923
924 return E_NOTIMPL;
925 }
926
927 static HRESULT WINAPI d3drm_frame2_AddMoveCallback(IDirect3DRMFrame2 *iface,
928 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
929 {
930 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
931
932 return E_NOTIMPL;
933 }
934
935 static HRESULT WINAPI d3drm_frame1_AddMoveCallback(IDirect3DRMFrame *iface,
936 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
937 {
938 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
939
940 return E_NOTIMPL;
941 }
942
943 static HRESULT WINAPI d3drm_frame3_AddTransform(IDirect3DRMFrame3 *iface,
944 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
945 {
946 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
947
948 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
949
950 switch (type)
951 {
952 case D3DRMCOMBINE_REPLACE:
953 memcpy(frame->transform, matrix, sizeof(D3DRMMATRIX4D));
954 break;
955
956 case D3DRMCOMBINE_BEFORE:
957 FIXME("D3DRMCOMBINE_BEFORE not supported yet\n");
958 break;
959
960 case D3DRMCOMBINE_AFTER:
961 FIXME("D3DRMCOMBINE_AFTER not supported yet\n");
962 break;
963
964 default:
965 WARN("Unknown Combine Type %u\n", type);
966 return D3DRMERR_BADVALUE;
967 }
968
969 return S_OK;
970 }
971
972 static HRESULT WINAPI d3drm_frame2_AddTransform(IDirect3DRMFrame2 *iface,
973 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
974 {
975 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
976
977 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
978
979 return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
980 }
981
982 static HRESULT WINAPI d3drm_frame1_AddTransform(IDirect3DRMFrame *iface,
983 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
984 {
985 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
986
987 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
988
989 return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
990 }
991
992 static HRESULT WINAPI d3drm_frame3_AddTranslation(IDirect3DRMFrame3 *iface,
993 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
994 {
995 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
996
997 return E_NOTIMPL;
998 }
999
1000 static HRESULT WINAPI d3drm_frame2_AddTranslation(IDirect3DRMFrame2 *iface,
1001 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1002 {
1003 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
1004
1005 return E_NOTIMPL;
1006 }
1007
1008 static HRESULT WINAPI d3drm_frame1_AddTranslation(IDirect3DRMFrame *iface,
1009 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1010 {
1011 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
1012
1013 return E_NOTIMPL;
1014 }
1015
1016 static HRESULT WINAPI d3drm_frame3_AddScale(IDirect3DRMFrame3 *iface,
1017 D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1018 {
1019 FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1020
1021 return E_NOTIMPL;
1022 }
1023
1024 static HRESULT WINAPI d3drm_frame2_AddScale(IDirect3DRMFrame2 *iface,
1025 D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1026 {
1027 FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1028
1029 return E_NOTIMPL;
1030 }
1031
1032 static HRESULT WINAPI d3drm_frame1_AddScale(IDirect3DRMFrame *iface,
1033 D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1034 {
1035 FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1036
1037 return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI d3drm_frame3_AddRotation(IDirect3DRMFrame3 *iface,
1041 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1042 {
1043 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
1044 iface, type, x, y, z, theta);
1045
1046 return E_NOTIMPL;
1047 }
1048
1049 static HRESULT WINAPI d3drm_frame2_AddRotation(IDirect3DRMFrame2 *iface,
1050 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1051 {
1052 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n", iface, type, x, y, z, theta);
1053
1054 return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI d3drm_frame1_AddRotation(IDirect3DRMFrame *iface,
1058 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1059 {
1060 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n", iface, type, x, y, z, theta);
1061
1062 return E_NOTIMPL;
1063 }
1064
1065 static HRESULT WINAPI d3drm_frame3_AddVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1066 {
1067 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1068 ULONG i;
1069
1070 TRACE("iface %p, visual %p.\n", iface, visual);
1071
1072 if (!visual)
1073 return D3DRMERR_BADOBJECT;
1074
1075 /* Check if already existing and return gracefully without increasing ref count */
1076 for (i = 0; i < frame->nb_visuals; i++)
1077 if (frame->visuals[i] == (IDirect3DRMVisual *)visual)
1078 return D3DRM_OK;
1079
1080 if (!d3drm_array_reserve((void **)&frame->visuals, &frame->visuals_size,
1081 frame->nb_visuals + 1, sizeof(*frame->visuals)))
1082 return E_OUTOFMEMORY;
1083
1084 frame->visuals[frame->nb_visuals++] = (IDirect3DRMVisual *)visual;
1085 IDirect3DRMVisual_AddRef(visual);
1086
1087 return D3DRM_OK;
1088 }
1089
1090 static HRESULT WINAPI d3drm_frame2_AddVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1091 {
1092 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1093
1094 TRACE("iface %p, visual %p.\n", iface, visual);
1095
1096 return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1097 }
1098
1099 static HRESULT WINAPI d3drm_frame1_AddVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1100 {
1101 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1102
1103 TRACE("iface %p, visual %p.\n", iface, visual);
1104
1105 return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1106 }
1107
1108 static HRESULT WINAPI d3drm_frame3_GetChildren(IDirect3DRMFrame3 *iface, IDirect3DRMFrameArray **children)
1109 {
1110 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1111 struct d3drm_frame_array *array;
1112
1113 TRACE("iface %p, children %p.\n", iface, children);
1114
1115 if (!children)
1116 return D3DRMERR_BADVALUE;
1117
1118 if (!(array = d3drm_frame_array_create(frame->nb_children, frame->children)))
1119 return E_OUTOFMEMORY;
1120
1121 *children = &array->IDirect3DRMFrameArray_iface;
1122
1123 return D3DRM_OK;
1124 }
1125
1126 static HRESULT WINAPI d3drm_frame2_GetChildren(IDirect3DRMFrame2 *iface, IDirect3DRMFrameArray **children)
1127 {
1128 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1129
1130 TRACE("iface %p, children %p.\n", iface, children);
1131
1132 return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1133 }
1134
1135 static HRESULT WINAPI d3drm_frame1_GetChildren(IDirect3DRMFrame *iface, IDirect3DRMFrameArray **children)
1136 {
1137 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1138
1139 TRACE("iface %p, children %p.\n", iface, children);
1140
1141 return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1142 }
1143
1144 static D3DCOLOR WINAPI d3drm_frame3_GetColor(IDirect3DRMFrame3 *iface)
1145 {
1146 FIXME("iface %p stub!\n", iface);
1147
1148 return 0;
1149 }
1150
1151 static D3DCOLOR WINAPI d3drm_frame2_GetColor(IDirect3DRMFrame2 *iface)
1152 {
1153 FIXME("iface %p stub!\n", iface);
1154
1155 return 0;
1156 }
1157
1158 static D3DCOLOR WINAPI d3drm_frame1_GetColor(IDirect3DRMFrame *iface)
1159 {
1160 FIXME("iface %p stub!\n", iface);
1161
1162 return 0;
1163 }
1164
1165 static HRESULT WINAPI d3drm_frame3_GetLights(IDirect3DRMFrame3 *iface, IDirect3DRMLightArray **lights)
1166 {
1167 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1168 struct d3drm_light_array *array;
1169
1170 TRACE("iface %p, lights %p.\n", iface, lights);
1171
1172 if (!lights)
1173 return D3DRMERR_BADVALUE;
1174
1175 if (!(array = d3drm_light_array_create(frame->nb_lights, frame->lights)))
1176 return E_OUTOFMEMORY;
1177
1178 *lights = &array->IDirect3DRMLightArray_iface;
1179
1180 return D3DRM_OK;
1181 }
1182
1183 static HRESULT WINAPI d3drm_frame2_GetLights(IDirect3DRMFrame2 *iface, IDirect3DRMLightArray **lights)
1184 {
1185 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1186
1187 TRACE("iface %p, lights %p.\n", iface, lights);
1188
1189 return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1190 }
1191
1192 static HRESULT WINAPI d3drm_frame1_GetLights(IDirect3DRMFrame *iface, IDirect3DRMLightArray **lights)
1193 {
1194 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1195
1196 TRACE("iface %p, lights %p.\n", iface, lights);
1197
1198 return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1199 }
1200
1201 static D3DRMMATERIALMODE WINAPI d3drm_frame3_GetMaterialMode(IDirect3DRMFrame3 *iface)
1202 {
1203 FIXME("iface %p stub!\n", iface);
1204
1205 return D3DRMMATERIAL_FROMPARENT;
1206 }
1207
1208 static D3DRMMATERIALMODE WINAPI d3drm_frame2_GetMaterialMode(IDirect3DRMFrame2 *iface)
1209 {
1210 FIXME("iface %p stub!\n", iface);
1211
1212 return D3DRMMATERIAL_FROMPARENT;
1213 }
1214
1215 static D3DRMMATERIALMODE WINAPI d3drm_frame1_GetMaterialMode(IDirect3DRMFrame *iface)
1216 {
1217 FIXME("iface %p stub!\n", iface);
1218
1219 return D3DRMMATERIAL_FROMPARENT;
1220 }
1221
1222 static HRESULT WINAPI d3drm_frame3_GetParent(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **parent)
1223 {
1224 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1225
1226 TRACE("iface %p, parent %p.\n", iface, parent);
1227
1228 if (!parent)
1229 return D3DRMERR_BADVALUE;
1230
1231 if (frame->parent)
1232 {
1233 *parent = &frame->parent->IDirect3DRMFrame3_iface;
1234 IDirect3DRMFrame_AddRef(*parent);
1235 }
1236 else
1237 {
1238 *parent = NULL;
1239 }
1240
1241 return D3DRM_OK;
1242 }
1243
1244 static HRESULT WINAPI d3drm_frame2_GetParent(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **parent)
1245 {
1246 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1247
1248 TRACE("iface %p, parent %p.\n", iface, parent);
1249
1250 if (!parent)
1251 return D3DRMERR_BADVALUE;
1252
1253 if (frame->parent)
1254 {
1255 *parent = &frame->parent->IDirect3DRMFrame_iface;
1256 IDirect3DRMFrame_AddRef(*parent);
1257 }
1258 else
1259 {
1260 *parent = NULL;
1261 }
1262
1263 return D3DRM_OK;
1264 }
1265
1266 static HRESULT WINAPI d3drm_frame1_GetParent(IDirect3DRMFrame *iface, IDirect3DRMFrame **parent)
1267 {
1268 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1269
1270 TRACE("iface %p, parent %p.\n", iface, parent);
1271
1272 return d3drm_frame2_GetParent(&frame->IDirect3DRMFrame2_iface, parent);
1273 }
1274
1275 static HRESULT WINAPI d3drm_frame3_GetPosition(IDirect3DRMFrame3 *iface,
1276 IDirect3DRMFrame3 *reference, D3DVECTOR *position)
1277 {
1278 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1279
1280 return E_NOTIMPL;
1281 }
1282
1283 static HRESULT WINAPI d3drm_frame2_GetPosition(IDirect3DRMFrame2 *iface,
1284 IDirect3DRMFrame *reference, D3DVECTOR *position)
1285 {
1286 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1287
1288 return E_NOTIMPL;
1289 }
1290
1291 static HRESULT WINAPI d3drm_frame1_GetPosition(IDirect3DRMFrame *iface,
1292 IDirect3DRMFrame *reference, D3DVECTOR *position)
1293 {
1294 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1295
1296 return E_NOTIMPL;
1297 }
1298
1299
1300 static HRESULT WINAPI d3drm_frame3_GetRotation(IDirect3DRMFrame3 *iface,
1301 IDirect3DRMFrame3 *reference, D3DVECTOR *axis, D3DVALUE *theta)
1302 {
1303 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1304
1305 return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI d3drm_frame2_GetRotation(IDirect3DRMFrame2 *iface,
1309 IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1310 {
1311 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1312
1313 return E_NOTIMPL;
1314 }
1315
1316 static HRESULT WINAPI d3drm_frame1_GetRotation(IDirect3DRMFrame *iface,
1317 IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1318 {
1319 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1320
1321 return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI d3drm_frame3_GetScene(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **scene)
1325 {
1326 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1327
1328 TRACE("iface %p, scene %p.\n", iface, scene);
1329
1330 if (!scene)
1331 return D3DRMERR_BADVALUE;
1332
1333 while (frame->parent)
1334 frame = frame->parent;
1335
1336 *scene = &frame->IDirect3DRMFrame3_iface;
1337 IDirect3DRMFrame3_AddRef(*scene);
1338
1339 return D3DRM_OK;
1340 }
1341
1342 static HRESULT WINAPI d3drm_frame2_GetScene(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **scene)
1343 {
1344 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1345 IDirect3DRMFrame3 *frame3;
1346 HRESULT hr;
1347
1348 TRACE("iface %p, scene %p.\n", iface, scene);
1349
1350 if (!scene)
1351 return D3DRMERR_BADVALUE;
1352
1353 hr = IDirect3DRMFrame3_GetScene(&frame->IDirect3DRMFrame3_iface, &frame3);
1354 if (FAILED(hr) || !frame3)
1355 {
1356 *scene = NULL;
1357 return hr;
1358 }
1359
1360 hr = IDirect3DRMFrame3_QueryInterface(frame3, &IID_IDirect3DRMFrame, (void **)scene);
1361 IDirect3DRMFrame3_Release(frame3);
1362
1363 return hr;
1364 }
1365
1366 static HRESULT WINAPI d3drm_frame1_GetScene(IDirect3DRMFrame *iface, IDirect3DRMFrame **scene)
1367 {
1368 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1369
1370 TRACE("iface %p, scene %p.\n", iface, scene);
1371
1372 return d3drm_frame2_GetScene(&frame->IDirect3DRMFrame2_iface, scene);
1373 }
1374
1375 static D3DRMSORTMODE WINAPI d3drm_frame3_GetSortMode(IDirect3DRMFrame3 *iface)
1376 {
1377 FIXME("iface %p stub!\n", iface);
1378
1379 return D3DRMSORT_FROMPARENT;
1380 }
1381
1382 static D3DRMSORTMODE WINAPI d3drm_frame2_GetSortMode(IDirect3DRMFrame2 *iface)
1383 {
1384 FIXME("iface %p stub!\n", iface);
1385
1386 return D3DRMSORT_FROMPARENT;
1387 }
1388
1389 static D3DRMSORTMODE WINAPI d3drm_frame1_GetSortMode(IDirect3DRMFrame *iface)
1390 {
1391 FIXME("iface %p stub!\n", iface);
1392
1393 return D3DRMSORT_FROMPARENT;
1394 }
1395
1396 static HRESULT WINAPI d3drm_frame3_GetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 **texture)
1397 {
1398 FIXME("iface %p, texture %p stub!\n", iface, texture);
1399
1400 return E_NOTIMPL;
1401 }
1402
1403 static HRESULT WINAPI d3drm_frame2_GetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture **texture)
1404 {
1405 FIXME("iface %p, texture %p stub!\n", iface, texture);
1406
1407 return E_NOTIMPL;
1408 }
1409
1410 static HRESULT WINAPI d3drm_frame1_GetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture **texture)
1411 {
1412 FIXME("iface %p, texture %p stub!\n", iface, texture);
1413
1414 return E_NOTIMPL;
1415 }
1416
1417 static HRESULT WINAPI d3drm_frame3_GetTransform(IDirect3DRMFrame3 *iface,
1418 IDirect3DRMFrame3 *reference, D3DRMMATRIX4D matrix)
1419 {
1420 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1421
1422 TRACE("iface %p, reference %p, matrix %p.\n", iface, reference, matrix);
1423
1424 if (reference)
1425 FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1426
1427 memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
1428
1429 return D3DRM_OK;
1430 }
1431
1432 static HRESULT WINAPI d3drm_frame2_GetTransform(IDirect3DRMFrame2 *iface, D3DRMMATRIX4D matrix)
1433 {
1434 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1435
1436 TRACE("iface %p, matrix %p.\n", iface, matrix);
1437
1438 memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
1439
1440 return D3DRM_OK;
1441 }
1442
1443 static HRESULT WINAPI d3drm_frame1_GetTransform(IDirect3DRMFrame *iface, D3DRMMATRIX4D matrix)
1444 {
1445 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1446
1447 TRACE("iface %p, matrix %p.\n", iface, matrix);
1448
1449 return d3drm_frame2_GetTransform(&frame->IDirect3DRMFrame2_iface, matrix);
1450 }
1451
1452 static HRESULT WINAPI d3drm_frame3_GetVelocity(IDirect3DRMFrame3 *iface,
1453 IDirect3DRMFrame3 *reference, D3DVECTOR *velocity, BOOL with_rotation)
1454 {
1455 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1456 iface, reference, velocity, with_rotation);
1457
1458 return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI d3drm_frame2_GetVelocity(IDirect3DRMFrame2 *iface,
1462 IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1463 {
1464 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1465 iface, reference, velocity, with_rotation);
1466
1467 return E_NOTIMPL;
1468 }
1469
1470 static HRESULT WINAPI d3drm_frame1_GetVelocity(IDirect3DRMFrame *iface,
1471 IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1472 {
1473 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1474 iface, reference, velocity, with_rotation);
1475
1476 return E_NOTIMPL;
1477 }
1478
1479 static HRESULT WINAPI d3drm_frame3_GetOrientation(IDirect3DRMFrame3 *iface,
1480 IDirect3DRMFrame3 *reference, D3DVECTOR *dir, D3DVECTOR *up)
1481 {
1482 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1483
1484 return E_NOTIMPL;
1485 }
1486
1487 static HRESULT WINAPI d3drm_frame2_GetOrientation(IDirect3DRMFrame2 *iface,
1488 IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1489 {
1490 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1491
1492 return E_NOTIMPL;
1493 }
1494
1495 static HRESULT WINAPI d3drm_frame1_GetOrientation(IDirect3DRMFrame *iface,
1496 IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1497 {
1498 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1499
1500 return E_NOTIMPL;
1501 }
1502
1503 static HRESULT WINAPI d3drm_frame3_GetVisuals(IDirect3DRMFrame3 *iface, DWORD *count, IUnknown **visuals)
1504 {
1505 FIXME("iface %p, count %p, visuals %p stub!\n", iface, count, visuals);
1506
1507 return E_NOTIMPL;
1508 }
1509
1510 static HRESULT WINAPI d3drm_frame2_GetVisuals(IDirect3DRMFrame2 *iface, IDirect3DRMVisualArray **visuals)
1511 {
1512 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1513 struct d3drm_visual_array *array;
1514
1515 TRACE("iface %p, visuals %p.\n", iface, visuals);
1516
1517 if (!visuals)
1518 return D3DRMERR_BADVALUE;
1519
1520 if (!(array = d3drm_visual_array_create(frame->nb_visuals, frame->visuals)))
1521 return E_OUTOFMEMORY;
1522
1523 *visuals = &array->IDirect3DRMVisualArray_iface;
1524
1525 return D3DRM_OK;
1526 }
1527
1528 static HRESULT WINAPI d3drm_frame1_GetVisuals(IDirect3DRMFrame *iface, IDirect3DRMVisualArray **visuals)
1529 {
1530 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1531
1532 TRACE("iface %p, visuals %p.\n", iface, visuals);
1533
1534 return d3drm_frame2_GetVisuals(&frame->IDirect3DRMFrame2_iface, visuals);
1535 }
1536
1537 static HRESULT WINAPI d3drm_frame2_GetTextureTopology(IDirect3DRMFrame2 *iface, BOOL *wrap_u, BOOL *wrap_v)
1538 {
1539 FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1540
1541 return E_NOTIMPL;
1542 }
1543
1544 static HRESULT WINAPI d3drm_frame1_GetTextureTopology(IDirect3DRMFrame *iface, BOOL *wrap_u, BOOL *wrap_v)
1545 {
1546 FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1547
1548 return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI d3drm_frame3_InverseTransform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
1552 {
1553 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1554
1555 return E_NOTIMPL;
1556 }
1557
1558 static HRESULT WINAPI d3drm_frame2_InverseTransform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
1559 {
1560 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1561
1562 return E_NOTIMPL;
1563 }
1564
1565 static HRESULT WINAPI d3drm_frame1_InverseTransform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
1566 {
1567 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1568
1569 return E_NOTIMPL;
1570 }
1571
1572 static HRESULT WINAPI d3drm_frame3_Load(IDirect3DRMFrame3 *iface, void *filename,
1573 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURE3CALLBACK cb, void *ctx)
1574 {
1575 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1576 iface, filename, name, flags, cb, ctx);
1577
1578 return E_NOTIMPL;
1579 }
1580
1581 static HRESULT WINAPI d3drm_frame2_Load(IDirect3DRMFrame2 *iface, void *filename,
1582 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1583 {
1584 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1585 iface, filename, name, flags, cb, ctx);
1586
1587 return E_NOTIMPL;
1588 }
1589
1590 static HRESULT WINAPI d3drm_frame1_Load(IDirect3DRMFrame *iface, void *filename,
1591 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1592 {
1593 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1594 iface, filename, name, flags, cb, ctx);
1595
1596 return E_NOTIMPL;
1597 }
1598
1599 static HRESULT WINAPI d3drm_frame3_LookAt(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *target,
1600 IDirect3DRMFrame3 *reference, D3DRMFRAMECONSTRAINT constraint)
1601 {
1602 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1603
1604 return E_NOTIMPL;
1605 }
1606
1607 static HRESULT WINAPI d3drm_frame2_LookAt(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *target,
1608 IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1609 {
1610 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1611
1612 return E_NOTIMPL;
1613 }
1614
1615 static HRESULT WINAPI d3drm_frame1_LookAt(IDirect3DRMFrame *iface, IDirect3DRMFrame *target,
1616 IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1617 {
1618 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1619
1620 return E_NOTIMPL;
1621 }
1622
1623 static HRESULT WINAPI d3drm_frame3_Move(IDirect3DRMFrame3 *iface, D3DVALUE delta)
1624 {
1625 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1626
1627 return E_NOTIMPL;
1628 }
1629
1630 static HRESULT WINAPI d3drm_frame2_Move(IDirect3DRMFrame2 *iface, D3DVALUE delta)
1631 {
1632 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1633
1634 return E_NOTIMPL;
1635 }
1636
1637 static HRESULT WINAPI d3drm_frame1_Move(IDirect3DRMFrame *iface, D3DVALUE delta)
1638 {
1639 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1640
1641 return E_NOTIMPL;
1642 }
1643
1644 static HRESULT WINAPI d3drm_frame3_DeleteChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
1645 {
1646 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1647 struct d3drm_frame *child_impl = unsafe_impl_from_IDirect3DRMFrame3(child);
1648 ULONG i;
1649
1650 TRACE("iface %p, child %p.\n", iface, child);
1651
1652 if (!child_impl)
1653 return D3DRMERR_BADOBJECT;
1654
1655 /* Check if child exists */
1656 for (i = 0; i < frame->nb_children; ++i)
1657 {
1658 if (frame->children[i] == child)
1659 break;
1660 }
1661
1662 if (i == frame->nb_children)
1663 return D3DRMERR_BADVALUE;
1664
1665 memmove(frame->children + i, frame->children + i + 1, sizeof(*frame->children) * (frame->nb_children - 1 - i));
1666 IDirect3DRMFrame3_Release(child);
1667 child_impl->parent = NULL;
1668 --frame->nb_children;
1669
1670 return D3DRM_OK;
1671 }
1672
1673 static HRESULT WINAPI d3drm_frame2_DeleteChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
1674 {
1675 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1676 IDirect3DRMFrame3 *child3;
1677 HRESULT hr;
1678
1679 TRACE("iface %p, child %p.\n", iface, child);
1680
1681 if (!child)
1682 return D3DRMERR_BADOBJECT;
1683 if (FAILED(hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3)))
1684 return D3DRMERR_BADOBJECT;
1685 IDirect3DRMFrame_Release(child);
1686
1687 return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, child3);
1688 }
1689
1690 static HRESULT WINAPI d3drm_frame1_DeleteChild(IDirect3DRMFrame *iface, IDirect3DRMFrame *child)
1691 {
1692 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1693 struct d3drm_frame *child_frame = unsafe_impl_from_IDirect3DRMFrame(child);
1694
1695 TRACE("iface %p, child %p.\n", iface, child);
1696
1697 if (!child_frame)
1698 return D3DRMERR_BADOBJECT;
1699
1700 return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, &child_frame->IDirect3DRMFrame3_iface);
1701 }
1702
1703 static HRESULT WINAPI d3drm_frame3_DeleteLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1704 {
1705 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1706 ULONG i;
1707
1708 TRACE("iface %p, light %p.\n", iface, light);
1709
1710 if (!light)
1711 return D3DRMERR_BADOBJECT;
1712
1713 /* Check if visual exists */
1714 for (i = 0; i < frame->nb_lights; ++i)
1715 {
1716 if (frame->lights[i] == light)
1717 break;
1718 }
1719
1720 if (i == frame->nb_lights)
1721 return D3DRMERR_BADVALUE;
1722
1723 memmove(frame->lights + i, frame->lights + i + 1, sizeof(*frame->lights) * (frame->nb_lights - 1 - i));
1724 IDirect3DRMLight_Release(light);
1725 --frame->nb_lights;
1726
1727 return D3DRM_OK;
1728 }
1729
1730 static HRESULT WINAPI d3drm_frame2_DeleteLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
1731 {
1732 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1733
1734 TRACE("iface %p, light %p.\n", iface, light);
1735
1736 return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1737 }
1738
1739 static HRESULT WINAPI d3drm_frame1_DeleteLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
1740 {
1741 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1742
1743 TRACE("iface %p, light %p.\n", iface, light);
1744
1745 return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1746 }
1747
1748 static HRESULT WINAPI d3drm_frame3_DeleteMoveCallback(IDirect3DRMFrame3 *iface,
1749 D3DRMFRAME3MOVECALLBACK cb, void *ctx)
1750 {
1751 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1752
1753 return E_NOTIMPL;
1754 }
1755
1756 static HRESULT WINAPI d3drm_frame2_DeleteMoveCallback(IDirect3DRMFrame2 *iface,
1757 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1758 {
1759 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1760
1761 return E_NOTIMPL;
1762 }
1763
1764 static HRESULT WINAPI d3drm_frame1_DeleteMoveCallback(IDirect3DRMFrame *iface,
1765 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1766 {
1767 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1768
1769 return E_NOTIMPL;
1770 }
1771
1772 static HRESULT WINAPI d3drm_frame3_DeleteVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1773 {
1774 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1775 ULONG i;
1776
1777 TRACE("iface %p, visual %p.\n", iface, visual);
1778
1779 if (!visual)
1780 return D3DRMERR_BADOBJECT;
1781
1782 /* Check if visual exists */
1783 for (i = 0; i < frame->nb_visuals; ++i)
1784 {
1785 if (frame->visuals[i] == (IDirect3DRMVisual *)visual)
1786 break;
1787 }
1788
1789 if (i == frame->nb_visuals)
1790 return D3DRMERR_BADVALUE;
1791
1792 memmove(frame->visuals + i, frame->visuals + i + 1, sizeof(*frame->visuals) * (frame->nb_visuals - 1 - i));
1793 IDirect3DRMVisual_Release(visual);
1794 --frame->nb_visuals;
1795
1796 return D3DRM_OK;
1797 }
1798
1799 static HRESULT WINAPI d3drm_frame2_DeleteVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1800 {
1801 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1802
1803 TRACE("iface %p, visual %p.\n", iface, visual);
1804
1805 return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1806 }
1807
1808 static HRESULT WINAPI d3drm_frame1_DeleteVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1809 {
1810 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1811
1812 TRACE("iface %p, visual %p.\n", iface, visual);
1813
1814 return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1815 }
1816
1817 static D3DCOLOR WINAPI d3drm_frame3_GetSceneBackground(IDirect3DRMFrame3 *iface)
1818 {
1819 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1820
1821 TRACE("iface %p.\n", iface);
1822
1823 return frame->scenebackground;
1824 }
1825
1826 static D3DCOLOR WINAPI d3drm_frame2_GetSceneBackground(IDirect3DRMFrame2 *iface)
1827 {
1828 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1829
1830 TRACE("iface %p.\n", iface);
1831
1832 return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
1833 }
1834
1835 static D3DCOLOR WINAPI d3drm_frame1_GetSceneBackground(IDirect3DRMFrame *iface)
1836 {
1837 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1838
1839 TRACE("iface %p.\n", iface);
1840
1841 return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
1842 }
1843
1844 static HRESULT WINAPI d3drm_frame3_GetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
1845 IDirectDrawSurface **surface)
1846 {
1847 FIXME("iface %p, surface %p stub!\n", iface, surface);
1848
1849 return E_NOTIMPL;
1850 }
1851
1852 static HRESULT WINAPI d3drm_frame2_GetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
1853 IDirectDrawSurface **surface)
1854 {
1855 FIXME("iface %p, surface %p stub!\n", iface, surface);
1856
1857 return E_NOTIMPL;
1858 }
1859
1860 static HRESULT WINAPI d3drm_frame1_GetSceneBackgroundDepth(IDirect3DRMFrame *iface,
1861 IDirectDrawSurface **surface)
1862 {
1863 FIXME("iface %p, surface %p stub!\n", iface, surface);
1864
1865 return E_NOTIMPL;
1866 }
1867
1868 static D3DCOLOR WINAPI d3drm_frame3_GetSceneFogColor(IDirect3DRMFrame3 *iface)
1869 {
1870 FIXME("iface %p stub!\n", iface);
1871
1872 return 0;
1873 }
1874
1875 static D3DCOLOR WINAPI d3drm_frame2_GetSceneFogColor(IDirect3DRMFrame2 *iface)
1876 {
1877 FIXME("iface %p stub!\n", iface);
1878
1879 return 0;
1880 }
1881
1882 static D3DCOLOR WINAPI d3drm_frame1_GetSceneFogColor(IDirect3DRMFrame *iface)
1883 {
1884 FIXME("iface %p stub!\n", iface);
1885
1886 return 0;
1887 }
1888
1889 static BOOL WINAPI d3drm_frame3_GetSceneFogEnable(IDirect3DRMFrame3 *iface)
1890 {
1891 FIXME("iface %p stub!\n", iface);
1892
1893 return FALSE;
1894 }
1895
1896 static BOOL WINAPI d3drm_frame2_GetSceneFogEnable(IDirect3DRMFrame2 *iface)
1897 {
1898 FIXME("iface %p stub!\n", iface);
1899
1900 return FALSE;
1901 }
1902
1903 static BOOL WINAPI d3drm_frame1_GetSceneFogEnable(IDirect3DRMFrame *iface)
1904 {
1905 FIXME("iface %p stub!\n", iface);
1906
1907 return FALSE;
1908 }
1909
1910 static D3DRMFOGMODE WINAPI d3drm_frame3_GetSceneFogMode(IDirect3DRMFrame3 *iface)
1911 {
1912 FIXME("iface %p stub!\n", iface);
1913
1914 return D3DRMFOG_LINEAR;
1915 }
1916
1917 static D3DRMFOGMODE WINAPI d3drm_frame2_GetSceneFogMode(IDirect3DRMFrame2 *iface)
1918 {
1919 FIXME("iface %p stub!\n", iface);
1920
1921 return D3DRMFOG_LINEAR;
1922 }
1923
1924 static D3DRMFOGMODE WINAPI d3drm_frame1_GetSceneFogMode(IDirect3DRMFrame *iface)
1925 {
1926 FIXME("iface %p stub!\n", iface);
1927
1928 return D3DRMFOG_LINEAR;
1929 }
1930
1931 static HRESULT WINAPI d3drm_frame3_GetSceneFogParams(IDirect3DRMFrame3 *iface,
1932 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1933 {
1934 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1935
1936 return E_NOTIMPL;
1937 }
1938
1939 static HRESULT WINAPI d3drm_frame2_GetSceneFogParams(IDirect3DRMFrame2 *iface,
1940 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1941 {
1942 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1943
1944 return E_NOTIMPL;
1945 }
1946
1947 static HRESULT WINAPI d3drm_frame1_GetSceneFogParams(IDirect3DRMFrame *iface,
1948 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1949 {
1950 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1951
1952 return E_NOTIMPL;
1953 }
1954
1955 static HRESULT WINAPI d3drm_frame3_SetSceneBackground(IDirect3DRMFrame3 *iface, D3DCOLOR color)
1956 {
1957 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1958
1959 TRACE("iface %p, color 0x%08x.\n", iface, color);
1960
1961 frame->scenebackground = color;
1962
1963 return D3DRM_OK;
1964 }
1965
1966 static HRESULT WINAPI d3drm_frame2_SetSceneBackground(IDirect3DRMFrame2 *iface, D3DCOLOR color)
1967 {
1968 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1969
1970 TRACE("iface %p, color 0x%08x.\n", iface, color);
1971
1972 return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
1973 }
1974
1975 static HRESULT WINAPI d3drm_frame1_SetSceneBackground(IDirect3DRMFrame *iface, D3DCOLOR color)
1976 {
1977 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1978
1979 TRACE("iface %p, color 0x%08x.\n", iface, color);
1980
1981 return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
1982 }
1983
1984 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundRGB(IDirect3DRMFrame3 *iface,
1985 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1986 {
1987 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1988
1989 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
1990
1991 d3drm_set_color(&frame->scenebackground, red, green, blue, 1.0f);
1992
1993 return D3DRM_OK;
1994 }
1995
1996 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundRGB(IDirect3DRMFrame2 *iface,
1997 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1998 {
1999 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2000
2001 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2002
2003 return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2004 }
2005
2006 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundRGB(IDirect3DRMFrame *iface,
2007 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2008 {
2009 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2010
2011 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2012
2013 return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2014 }
2015
2016 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
2017 IDirectDrawSurface *surface)
2018 {
2019 FIXME("iface %p, surface %p stub!\n", iface, surface);
2020
2021 return E_NOTIMPL;
2022 }
2023
2024 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
2025 IDirectDrawSurface *surface)
2026 {
2027 FIXME("iface %p, surface %p stub!\n", iface, surface);
2028
2029 return E_NOTIMPL;
2030 }
2031
2032 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundDepth(IDirect3DRMFrame *iface,
2033 IDirectDrawSurface *surface)
2034 {
2035 FIXME("iface %p, surface %p stub!\n", iface, surface);
2036
2037 return E_NOTIMPL;
2038 }
2039
2040 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundImage(IDirect3DRMFrame3 *iface,
2041 IDirect3DRMTexture3 *texture)
2042 {
2043 FIXME("iface %p, texture %p stub!\n", iface, texture);
2044
2045 return E_NOTIMPL;
2046 }
2047
2048 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundImage(IDirect3DRMFrame2 *iface,
2049 IDirect3DRMTexture *texture)
2050 {
2051 FIXME("iface %p, texture %p stub!\n", iface, texture);
2052
2053 return E_NOTIMPL;
2054 }
2055
2056 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundImage(IDirect3DRMFrame *iface,
2057 IDirect3DRMTexture *texture)
2058 {
2059 FIXME("iface %p, texture %p stub!\n", iface, texture);
2060
2061 return E_NOTIMPL;
2062 }
2063
2064 static HRESULT WINAPI d3drm_frame3_SetSceneFogEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2065 {
2066 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2067
2068 return E_NOTIMPL;
2069 }
2070
2071 static HRESULT WINAPI d3drm_frame2_SetSceneFogEnable(IDirect3DRMFrame2 *iface, BOOL enable)
2072 {
2073 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2074
2075 return E_NOTIMPL;
2076 }
2077
2078 static HRESULT WINAPI d3drm_frame1_SetSceneFogEnable(IDirect3DRMFrame *iface, BOOL enable)
2079 {
2080 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2081
2082 return E_NOTIMPL;
2083 }
2084
2085 static HRESULT WINAPI d3drm_frame3_SetSceneFogColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2086 {
2087 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2088
2089 return E_NOTIMPL;
2090 }
2091
2092 static HRESULT WINAPI d3drm_frame2_SetSceneFogColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2093 {
2094 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2095
2096 return E_NOTIMPL;
2097 }
2098
2099 static HRESULT WINAPI d3drm_frame1_SetSceneFogColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2100 {
2101 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2102
2103 return E_NOTIMPL;
2104 }
2105
2106 static HRESULT WINAPI d3drm_frame3_SetSceneFogMode(IDirect3DRMFrame3 *iface, D3DRMFOGMODE mode)
2107 {
2108 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2109
2110 return E_NOTIMPL;
2111 }
2112
2113 static HRESULT WINAPI d3drm_frame2_SetSceneFogMode(IDirect3DRMFrame2 *iface, D3DRMFOGMODE mode)
2114 {
2115 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2116
2117 return E_NOTIMPL;
2118 }
2119
2120 static HRESULT WINAPI d3drm_frame1_SetSceneFogMode(IDirect3DRMFrame *iface, D3DRMFOGMODE mode)
2121 {
2122 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2123
2124 return E_NOTIMPL;
2125 }
2126
2127 static HRESULT WINAPI d3drm_frame3_SetSceneFogParams(IDirect3DRMFrame3 *iface,
2128 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2129 {
2130 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2131
2132 return E_NOTIMPL;
2133 }
2134
2135 static HRESULT WINAPI d3drm_frame2_SetSceneFogParams(IDirect3DRMFrame2 *iface,
2136 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2137 {
2138 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2139
2140 return E_NOTIMPL;
2141 }
2142
2143 static HRESULT WINAPI d3drm_frame1_SetSceneFogParams(IDirect3DRMFrame *iface,
2144 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2145 {
2146 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2147
2148 return E_NOTIMPL;
2149 }
2150
2151 static HRESULT WINAPI d3drm_frame3_SetColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2152 {
2153 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2154
2155 return E_NOTIMPL;
2156 }
2157
2158 static HRESULT WINAPI d3drm_frame2_SetColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2159 {
2160 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2161
2162 return E_NOTIMPL;
2163 }
2164
2165 static HRESULT WINAPI d3drm_frame1_SetColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2166 {
2167 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2168
2169 return E_NOTIMPL;
2170 }
2171
2172 static HRESULT WINAPI d3drm_frame3_SetColorRGB(IDirect3DRMFrame3 *iface,
2173 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2174 {
2175 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2176
2177 return E_NOTIMPL;
2178 }
2179
2180 static HRESULT WINAPI d3drm_frame2_SetColorRGB(IDirect3DRMFrame2 *iface,
2181 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2182 {
2183 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2184
2185 return E_NOTIMPL;
2186 }
2187
2188 static HRESULT WINAPI d3drm_frame1_SetColorRGB(IDirect3DRMFrame *iface,
2189 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2190 {
2191 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2192
2193 return E_NOTIMPL;
2194 }
2195
2196 static D3DRMZBUFFERMODE WINAPI d3drm_frame3_GetZbufferMode(IDirect3DRMFrame3 *iface)
2197 {
2198 FIXME("iface %p stub!\n", iface);
2199
2200 return D3DRMZBUFFER_FROMPARENT;
2201 }
2202
2203 static D3DRMZBUFFERMODE WINAPI d3drm_frame2_GetZbufferMode(IDirect3DRMFrame2 *iface)
2204 {
2205 FIXME("iface %p stub!\n", iface);
2206
2207 return D3DRMZBUFFER_FROMPARENT;
2208 }
2209
2210 static D3DRMZBUFFERMODE WINAPI d3drm_frame1_GetZbufferMode(IDirect3DRMFrame *iface)
2211 {
2212 FIXME("iface %p stub!\n", iface);
2213
2214 return D3DRMZBUFFER_FROMPARENT;
2215 }
2216
2217 static HRESULT WINAPI d3drm_frame3_SetMaterialMode(IDirect3DRMFrame3 *iface, D3DRMMATERIALMODE mode)
2218 {
2219 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2220
2221 return E_NOTIMPL;
2222 }
2223
2224 static HRESULT WINAPI d3drm_frame2_SetMaterialMode(IDirect3DRMFrame2 *iface, D3DRMMATERIALMODE mode)
2225 {
2226 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2227
2228 return E_NOTIMPL;
2229 }
2230
2231 static HRESULT WINAPI d3drm_frame1_SetMaterialMode(IDirect3DRMFrame *iface, D3DRMMATERIALMODE mode)
2232 {
2233 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2234
2235 return E_NOTIMPL;
2236 }
2237
2238 static HRESULT WINAPI d3drm_frame3_SetOrientation(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2239 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2240 {
2241 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2242 iface, reference, dx, dy, dz, ux, uy, uz);
2243
2244 return E_NOTIMPL;
2245 }
2246
2247 static HRESULT WINAPI d3drm_frame2_SetOrientation(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *reference,
2248 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2249 {
2250 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2251 iface, reference, dx, dy, dz, ux, uy, uz);
2252
2253 return E_NOTIMPL;
2254 }
2255
2256 static HRESULT WINAPI d3drm_frame1_SetOrientation(IDirect3DRMFrame *iface, IDirect3DRMFrame *reference,
2257 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2258 {
2259 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2260 iface, reference, dx, dy, dz, ux, uy, uz);
2261
2262 return E_NOTIMPL;
2263 }
2264
2265 static HRESULT WINAPI d3drm_frame3_SetPosition(IDirect3DRMFrame3 *iface,
2266 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2267 {
2268 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2269
2270 return E_NOTIMPL;
2271 }
2272
2273 static HRESULT WINAPI d3drm_frame2_SetPosition(IDirect3DRMFrame2 *iface,
2274 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2275 {
2276 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2277
2278 return E_NOTIMPL;
2279 }
2280
2281 static HRESULT WINAPI d3drm_frame1_SetPosition(IDirect3DRMFrame *iface,
2282 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2283 {
2284 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2285
2286 return E_NOTIMPL;
2287 }
2288
2289 static HRESULT WINAPI d3drm_frame3_SetRotation(IDirect3DRMFrame3 *iface,
2290 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2291 {
2292 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2293 iface, reference, x, y, z, theta);
2294
2295 return E_NOTIMPL;
2296 }
2297
2298 static HRESULT WINAPI d3drm_frame2_SetRotation(IDirect3DRMFrame2 *iface,
2299 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2300 {
2301 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2302 iface, reference, x, y, z, theta);
2303
2304 return E_NOTIMPL;
2305 }
2306
2307 static HRESULT WINAPI d3drm_frame1_SetRotation(IDirect3DRMFrame *iface,
2308 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2309 {
2310 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2311 iface, reference, x, y, z, theta);
2312
2313 return E_NOTIMPL;
2314 }
2315
2316 static HRESULT WINAPI d3drm_frame3_SetSortMode(IDirect3DRMFrame3 *iface, D3DRMSORTMODE mode)
2317 {
2318 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2319
2320 return E_NOTIMPL;
2321 }
2322
2323 static HRESULT WINAPI d3drm_frame2_SetSortMode(IDirect3DRMFrame2 *iface, D3DRMSORTMODE mode)
2324 {
2325 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2326
2327 return E_NOTIMPL;
2328 }
2329
2330 static HRESULT WINAPI d3drm_frame1_SetSortMode(IDirect3DRMFrame *iface, D3DRMSORTMODE mode)
2331 {
2332 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2333
2334 return E_NOTIMPL;
2335 }
2336
2337 static HRESULT WINAPI d3drm_frame3_SetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 *texture)
2338 {
2339 FIXME("iface %p, texture %p stub!\n", iface, texture);
2340
2341 return E_NOTIMPL;
2342 }
2343
2344 static HRESULT WINAPI d3drm_frame2_SetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture *texture)
2345 {
2346 FIXME("iface %p, texture %p stub!\n", iface, texture);
2347
2348 return E_NOTIMPL;
2349 }
2350
2351 static HRESULT WINAPI d3drm_frame1_SetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture *texture)
2352 {
2353 FIXME("iface %p, texture %p stub!\n", iface, texture);
2354
2355 return E_NOTIMPL;
2356 }
2357
2358 static HRESULT WINAPI d3drm_frame2_SetTextureTopology(IDirect3DRMFrame2 *iface, BOOL wrap_u, BOOL wrap_v)
2359 {
2360 FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2361
2362 return E_NOTIMPL;
2363 }
2364
2365 static HRESULT WINAPI d3drm_frame1_SetTextureTopology(IDirect3DRMFrame *iface, BOOL wrap_u, BOOL wrap_v)
2366 {
2367 FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2368
2369 return E_NOTIMPL;
2370 }
2371
2372 static HRESULT WINAPI d3drm_frame3_SetVelocity(IDirect3DRMFrame3 *iface,
2373 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2374 {
2375 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x.\n",
2376 iface, reference, x, y, z, with_rotation);
2377
2378 return E_NOTIMPL;
2379 }
2380
2381 static HRESULT WINAPI d3drm_frame2_SetVelocity(IDirect3DRMFrame2 *iface,
2382 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2383 {
2384 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2385 iface, reference, x, y, z, with_rotation);
2386
2387 return E_NOTIMPL;
2388 }
2389
2390 static HRESULT WINAPI d3drm_frame1_SetVelocity(IDirect3DRMFrame *iface,
2391 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2392 {
2393 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2394 iface, reference, x, y, z, with_rotation);
2395
2396 return E_NOTIMPL;
2397 }
2398
2399 static HRESULT WINAPI d3drm_frame3_SetZbufferMode(IDirect3DRMFrame3 *iface, D3DRMZBUFFERMODE mode)
2400 {
2401 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2402
2403 return E_NOTIMPL;
2404 }
2405
2406 static HRESULT WINAPI d3drm_frame2_SetZbufferMode(IDirect3DRMFrame2 *iface, D3DRMZBUFFERMODE mode)
2407 {
2408 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2409
2410 return E_NOTIMPL;
2411 }
2412
2413 static HRESULT WINAPI d3drm_frame1_SetZbufferMode(IDirect3DRMFrame *iface, D3DRMZBUFFERMODE mode)
2414 {
2415 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2416
2417 return E_NOTIMPL;
2418 }
2419
2420 static HRESULT WINAPI d3drm_frame3_Transform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
2421 {
2422 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2423
2424 return E_NOTIMPL;
2425 }
2426
2427 static HRESULT WINAPI d3drm_frame2_Transform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
2428 {
2429 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2430
2431 return E_NOTIMPL;
2432 }
2433
2434 static HRESULT WINAPI d3drm_frame1_Transform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
2435 {
2436 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2437
2438 return E_NOTIMPL;
2439 }
2440
2441 static HRESULT WINAPI d3drm_frame2_AddMoveCallback2(IDirect3DRMFrame2 *iface,
2442 D3DRMFRAMEMOVECALLBACK cb, void *ctx, DWORD flags)
2443 {
2444 FIXME("iface %p, cb %p, ctx %p, flags %#x stub!\n", iface, cb, ctx, flags);
2445
2446 return E_NOTIMPL;
2447 }
2448
2449 static HRESULT WINAPI d3drm_frame3_GetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2450 {
2451 FIXME("iface %p, box %p stub!\n", iface, box);
2452
2453 return E_NOTIMPL;
2454 }
2455
2456 static HRESULT WINAPI d3drm_frame2_GetBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2457 {
2458 FIXME("iface %p, box %p stub!\n", iface, box);
2459
2460 return E_NOTIMPL;
2461 }
2462
2463 static BOOL WINAPI d3drm_frame3_GetBoxEnable(IDirect3DRMFrame3 *iface)
2464 {
2465 FIXME("iface %p stub!\n", iface);
2466
2467 return FALSE;
2468 }
2469
2470 static BOOL WINAPI d3drm_frame2_GetBoxEnable(IDirect3DRMFrame2 *iface)
2471 {
2472 FIXME("iface %p stub!\n", iface);
2473
2474 return FALSE;
2475 }
2476
2477 static HRESULT WINAPI d3drm_frame3_GetAxes(IDirect3DRMFrame3 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2478 {
2479 FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2480
2481 return E_NOTIMPL;
2482 }
2483
2484 static HRESULT WINAPI d3drm_frame2_GetAxes(IDirect3DRMFrame2 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2485 {
2486 FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2487
2488 return E_NOTIMPL;
2489 }
2490
2491 static HRESULT WINAPI d3drm_frame3_GetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 **material)
2492 {
2493 FIXME("iface %p, material %p stub!\n", iface, material);
2494
2495 return E_NOTIMPL;
2496 }
2497
2498 static HRESULT WINAPI d3drm_frame2_GetMaterial(IDirect3DRMFrame2 *iface, IDirect3DRMMaterial **material)
2499 {
2500 FIXME("iface %p, material %p stub!\n", iface, material);
2501
2502 return E_NOTIMPL;
2503 }
2504
2505 static BOOL WINAPI d3drm_frame3_GetInheritAxes(IDirect3DRMFrame3 *iface)
2506 {
2507 FIXME("iface %p stub!\n", iface);
2508
2509 return FALSE;
2510 }
2511
2512 static BOOL WINAPI d3drm_frame2_GetInheritAxes(IDirect3DRMFrame2 *iface)
2513 {
2514 FIXME("iface %p stub!\n", iface);
2515
2516 return FALSE;
2517 }
2518
2519 static HRESULT WINAPI d3drm_frame3_GetHierarchyBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2520 {
2521 FIXME("iface %p, box %p stub!\n", iface, box);
2522
2523 return E_NOTIMPL;
2524 }
2525
2526 static HRESULT WINAPI d3drm_frame2_GetHierarchyBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2527 {
2528 FIXME("iface %p, box %p stub!\n", iface, box);
2529
2530 return E_NOTIMPL;
2531 }
2532
2533 static HRESULT WINAPI d3drm_frame3_SetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2534 {
2535 FIXME("iface %p, box %p stub!\n", iface, box);
2536
2537 return E_NOTIMPL;
2538 }
2539
2540 static HRESULT WINAPI d3drm_frame3_SetBoxEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2541 {
2542 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2543
2544 return E_NOTIMPL;
2545 }
2546
2547 static HRESULT WINAPI d3drm_frame3_SetAxes(IDirect3DRMFrame3 *iface,
2548 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2549 {
2550 FIXME("iface %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2551 iface, dx, dy, dz, ux, uy, uz);
2552
2553 return E_NOTIMPL;
2554 }
2555
2556 static HRESULT WINAPI d3drm_frame3_SetInheritAxes(IDirect3DRMFrame3 *iface, BOOL inherit)
2557 {
2558 FIXME("iface %p, inherit %#x stub!\n", iface, inherit);
2559
2560 return E_NOTIMPL;
2561 }
2562
2563 static HRESULT WINAPI d3drm_frame3_SetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 *material)
2564 {
2565 FIXME("iface %p, material %p stub!\n", iface, material);
2566
2567 return E_NOTIMPL;
2568 }
2569
2570 static HRESULT WINAPI d3drm_frame3_SetQuaternion(IDirect3DRMFrame3 *iface,
2571 IDirect3DRMFrame3 *reference, D3DRMQUATERNION *q)
2572 {
2573 FIXME("iface %p, reference %p, q %p stub!\n", iface, reference, q);
2574
2575 return E_NOTIMPL;
2576 }
2577
2578 static HRESULT WINAPI d3drm_frame3_RayPick(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2579 D3DRMRAY *ray, DWORD flags, IDirect3DRMPicked2Array **visuals)
2580 {
2581 FIXME("iface %p, reference %p, ray %p, flags %#x, visuals %p stub!\n",
2582 iface, reference, ray, flags, visuals);
2583
2584 return E_NOTIMPL;
2585 }
2586
2587 static HRESULT WINAPI d3drm_frame3_Save(IDirect3DRMFrame3 *iface,
2588 const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags)
2589 {
2590 FIXME("iface %p, filename %s, format %#x, flags %#x stub!\n",
2591 iface, debugstr_a(filename), format, flags);
2592
2593 return E_NOTIMPL;
2594 }
2595
2596 static HRESULT WINAPI d3drm_frame3_TransformVectors(IDirect3DRMFrame3 *iface,
2597 IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2598 {
2599 FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2600
2601 return E_NOTIMPL;
2602 }
2603
2604 static HRESULT WINAPI d3drm_frame3_InverseTransformVectors(IDirect3DRMFrame3 *iface,
2605 IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2606 {
2607 FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2608
2609 return E_NOTIMPL;
2610 }
2611
2612 static HRESULT WINAPI d3drm_frame3_SetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD options)
2613 {
2614 static const DWORD supported_options = D3DRMFRAME_RENDERENABLE | D3DRMFRAME_PICKENABLE;
2615 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2616
2617 TRACE("iface %p, options %#x.\n", iface, options);
2618
2619 if (options & ~supported_options)
2620 return D3DRMERR_BADVALUE;
2621
2622 frame->traversal_options = options;
2623
2624 return D3DRM_OK;
2625 }
2626
2627 static HRESULT WINAPI d3drm_frame3_GetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD *options)
2628 {
2629 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2630
2631 TRACE("iface %p, options %p.\n", iface, options);
2632
2633 if (!options)
2634 return D3DRMERR_BADVALUE;
2635
2636 *options = frame->traversal_options;
2637
2638 return D3DRM_OK;
2639 }
2640
2641 static HRESULT WINAPI d3drm_frame3_SetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD flags)
2642 {
2643 FIXME("iface %p, flags %#x stub!\n", iface, flags);
2644
2645 return E_NOTIMPL;
2646 }
2647
2648 static HRESULT WINAPI d3drm_frame3_GetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD *fog_mode)
2649 {
2650 FIXME("iface %p, fog_mode %p stub!\n", iface, fog_mode);
2651
2652 return E_NOTIMPL;
2653 }
2654
2655 static HRESULT WINAPI d3drm_frame3_SetMaterialOverride(IDirect3DRMFrame3 *iface,
2656 D3DRMMATERIALOVERRIDE *override)
2657 {
2658 FIXME("iface %p, override %p stub!\n", iface, override);
2659
2660 return E_NOTIMPL;
2661 }
2662
2663 static HRESULT WINAPI d3drm_frame3_GetMaterialOverride(IDirect3DRMFrame3 *iface,
2664 D3DRMMATERIALOVERRIDE *override)
2665 {
2666 FIXME("iface %p, override %p stub!\n", iface, override);
2667
2668 return E_NOTIMPL;
2669 }
2670
2671 static const struct IDirect3DRMFrame3Vtbl d3drm_frame3_vtbl =
2672 {
2673 d3drm_frame3_QueryInterface,
2674 d3drm_frame3_AddRef,
2675 d3drm_frame3_Release,
2676 d3drm_frame3_Clone,
2677 d3drm_frame3_AddDestroyCallback,
2678 d3drm_frame3_DeleteDestroyCallback,
2679 d3drm_frame3_SetAppData,
2680 d3drm_frame3_GetAppData,
2681 d3drm_frame3_SetName,
2682 d3drm_frame3_GetName,
2683 d3drm_frame3_GetClassName,
2684 d3drm_frame3_AddChild,
2685 d3drm_frame3_AddLight,
2686 d3drm_frame3_AddMoveCallback,
2687 d3drm_frame3_AddTransform,
2688 d3drm_frame3_AddTranslation,
2689 d3drm_frame3_AddScale,
2690 d3drm_frame3_AddRotation,
2691 d3drm_frame3_AddVisual,
2692 d3drm_frame3_GetChildren,
2693 d3drm_frame3_GetColor,
2694 d3drm_frame3_GetLights,
2695 d3drm_frame3_GetMaterialMode,
2696 d3drm_frame3_GetParent,
2697 d3drm_frame3_GetPosition,
2698 d3drm_frame3_GetRotation,
2699 d3drm_frame3_GetScene,
2700 d3drm_frame3_GetSortMode,
2701 d3drm_frame3_GetTexture,
2702 d3drm_frame3_GetTransform,
2703 d3drm_frame3_GetVelocity,
2704 d3drm_frame3_GetOrientation,
2705 d3drm_frame3_GetVisuals,
2706 d3drm_frame3_InverseTransform,
2707 d3drm_frame3_Load,
2708 d3drm_frame3_LookAt,
2709 d3drm_frame3_Move,
2710 d3drm_frame3_DeleteChild,
2711 d3drm_frame3_DeleteLight,
2712 d3drm_frame3_DeleteMoveCallback,
2713 d3drm_frame3_DeleteVisual,
2714 d3drm_frame3_GetSceneBackground,
2715 d3drm_frame3_GetSceneBackgroundDepth,
2716 d3drm_frame3_GetSceneFogColor,
2717 d3drm_frame3_GetSceneFogEnable,
2718 d3drm_frame3_GetSceneFogMode,
2719 d3drm_frame3_GetSceneFogParams,
2720 d3drm_frame3_SetSceneBackground,
2721 d3drm_frame3_SetSceneBackgroundRGB,
2722 d3drm_frame3_SetSceneBackgroundDepth,
2723 d3drm_frame3_SetSceneBackgroundImage,
2724 d3drm_frame3_SetSceneFogEnable,
2725 d3drm_frame3_SetSceneFogColor,
2726 d3drm_frame3_SetSceneFogMode,
2727 d3drm_frame3_SetSceneFogParams,
2728 d3drm_frame3_SetColor,
2729 d3drm_frame3_SetColorRGB,
2730 d3drm_frame3_GetZbufferMode,
2731 d3drm_frame3_SetMaterialMode,
2732 d3drm_frame3_SetOrientation,
2733 d3drm_frame3_SetPosition,
2734 d3drm_frame3_SetRotation,
2735 d3drm_frame3_SetSortMode,
2736 d3drm_frame3_SetTexture,
2737 d3drm_frame3_SetVelocity,
2738 d3drm_frame3_SetZbufferMode,
2739 d3drm_frame3_Transform,
2740 d3drm_frame3_GetBox,
2741 d3drm_frame3_GetBoxEnable,
2742 d3drm_frame3_GetAxes,
2743 d3drm_frame3_GetMaterial,
2744 d3drm_frame3_GetInheritAxes,
2745 d3drm_frame3_GetHierarchyBox,
2746 d3drm_frame3_SetBox,
2747 d3drm_frame3_SetBoxEnable,
2748 d3drm_frame3_SetAxes,
2749 d3drm_frame3_SetInheritAxes,
2750 d3drm_frame3_SetMaterial,
2751 d3drm_frame3_SetQuaternion,
2752 d3drm_frame3_RayPick,
2753 d3drm_frame3_Save,
2754 d3drm_frame3_TransformVectors,
2755 d3drm_frame3_InverseTransformVectors,
2756 d3drm_frame3_SetTraversalOptions,
2757 d3drm_frame3_GetTraversalOptions,
2758 d3drm_frame3_SetSceneFogMethod,
2759 d3drm_frame3_GetSceneFogMethod,
2760 d3drm_frame3_SetMaterialOverride,
2761 d3drm_frame3_GetMaterialOverride,
2762 };
2763
2764 static const struct IDirect3DRMFrame2Vtbl d3drm_frame2_vtbl =
2765 {
2766 d3drm_frame2_QueryInterface,
2767 d3drm_frame2_AddRef,
2768 d3drm_frame2_Release,
2769 d3drm_frame2_Clone,
2770 d3drm_frame2_AddDestroyCallback,
2771 d3drm_frame2_DeleteDestroyCallback,
2772 d3drm_frame2_SetAppData,
2773 d3drm_frame2_GetAppData,
2774 d3drm_frame2_SetName,
2775 d3drm_frame2_GetName,
2776 d3drm_frame2_GetClassName,
2777 d3drm_frame2_AddChild,
2778 d3drm_frame2_AddLight,
2779 d3drm_frame2_AddMoveCallback,
2780 d3drm_frame2_AddTransform,
2781 d3drm_frame2_AddTranslation,
2782 d3drm_frame2_AddScale,
2783 d3drm_frame2_AddRotation,
2784 d3drm_frame2_AddVisual,
2785 d3drm_frame2_GetChildren,
2786 d3drm_frame2_GetColor,
2787 d3drm_frame2_GetLights,
2788 d3drm_frame2_GetMaterialMode,
2789 d3drm_frame2_GetParent,
2790 d3drm_frame2_GetPosition,
2791 d3drm_frame2_GetRotation,
2792 d3drm_frame2_GetScene,
2793 d3drm_frame2_GetSortMode,
2794 d3drm_frame2_GetTexture,
2795 d3drm_frame2_GetTransform,
2796 d3drm_frame2_GetVelocity,
2797 d3drm_frame2_GetOrientation,
2798 d3drm_frame2_GetVisuals,
2799 d3drm_frame2_GetTextureTopology,
2800 d3drm_frame2_InverseTransform,
2801 d3drm_frame2_Load,
2802 d3drm_frame2_LookAt,
2803 d3drm_frame2_Move,
2804 d3drm_frame2_DeleteChild,
2805 d3drm_frame2_DeleteLight,
2806 d3drm_frame2_DeleteMoveCallback,
2807 d3drm_frame2_DeleteVisual,
2808 d3drm_frame2_GetSceneBackground,
2809 d3drm_frame2_GetSceneBackgroundDepth,
2810 d3drm_frame2_GetSceneFogColor,
2811 d3drm_frame2_GetSceneFogEnable,
2812 d3drm_frame2_GetSceneFogMode,
2813 d3drm_frame2_GetSceneFogParams,
2814 d3drm_frame2_SetSceneBackground,
2815 d3drm_frame2_SetSceneBackgroundRGB,
2816 d3drm_frame2_SetSceneBackgroundDepth,
2817 d3drm_frame2_SetSceneBackgroundImage,
2818 d3drm_frame2_SetSceneFogEnable,
2819 d3drm_frame2_SetSceneFogColor,
2820 d3drm_frame2_SetSceneFogMode,
2821 d3drm_frame2_SetSceneFogParams,
2822 d3drm_frame2_SetColor,
2823 d3drm_frame2_SetColorRGB,
2824 d3drm_frame2_GetZbufferMode,
2825 d3drm_frame2_SetMaterialMode,
2826 d3drm_frame2_SetOrientation,
2827 d3drm_frame2_SetPosition,
2828 d3drm_frame2_SetRotation,
2829 d3drm_frame2_SetSortMode,
2830 d3drm_frame2_SetTexture,
2831 d3drm_frame2_SetTextureTopology,
2832 d3drm_frame2_SetVelocity,
2833 d3drm_frame2_SetZbufferMode,
2834 d3drm_frame2_Transform,
2835 d3drm_frame2_AddMoveCallback2,
2836 d3drm_frame2_GetBox,
2837 d3drm_frame2_GetBoxEnable,
2838 d3drm_frame2_GetAxes,
2839 d3drm_frame2_GetMaterial,
2840 d3drm_frame2_GetInheritAxes,
2841 d3drm_frame2_GetHierarchyBox,
2842 };
2843
2844 static const struct IDirect3DRMFrameVtbl d3drm_frame1_vtbl =
2845 {
2846 d3drm_frame1_QueryInterface,
2847 d3drm_frame1_AddRef,
2848 d3drm_frame1_Release,
2849 d3drm_frame1_Clone,
2850 d3drm_frame1_AddDestroyCallback,
2851 d3drm_frame1_DeleteDestroyCallback,
2852 d3drm_frame1_SetAppData,
2853 d3drm_frame1_GetAppData,
2854 d3drm_frame1_SetName,
2855 d3drm_frame1_GetName,
2856 d3drm_frame1_GetClassName,
2857 d3drm_frame1_AddChild,
2858 d3drm_frame1_AddLight,
2859 d3drm_frame1_AddMoveCallback,
2860 d3drm_frame1_AddTransform,
2861 d3drm_frame1_AddTranslation,
2862 d3drm_frame1_AddScale,
2863 d3drm_frame1_AddRotation,
2864 d3drm_frame1_AddVisual,
2865 d3drm_frame1_GetChildren,
2866 d3drm_frame1_GetColor,
2867 d3drm_frame1_GetLights,
2868 d3drm_frame1_GetMaterialMode,
2869 d3drm_frame1_GetParent,
2870 d3drm_frame1_GetPosition,
2871 d3drm_frame1_GetRotation,
2872 d3drm_frame1_GetScene,
2873 d3drm_frame1_GetSortMode,
2874 d3drm_frame1_GetTexture,
2875 d3drm_frame1_GetTransform,
2876 d3drm_frame1_GetVelocity,
2877 d3drm_frame1_GetOrientation,
2878 d3drm_frame1_GetVisuals,
2879 d3drm_frame1_GetTextureTopology,
2880 d3drm_frame1_InverseTransform,
2881 d3drm_frame1_Load,
2882 d3drm_frame1_LookAt,
2883 d3drm_frame1_Move,
2884 d3drm_frame1_DeleteChild,
2885 d3drm_frame1_DeleteLight,
2886 d3drm_frame1_DeleteMoveCallback,
2887 d3drm_frame1_DeleteVisual,
2888 d3drm_frame1_GetSceneBackground,
2889 d3drm_frame1_GetSceneBackgroundDepth,
2890 d3drm_frame1_GetSceneFogColor,
2891 d3drm_frame1_GetSceneFogEnable,
2892 d3drm_frame1_GetSceneFogMode,
2893 d3drm_frame1_GetSceneFogParams,
2894 d3drm_frame1_SetSceneBackground,
2895 d3drm_frame1_SetSceneBackgroundRGB,
2896 d3drm_frame1_SetSceneBackgroundDepth,
2897 d3drm_frame1_SetSceneBackgroundImage,
2898 d3drm_frame1_SetSceneFogEnable,
2899 d3drm_frame1_SetSceneFogColor,
2900 d3drm_frame1_SetSceneFogMode,
2901 d3drm_frame1_SetSceneFogParams,
2902 d3drm_frame1_SetColor,
2903 d3drm_frame1_SetColorRGB,
2904 d3drm_frame1_GetZbufferMode,
2905 d3drm_frame1_SetMaterialMode,
2906 d3drm_frame1_SetOrientation,
2907 d3drm_frame1_SetPosition,
2908 d3drm_frame1_SetRotation,
2909 d3drm_frame1_SetSortMode,
2910 d3drm_frame1_SetTexture,
2911 d3drm_frame1_SetTextureTopology,
2912 d3drm_frame1_SetVelocity,
2913 d3drm_frame1_SetZbufferMode,
2914 d3drm_frame1_Transform,
2915 };
2916
2917 static inline struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2918 {
2919 if (!iface)
2920 return NULL;
2921 assert(iface->lpVtbl == &d3drm_frame3_vtbl);
2922
2923 return impl_from_IDirect3DRMFrame3(iface);
2924 }
2925
2926 struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame(IDirect3DRMFrame *iface)
2927 {
2928 if (!iface)
2929 return NULL;
2930 assert(iface->lpVtbl == &d3drm_frame1_vtbl);
2931
2932 return impl_from_IDirect3DRMFrame(iface);
2933 }
2934
2935 HRESULT d3drm_frame_create(struct d3drm_frame **frame, IUnknown *parent_frame, IDirect3DRM *d3drm)
2936 {
2937 static const char classname[] = "Frame";
2938 struct d3drm_frame *object;
2939 HRESULT hr = D3DRM_OK;
2940
2941 TRACE("frame %p, parent_frame %p, d3drm %p.\n", frame, parent_frame, d3drm);
2942
2943 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2944 return E_OUTOFMEMORY;
2945
2946 object->IDirect3DRMFrame_iface.lpVtbl = &d3drm_frame1_vtbl;
2947 object->IDirect3DRMFrame2_iface.lpVtbl = &d3drm_frame2_vtbl;
2948 object->IDirect3DRMFrame3_iface.lpVtbl = &d3drm_frame3_vtbl;
2949 object->d3drm = d3drm;
2950 object->ref = 1;
2951 d3drm_set_color(&object->scenebackground, 0.0f, 0.0f, 0.0f, 1.0f);
2952 object->traversal_options = D3DRMFRAME_RENDERENABLE | D3DRMFRAME_PICKENABLE;
2953
2954 d3drm_object_init(&object->obj, classname);
2955
2956 memcpy(object->transform, identity, sizeof(D3DRMMATRIX4D));
2957
2958 if (parent_frame)
2959 {
2960 IDirect3DRMFrame3 *p;
2961
2962 if (FAILED(hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&p)))
2963 {
2964 HeapFree(GetProcessHeap(), 0, object);
2965 return hr;
2966 }
2967 IDirect3DRMFrame_Release(parent_frame);
2968 IDirect3DRMFrame3_AddChild(p, &object->IDirect3DRMFrame3_iface);
2969 }
2970
2971 IDirect3DRM_AddRef(object->d3drm);
2972
2973 *frame = object;
2974
2975 return hr;
2976 }
2977
2978 static HRESULT WINAPI d3drm_animation2_QueryInterface(IDirect3DRMAnimation2 *iface, REFIID riid, void **out)
2979 {
2980 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
2981
2982 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
2983
2984 if (IsEqualGUID(riid, &IID_IDirect3DRMAnimation)
2985 || IsEqualGUID(riid, &IID_IDirect3DRMObject)
2986 || IsEqualGUID(riid, &IID_IUnknown))
2987 {
2988 *out = &animation->IDirect3DRMAnimation_iface;
2989 }
2990 else if (IsEqualGUID(riid, &IID_IDirect3DRMAnimation2))
2991 {
2992 *out = &animation->IDirect3DRMAnimation2_iface;
2993 }
2994 else
2995 {
2996 *out = NULL;
2997 WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
2998 return CLASS_E_CLASSNOTAVAILABLE;
2999 }
3000
3001 IUnknown_AddRef((IUnknown *)*out);
3002 return S_OK;
3003 }
3004
3005 static HRESULT WINAPI d3drm_animation1_QueryInterface(IDirect3DRMAnimation *iface, REFIID riid, void **out)
3006 {
3007 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3008
3009 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
3010
3011 return IDirect3DRMAnimation2_QueryInterface(&animation->IDirect3DRMAnimation2_iface, riid, out);
3012 }
3013
3014 static ULONG WINAPI d3drm_animation2_AddRef(IDirect3DRMAnimation2 *iface)
3015 {
3016 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3017 ULONG refcount = InterlockedIncrement(&animation->ref);
3018
3019 TRACE("%p increasing refcount to %u.\n", iface, refcount);
3020
3021 return refcount;
3022 }
3023
3024 static ULONG WINAPI d3drm_animation1_AddRef(IDirect3DRMAnimation *iface)
3025 {
3026 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3027 return IDirect3DRMAnimation2_AddRef(&animation->IDirect3DRMAnimation2_iface);
3028 }
3029
3030 static ULONG WINAPI d3drm_animation2_Release(IDirect3DRMAnimation2 *iface)
3031 {
3032 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3033 ULONG refcount = InterlockedDecrement(&animation->ref);
3034
3035 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
3036
3037 if (!refcount)
3038 {
3039 d3drm_object_cleanup((IDirect3DRMObject *)&animation->IDirect3DRMAnimation_iface, &animation->obj);
3040 IDirect3DRM_Release(animation->d3drm);
3041 HeapFree(GetProcessHeap(), 0, animation->rotate.keys);
3042 HeapFree(GetProcessHeap(), 0, animation->scale.keys);
3043 HeapFree(GetProcessHeap(), 0, animation->position.keys);
3044 HeapFree(GetProcessHeap(), 0, animation);
3045 }
3046
3047 return refcount;
3048 }
3049
3050 static ULONG WINAPI d3drm_animation1_Release(IDirect3DRMAnimation *iface)
3051 {
3052 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3053
3054 return IDirect3DRMAnimation2_Release(&animation->IDirect3DRMAnimation2_iface);
3055 }
3056
3057 static HRESULT WINAPI d3drm_animation2_Clone(IDirect3DRMAnimation2 *iface, IUnknown *outer, REFIID iid, void **out)
3058 {
3059 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
3060
3061 return E_NOTIMPL;
3062 }
3063
3064 static HRESULT WINAPI d3drm_animation1_Clone(IDirect3DRMAnimation *iface, IUnknown *outer, REFIID iid, void **out)
3065 {
3066 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
3067
3068 return E_NOTIMPL;
3069 }
3070
3071 static HRESULT WINAPI d3drm_animation2_AddDestroyCallback(IDirect3DRMAnimation2 *iface,
3072 D3DRMOBJECTCALLBACK cb, void *ctx)
3073 {
3074 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3075
3076 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3077
3078 return d3drm_object_add_destroy_callback(&animation->obj, cb, ctx);
3079 }
3080
3081 static HRESULT WINAPI d3drm_animation1_AddDestroyCallback(IDirect3DRMAnimation *iface,
3082 D3DRMOBJECTCALLBACK cb, void *ctx)
3083 {
3084 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3085
3086 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3087
3088 return IDirect3DRMAnimation2_AddDestroyCallback(&animation->IDirect3DRMAnimation2_iface, cb, ctx);
3089 }
3090
3091 static HRESULT WINAPI d3drm_animation2_DeleteDestroyCallback(IDirect3DRMAnimation2 *iface,
3092 D3DRMOBJECTCALLBACK cb, void *ctx)
3093 {
3094 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3095
3096 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3097
3098 return d3drm_object_delete_destroy_callback(&animation->obj, cb, ctx);
3099 }
3100
3101 static HRESULT WINAPI d3drm_animation1_DeleteDestroyCallback(IDirect3DRMAnimation *iface,
3102 D3DRMOBJECTCALLBACK cb, void *ctx)
3103 {
3104 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3105
3106 TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3107
3108 return IDirect3DRMAnimation2_DeleteDestroyCallback(&animation->IDirect3DRMAnimation2_iface, cb, ctx);
3109 }
3110
3111 static HRESULT WINAPI d3drm_animation2_SetAppData(IDirect3DRMAnimation2 *iface, DWORD data)
3112 {
3113 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3114
3115 TRACE("iface %p, data %#x.\n", iface, data);
3116
3117 animation->obj.appdata = data;
3118
3119 return D3DRM_OK;
3120 }
3121
3122 static HRESULT WINAPI d3drm_animation1_SetAppData(IDirect3DRMAnimation *iface, DWORD data)
3123 {
3124 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3125
3126 TRACE("iface %p, data %#x.\n", iface, data);
3127
3128 return d3drm_animation2_SetAppData(&animation->IDirect3DRMAnimation2_iface, data);
3129 }
3130
3131 static DWORD WINAPI d3drm_animation2_GetAppData(IDirect3DRMAnimation2 *iface)
3132 {
3133 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3134
3135 TRACE("iface %p.\n", iface);
3136
3137 return animation->obj.appdata;
3138 }
3139
3140 static DWORD WINAPI d3drm_animation1_GetAppData(IDirect3DRMAnimation *iface)
3141 {
3142 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3143
3144 TRACE("iface %p.\n", iface);
3145
3146 return d3drm_animation2_GetAppData(&animation->IDirect3DRMAnimation2_iface);
3147 }
3148
3149 static HRESULT WINAPI d3drm_animation2_SetName(IDirect3DRMAnimation2 *iface, const char *name)
3150 {
3151 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3152
3153 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3154
3155 return d3drm_object_set_name(&animation->obj, name);
3156 }
3157
3158 static HRESULT WINAPI d3drm_animation1_SetName(IDirect3DRMAnimation *iface, const char *name)
3159 {
3160 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3161
3162 TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3163
3164 return d3drm_animation2_SetName(&animation->IDirect3DRMAnimation2_iface, name);
3165 }
3166
3167 static HRESULT WINAPI d3drm_animation2_GetName(IDirect3DRMAnimation2 *iface, DWORD *size, char *name)
3168 {
3169 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3170
3171 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3172
3173 return d3drm_object_get_name(&animation->obj, size, name);
3174 }
3175
3176 static HRESULT WINAPI d3drm_animation1_GetName(IDirect3DRMAnimation *iface, DWORD *size, char *name)
3177 {
3178 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3179
3180 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3181
3182 return d3drm_animation2_GetName(&animation->IDirect3DRMAnimation2_iface, size, name);
3183 }
3184
3185 static HRESULT WINAPI d3drm_animation2_GetClassName(IDirect3DRMAnimation2 *iface, DWORD *size, char *name)
3186 {
3187 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3188
3189 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3190
3191 return d3drm_object_get_class_name(&animation->obj, size, name);
3192 }
3193
3194 static HRESULT WINAPI d3drm_animation1_GetClassName(IDirect3DRMAnimation *iface, DWORD *size, char *name)
3195 {
3196 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3197
3198 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3199
3200 return d3drm_animation2_GetClassName(&animation->IDirect3DRMAnimation2_iface, size, name);
3201 }
3202
3203 static HRESULT WINAPI d3drm_animation2_SetOptions(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONOPTIONS options)
3204 {
3205 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3206 static const DWORD supported_options = D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED | D3DRMANIMATION_LINEARPOSITION
3207 | D3DRMANIMATION_SPLINEPOSITION | D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION;
3208
3209 TRACE("iface %p, options %#x.\n", iface, options);
3210
3211 if (!(options & supported_options))
3212 return D3DRMERR_BADVALUE;
3213
3214 if ((options & (D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED)) == (D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED) ||
3215 (options & (D3DRMANIMATION_LINEARPOSITION | D3DRMANIMATION_SPLINEPOSITION)) ==
3216 (D3DRMANIMATION_LINEARPOSITION | D3DRMANIMATION_SPLINEPOSITION) ||
3217 (options & (D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION)) ==
3218 (D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION))
3219 {
3220 return D3DRMERR_BADVALUE;
3221 }
3222
3223 animation->options = options;
3224
3225 return D3DRM_OK;
3226 }
3227
3228 static HRESULT WINAPI d3drm_animation1_SetOptions(IDirect3DRMAnimation *iface, D3DRMANIMATIONOPTIONS options)
3229 {
3230 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3231
3232 TRACE("iface %p, %#x.\n", iface, options);
3233
3234 return d3drm_animation2_SetOptions(&animation->IDirect3DRMAnimation2_iface, options);
3235 }
3236
3237 static SIZE_T d3drm_animation_lookup_key(const struct d3drm_animation_key *keys,
3238 SIZE_T count, D3DVALUE time)
3239 {
3240 SIZE_T start = 0, cur = 0, end = count;
3241
3242 while (start < end)
3243 {
3244 cur = start + (end - start) / 2;
3245
3246 if (time == keys[cur].time)
3247 return cur;
3248
3249 if (time < keys[cur].time)
3250 end = cur;
3251 else
3252 start = cur + 1;
3253 }
3254
3255 return cur;
3256 }
3257
3258 static SIZE_T d3drm_animation_get_index_min(const struct d3drm_animation_key *keys, SIZE_T count, D3DVALUE time)
3259 {
3260 SIZE_T i;
3261
3262 i = d3drm_animation_lookup_key(keys, count, time);
3263 while (i > 0 && keys[i - 1].time == time)
3264 --i;
3265
3266 return i;
3267 }
3268
3269 static SIZE_T d3drm_animation_get_index_max(const struct d3drm_animation_key *keys, SIZE_T count, D3DVALUE time)
3270 {
3271 SIZE_T i;
3272
3273 i = d3drm_animation_lookup_key(keys, count, time);
3274 while (i < count - 1 && keys[i + 1].time == time)
3275 ++i;
3276
3277 return i;
3278 }
3279
3280 static SIZE_T d3drm_animation_get_insert_position(const struct d3drm_animation_keys *keys, D3DVALUE time)
3281 {
3282 if (!keys->count || time < keys->keys[0].time)
3283 return 0;
3284
3285 if (time >= keys->keys[keys->count - 1].time)
3286 return keys->count;
3287
3288 return d3drm_animation_get_index_max(keys->keys, keys->count, time);
3289 }
3290
3291 static const struct d3drm_animation_key *d3drm_animation_get_range(const struct d3drm_animation_keys *keys,
3292 D3DVALUE time_min, D3DVALUE time_max, SIZE_T *count)
3293 {
3294 SIZE_T min;
3295
3296 if (!keys->count || time_max < keys->keys[0].time
3297 || time_min > keys->keys[keys->count - 1].time)
3298 return NULL;
3299
3300 min = d3drm_animation_get_index_min(keys->keys, keys->count, time_min);
3301 if (count)
3302 *count = d3drm_animation_get_index_max(&keys->keys[min], keys->count - min, time_max) - min + 1;
3303
3304 return &keys->keys[min];
3305 }
3306
3307 static HRESULT WINAPI d3drm_animation2_AddKey(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONKEY *key)
3308 {
3309 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3310 struct d3drm_animation_keys *keys;
3311 SIZE_T index;
3312
3313 TRACE("iface %p, key %p.\n", iface, key);
3314
3315 if (!key || key->dwSize != sizeof(*key))
3316 return E_INVALIDARG;
3317
3318 switch (key->dwKeyType)
3319 {
3320 case D3DRMANIMATION_POSITIONKEY:
3321 keys = &animation->position;
3322 break;
3323 case D3DRMANIMATION_SCALEKEY:
3324 keys = &animation->scale;
3325 break;
3326 case D3DRMANIMATION_ROTATEKEY:
3327 keys = &animation->rotate;
3328 break;
3329 default:
3330 return E_INVALIDARG;
3331 }
3332
3333 index = d3drm_animation_get_insert_position(keys, key->dvTime);
3334
3335 if (!d3drm_array_reserve((void **)&keys->keys, &keys->size, keys->count + 1, sizeof(*keys->keys)))
3336 return E_OUTOFMEMORY;
3337
3338 if (index < keys->count)
3339 memmove(&keys->keys[index + 1], &keys->keys[index], sizeof(*keys->keys) * (keys->count - index));
3340 keys->keys[index].time = key->dvTime;
3341 switch (key->dwKeyType)
3342 {
3343 case D3DRMANIMATION_POSITIONKEY:
3344 keys->keys[index].u.position = key->u.dvPositionKey;
3345 break;
3346 case D3DRMANIMATION_SCALEKEY:
3347 keys->keys[index].u.scale = key->u.dvScaleKey;
3348 break;
3349 case D3DRMANIMATION_ROTATEKEY:
3350 keys->keys[index].u.rotate = key->u.dqRotateKey;
3351 break;
3352 }
3353 ++keys->count;
3354
3355 return D3DRM_OK;
3356 }
3357
3358 static HRESULT WINAPI d3drm_animation2_AddRotateKey(IDirect3DRMAnimation2 *iface, D3DVALUE time, D3DRMQUATERNION *q)
3359 {
3360 D3DRMANIMATIONKEY key;
3361
3362 TRACE("iface %p, time %.8e, q %p.\n", iface, time, q);
3363
3364 key.dwSize = sizeof(key);
3365 key.dwKeyType = D3DRMANIMATION_ROTATEKEY;
3366 key.dvTime = time;
3367 key.dwID = 0;
3368 key.u.dqRotateKey = *q;
3369
3370 return d3drm_animation2_AddKey(iface, &key);
3371 }
3372
3373 static HRESULT WINAPI d3drm_animation1_AddRotateKey(IDirect3DRMAnimation *iface, D3DVALUE time, D3DRMQUATERNION *q)
3374 {
3375 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3376
3377 TRACE("iface %p, time %.8e, q %p.\n", iface, time, q);
3378
3379 return d3drm_animation2_AddRotateKey(&animation->IDirect3DRMAnimation2_iface, time, q);
3380 }
3381
3382 static HRESULT WINAPI d3drm_animation2_AddPositionKey(IDirect3DRMAnimation2 *iface, D3DVALUE time,
3383 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3384 {
3385 D3DRMANIMATIONKEY key;
3386
3387 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3388
3389 key.dwSize = sizeof(key);
3390 key.dwKeyType = D3DRMANIMATION_POSITIONKEY;
3391 key.dvTime = time;
3392 key.dwID = 0;
3393 key.u.dvPositionKey.u1.x = x;
3394 key.u.dvPositionKey.u2.y = y;
3395 key.u.dvPositionKey.u3.z = z;
3396
3397 return d3drm_animation2_AddKey(iface, &key);
3398 }
3399
3400 static HRESULT WINAPI d3drm_animation1_AddPositionKey(IDirect3DRMAnimation *iface, D3DVALUE time,
3401 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3402 {
3403 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3404
3405 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3406
3407 return d3drm_animation2_AddPositionKey(&animation->IDirect3DRMAnimation2_iface, time, x, y, z);
3408 }
3409
3410 static HRESULT WINAPI d3drm_animation2_AddScaleKey(IDirect3DRMAnimation2 *iface, D3DVALUE time,
3411 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3412 {
3413 D3DRMANIMATIONKEY key;
3414
3415 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3416
3417 key.dwSize = sizeof(key);
3418 key.dwKeyType = D3DRMANIMATION_SCALEKEY;
3419 key.dvTime = time;
3420 key.dwID = 0;
3421 key.u.dvScaleKey.u1.x = x;
3422 key.u.dvScaleKey.u2.y = y;
3423 key.u.dvScaleKey.u3.z = z;
3424
3425 return d3drm_animation2_AddKey(iface, &key);
3426 }
3427
3428 static HRESULT WINAPI d3drm_animation1_AddScaleKey(IDirect3DRMAnimation *iface, D3DVALUE time,
3429 D3DVALUE x, D3DVALUE y, D3DVALUE z)
3430 {
3431 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3432
3433 TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3434
3435 return d3drm_animation2_AddScaleKey(&animation->IDirect3DRMAnimation2_iface, time, x, y, z);
3436 }
3437
3438 static void d3drm_animation_delete_key(struct d3drm_animation_keys *keys, const struct d3drm_animation_key *key)
3439 {
3440 SIZE_T index = key - keys->keys;
3441
3442 if (index < keys->count - 1)
3443 memmove(&keys->keys[index], &keys->keys[index + 1], sizeof(*keys->keys) * (keys->count - index - 1));
3444 --keys->count;
3445 }
3446
3447 static HRESULT WINAPI d3drm_animation2_DeleteKey(IDirect3DRMAnimation2 *iface, D3DVALUE time)
3448 {
3449 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3450 const struct d3drm_animation_key *key;
3451
3452 TRACE("iface %p, time %.8e.\n", iface, time);
3453
3454 if ((key = d3drm_animation_get_range(&animation->rotate, time, time, NULL)))
3455 d3drm_animation_delete_key(&animation->rotate, key);
3456
3457 if ((key = d3drm_animation_get_range(&animation->position, time, time, NULL)))
3458 d3drm_animation_delete_key(&animation->position, key);
3459
3460 if ((key = d3drm_animation_get_range(&animation->scale, time, time, NULL)))
3461 d3drm_animation_delete_key(&animation->scale, key);
3462
3463 return D3DRM_OK;
3464 }
3465
3466 static HRESULT WINAPI d3drm_animation1_DeleteKey(IDirect3DRMAnimation *iface, D3DVALUE time)
3467 {
3468 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3469
3470 TRACE("iface %p, time %.8e.\n", iface, time);
3471
3472 return d3drm_animation2_DeleteKey(&animation->IDirect3DRMAnimation2_iface, time);
3473 }
3474
3475 static HRESULT WINAPI d3drm_animation1_SetFrame(IDirect3DRMAnimation *iface, IDirect3DRMFrame *frame)
3476 {
3477 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3478 HRESULT hr = D3DRM_OK;
3479
3480 TRACE("iface %p, frame %p.\n", iface, frame);
3481
3482 if (frame)
3483 {
3484 hr = IDirect3DRMFrame_QueryInterface(frame, &IID_IDirect3DRMFrame3, (void **)&animation->frame);
3485 if (SUCCEEDED(hr))
3486 IDirect3DRMFrame3_Release(animation->frame);
3487 }
3488 else
3489 animation->frame = NULL;
3490
3491 return hr;
3492 }
3493
3494 static HRESULT WINAPI d3drm_animation1_SetTime(IDirect3DRMAnimation *iface, D3DVALUE time)
3495 {
3496 FIXME("iface %p, time %.8e.\n", iface, time);
3497
3498 return E_NOTIMPL;
3499 }
3500
3501 static D3DRMANIMATIONOPTIONS WINAPI d3drm_animation2_GetOptions(IDirect3DRMAnimation2 *iface)
3502 {
3503 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3504
3505 TRACE("iface %p.\n", iface);
3506
3507 return animation->options;
3508 }
3509
3510 static D3DRMANIMATIONOPTIONS WINAPI d3drm_animation1_GetOptions(IDirect3DRMAnimation *iface)
3511 {
3512 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3513
3514 TRACE("iface %p.\n", iface);
3515
3516 return d3drm_animation2_GetOptions(&animation->IDirect3DRMAnimation2_iface);
3517 }
3518
3519 static HRESULT WINAPI d3drm_animation2_SetFrame(IDirect3DRMAnimation2 *iface, IDirect3DRMFrame3 *frame)
3520 {
3521 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3522
3523 TRACE("iface %p, frame %p.\n", iface, frame);
3524
3525 animation->frame = frame;
3526
3527 return D3DRM_OK;
3528 }
3529
3530 static HRESULT WINAPI d3drm_animation2_SetTime(IDirect3DRMAnimation2 *iface, D3DVALUE time)
3531 {
3532 FIXME("iface %p, time %.8e.\n", iface, time);
3533
3534 return E_NOTIMPL;
3535 }
3536
3537 static HRESULT WINAPI d3drm_animation2_GetFrame(IDirect3DRMAnimation2 *iface, IDirect3DRMFrame3 **frame)
3538 {
3539 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3540
3541 TRACE("iface %p, frame %p.\n", iface, frame);
3542
3543 if (!frame)
3544 return D3DRMERR_BADVALUE;
3545
3546 *frame = animation->frame;
3547 if (*frame)
3548 IDirect3DRMFrame3_AddRef(*frame);
3549
3550 return D3DRM_OK;
3551 }
3552
3553 static HRESULT WINAPI d3drm_animation2_DeleteKeyByID(IDirect3DRMAnimation2 *iface, DWORD id)
3554 {
3555 FIXME("iface %p, id %#x.\n", iface, id);
3556
3557 return E_NOTIMPL;
3558 }
3559
3560 static HRESULT WINAPI d3drm_animation2_ModifyKey(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONKEY *key)
3561 {
3562 FIXME("iface %p, key %p.\n", iface, key);
3563
3564 return E_NOTIMPL;
3565 }
3566
3567 static HRESULT WINAPI d3drm_animation2_GetKeys(IDirect3DRMAnimation2 *iface, D3DVALUE time_min, D3DVALUE time_max,
3568 DWORD *key_count, D3DRMANIMATIONKEY *keys)
3569 {
3570 struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3571 const struct d3drm_animation_key *key;
3572 SIZE_T count, i;
3573
3574 TRACE("iface %p, time min %.8e, time max %.8e, key_count %p, keys %p.\n",
3575 iface, time_min, time_max, key_count, keys);
3576
3577 if (!key_count)
3578 return D3DRMERR_BADVALUE;
3579
3580 *key_count = 0;
3581
3582 if ((key = d3drm_animation_get_range(&animation->rotate, time_min, time_max, &count)))
3583 {
3584 if (keys)
3585 {
3586 for (i = 0; i < count; ++i)
3587 {
3588 keys[i].dwSize = sizeof(*keys);
3589 keys[i].dwKeyType = D3DRMANIMATION_ROTATEKEY;
3590 keys[i].dvTime = key[i].time;
3591 keys[i].dwID = 0; /* FIXME */
3592 keys[i].u.dqRotateKey = key[i].u.rotate;
3593 }
3594 keys += count;
3595 }
3596 *key_count += count;
3597 }
3598
3599 if ((key = d3drm_animation_get_range(&animation->position, time_min, time_max, &count)))
3600 {
3601 if (keys)
3602 {
3603 for (i = 0; i < count; ++i)
3604 {
3605 keys[i].dwSize = sizeof(*keys);
3606 keys[i].dwKeyType = D3DRMANIMATION_POSITIONKEY;
3607 keys[i].dvTime = key[i].time;
3608 keys[i].dwID = 0; /* FIXME */
3609 keys[i].u.dvPositionKey = key[i].u.position;
3610 }
3611 keys += count;
3612 }
3613 *key_count += count;
3614 }
3615
3616 if ((key = d3drm_animation_get_range(&animation->scale, time_min, time_max, &count)))
3617 {
3618 if (keys)
3619 {
3620 for (i = 0; keys && i < count; ++i)
3621 {
3622 keys[i].dwSize = sizeof(*keys);
3623 keys[i].dwKeyType = D3DRMANIMATION_SCALEKEY;
3624 keys[i].dvTime = key[i].time;
3625 keys[i].dwID = 0; /* FIXME */
3626 keys[i].u.dvScaleKey = key[i].u.scale;
3627 }
3628 keys += count;
3629 }
3630 *key_count += count;
3631 }
3632
3633 return *key_count ? D3DRM_OK : D3DRMERR_NOSUCHKEY;
3634 }
3635
3636 static const struct IDirect3DRMAnimationVtbl d3drm_animation1_vtbl =
3637 {
3638 d3drm_animation1_QueryInterface,
3639 d3drm_animation1_AddRef,
3640 d3drm_animation1_Release,
3641 d3drm_animation1_Clone,
3642 d3drm_animation1_AddDestroyCallback,
3643 d3drm_animation1_DeleteDestroyCallback,
3644 d3drm_animation1_SetAppData,
3645 d3drm_animation1_GetAppData,
3646 d3drm_animation1_SetName,
3647 d3drm_animation1_GetName,
3648 d3drm_animation1_GetClassName,
3649 d3drm_animation1_SetOptions,
3650 d3drm_animation1_AddRotateKey,
3651 d3drm_animation1_AddPositionKey,
3652 d3drm_animation1_AddScaleKey,
3653 d3drm_animation1_DeleteKey,
3654 d3drm_animation1_SetFrame,
3655 d3drm_animation1_SetTime,
3656 d3drm_animation1_GetOptions,
3657 };
3658
3659 static const struct IDirect3DRMAnimation2Vtbl d3drm_animation2_vtbl =
3660 {
3661 d3drm_animation2_QueryInterface,
3662 d3drm_animation2_AddRef,
3663 d3drm_animation2_Release,
3664 d3drm_animation2_Clone,
3665 d3drm_animation2_AddDestroyCallback,
3666 d3drm_animation2_DeleteDestroyCallback,
3667 d3drm_animation2_SetAppData,
3668 d3drm_animation2_GetAppData,
3669 d3drm_animation2_SetName,
3670 d3drm_animation2_GetName,
3671 d3drm_animation2_GetClassName,
3672 d3drm_animation2_SetOptions,
3673 d3drm_animation2_AddRotateKey,
3674 d3drm_animation2_AddPositionKey,
3675 d3drm_animation2_AddScaleKey,
3676 d3drm_animation2_DeleteKey,
3677 d3drm_animation2_SetFrame,
3678 d3drm_animation2_SetTime,
3679 d3drm_animation2_GetOptions,
3680 d3drm_animation2_GetFrame,
3681 d3drm_animation2_DeleteKeyByID,
3682 d3drm_animation2_AddKey,
3683 d3drm_animation2_ModifyKey,
3684 d3drm_animation2_GetKeys,
3685 };
3686
3687 HRESULT d3drm_animation_create(struct d3drm_animation **animation, IDirect3DRM *d3drm)
3688 {
3689 static const char classname[] = "Animation";
3690 struct d3drm_animation *object;
3691 HRESULT hr = D3DRM_OK;
3692
3693 TRACE("animation %p, d3drm %p.\n", animation, d3drm);
3694
3695 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
3696 return E_OUTOFMEMORY;
3697
3698 object->IDirect3DRMAnimation_iface.lpVtbl = &d3drm_animation1_vtbl;
3699 object->IDirect3DRMAnimation2_iface.lpVtbl = &d3drm_animation2_vtbl;
3700 object->d3drm = d3drm;
3701 object->ref = 1;
3702 object->options = D3DRMANIMATION_CLOSED | D3DRMANIMATION_LINEARPOSITION;
3703
3704 d3drm_object_init(&object->obj, classname);
3705
3706 IDirect3DRM_AddRef(object->d3drm);
3707
3708 *animation = object;
3709
3710 return hr;
3711 }
Windows API implementation