?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
reg/tests: Test import with non-standard registry file headers.
[wine.git] / dlls / d3drm / frame.c
blob2758ec63ad4f348ab41a3ed9c38aa62cb47138e7
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 HRESULT WINAPI d3drm_frame_array_QueryInterface(IDirect3DRMFrameArray *iface, REFIID riid, void **out)
93 {
94 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
95
96 if (IsEqualGUID(riid, &IID_IDirect3DRMFrameArray)
97 || IsEqualGUID(riid, &IID_IUnknown))
98 {
99 IDirect3DRMFrameArray_AddRef(iface);
100 *out = iface;
101 return S_OK;
102 }
103
104 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
105
106 *out = NULL;
107 return E_NOINTERFACE;
108 }
109
110 static ULONG WINAPI d3drm_frame_array_AddRef(IDirect3DRMFrameArray *iface)
111 {
112 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
113 ULONG refcount = InterlockedIncrement(&array->ref);
114
115 TRACE("%p increasing refcount to %u.\n", iface, refcount);
116
117 return refcount;
118 }
119
120 static ULONG WINAPI d3drm_frame_array_Release(IDirect3DRMFrameArray *iface)
121 {
122 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
123 ULONG refcount = InterlockedDecrement(&array->ref);
124 ULONG i;
125
126 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
127
128 if (!refcount)
129 {
130 for (i = 0; i < array->size; ++i)
131 {
132 IDirect3DRMFrame_Release(array->frames[i]);
133 }
134 HeapFree(GetProcessHeap(), 0, array->frames);
135 HeapFree(GetProcessHeap(), 0, array);
136 }
137
138 return refcount;
139 }
140
141 static DWORD WINAPI d3drm_frame_array_GetSize(IDirect3DRMFrameArray *iface)
142 {
143 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
144
145 TRACE("iface %p.\n", iface);
146
147 return array->size;
148 }
149
150 static HRESULT WINAPI d3drm_frame_array_GetElement(IDirect3DRMFrameArray *iface,
151 DWORD index, IDirect3DRMFrame **frame)
152 {
153 struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
154
155 TRACE("iface %p, index %u, frame %p.\n", iface, index, frame);
156
157 if (!frame)
158 return D3DRMERR_BADVALUE;
159
160 if (index >= array->size)
161 {
162 *frame = NULL;
163 return D3DRMERR_BADVALUE;
164 }
165
166 IDirect3DRMFrame_AddRef(array->frames[index]);
167 *frame = array->frames[index];
168
169 return D3DRM_OK;
170 }
171
172 static const struct IDirect3DRMFrameArrayVtbl d3drm_frame_array_vtbl =
173 {
174 d3drm_frame_array_QueryInterface,
175 d3drm_frame_array_AddRef,
176 d3drm_frame_array_Release,
177 d3drm_frame_array_GetSize,
178 d3drm_frame_array_GetElement,
179 };
180
181 static struct d3drm_frame_array *d3drm_frame_array_create(unsigned int frame_count, IDirect3DRMFrame3 **frames)
182 {
183 struct d3drm_frame_array *array;
184 unsigned int i;
185
186 if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
187 return NULL;
188
189 array->IDirect3DRMFrameArray_iface.lpVtbl = &d3drm_frame_array_vtbl;
190 array->ref = 1;
191 array->size = frame_count;
192
193 if (frame_count)
194 {
195 if (!(array->frames = HeapAlloc(GetProcessHeap(), 0, frame_count * sizeof(*array->frames))))
196 {
197 HeapFree(GetProcessHeap(), 0, array);
198 return NULL;
199 }
200
201 for (i = 0; i < frame_count; ++i)
202 {
203 IDirect3DRMFrame3_QueryInterface(frames[i], &IID_IDirect3DRMFrame, (void **)&array->frames[i]);
204 }
205 }
206
207 return array;
208 }
209
210 static HRESULT WINAPI d3drm_visual_array_QueryInterface(IDirect3DRMVisualArray *iface, REFIID riid, void **out)
211 {
212 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
213
214 if (IsEqualGUID(riid, &IID_IDirect3DRMVisualArray)
215 || IsEqualGUID(riid, &IID_IUnknown))
216 {
217 IDirect3DRMVisualArray_AddRef(iface);
218 *out = iface;
219 return S_OK;
220 }
221
222 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
223
224 *out = NULL;
225 return E_NOINTERFACE;
226 }
227
228 static ULONG WINAPI d3drm_visual_array_AddRef(IDirect3DRMVisualArray *iface)
229 {
230 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
231 ULONG refcount = InterlockedIncrement(&array->ref);
232
233 TRACE("%p increasing refcount to %u.\n", iface, refcount);
234
235 return refcount;
236 }
237
238 static ULONG WINAPI d3drm_visual_array_Release(IDirect3DRMVisualArray *iface)
239 {
240 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
241 ULONG refcount = InterlockedDecrement(&array->ref);
242 ULONG i;
243
244 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
245
246 if (!refcount)
247 {
248 for (i = 0; i < array->size; ++i)
249 {
250 IDirect3DRMVisual_Release(array->visuals[i]);
251 }
252 HeapFree(GetProcessHeap(), 0, array->visuals);
253 HeapFree(GetProcessHeap(), 0, array);
254 }
255
256 return refcount;
257 }
258
259 static DWORD WINAPI d3drm_visual_array_GetSize(IDirect3DRMVisualArray *iface)
260 {
261 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
262
263 TRACE("iface %p.\n", iface);
264
265 return array->size;
266 }
267
268 static HRESULT WINAPI d3drm_visual_array_GetElement(IDirect3DRMVisualArray *iface,
269 DWORD index, IDirect3DRMVisual **visual)
270 {
271 struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
272
273 TRACE("iface %p, index %u, visual %p.\n", iface, index, visual);
274
275 if (!visual)
276 return D3DRMERR_BADVALUE;
277
278 if (index >= array->size)
279 {
280 *visual = NULL;
281 return D3DRMERR_BADVALUE;
282 }
283
284 IDirect3DRMVisual_AddRef(array->visuals[index]);
285 *visual = array->visuals[index];
286
287 return D3DRM_OK;
288 }
289
290 static const struct IDirect3DRMVisualArrayVtbl d3drm_visual_array_vtbl =
291 {
292 d3drm_visual_array_QueryInterface,
293 d3drm_visual_array_AddRef,
294 d3drm_visual_array_Release,
295 d3drm_visual_array_GetSize,
296 d3drm_visual_array_GetElement,
297 };
298
299 static struct d3drm_visual_array *d3drm_visual_array_create(unsigned int visual_count, IDirect3DRMVisual **visuals)
300 {
301 struct d3drm_visual_array *array;
302 unsigned int i;
303
304 if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
305 return NULL;
306
307 array->IDirect3DRMVisualArray_iface.lpVtbl = &d3drm_visual_array_vtbl;
308 array->ref = 1;
309 array->size = visual_count;
310
311 if (visual_count)
312 {
313 if (!(array->visuals = HeapAlloc(GetProcessHeap(), 0, visual_count * sizeof(*array->visuals))))
314 {
315 HeapFree(GetProcessHeap(), 0, array);
316 return NULL;
317 }
318
319 for (i = 0; i < visual_count; ++i)
320 {
321 array->visuals[i] = visuals[i];
322 IDirect3DRMVisual_AddRef(array->visuals[i]);
323 }
324 }
325
326 return array;
327 }
328
329 static HRESULT WINAPI d3drm_light_array_QueryInterface(IDirect3DRMLightArray *iface, REFIID riid, void **out)
330 {
331 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
332
333 if (IsEqualGUID(riid, &IID_IDirect3DRMLightArray)
334 || IsEqualGUID(riid, &IID_IUnknown))
335 {
336 IDirect3DRMLightArray_AddRef(iface);
337 *out = iface;
338 return S_OK;
339 }
340
341 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
342
343 *out = NULL;
344 return E_NOINTERFACE;
345 }
346
347 static ULONG WINAPI d3drm_light_array_AddRef(IDirect3DRMLightArray *iface)
348 {
349 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
350 ULONG refcount = InterlockedIncrement(&array->ref);
351
352 TRACE("%p increasing refcount to %u.\n", iface, refcount);
353
354 return refcount;
355 }
356
357 static ULONG WINAPI d3drm_light_array_Release(IDirect3DRMLightArray *iface)
358 {
359 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
360 ULONG refcount = InterlockedDecrement(&array->ref);
361 ULONG i;
362
363 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
364
365 if (!refcount)
366 {
367 for (i = 0; i < array->size; ++i)
368 {
369 IDirect3DRMLight_Release(array->lights[i]);
370 }
371 HeapFree(GetProcessHeap(), 0, array->lights);
372 HeapFree(GetProcessHeap(), 0, array);
373 }
374
375 return refcount;
376 }
377
378 static DWORD WINAPI d3drm_light_array_GetSize(IDirect3DRMLightArray *iface)
379 {
380 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
381
382 TRACE("iface %p.\n", iface);
383
384 return array->size;
385 }
386
387 static HRESULT WINAPI d3drm_light_array_GetElement(IDirect3DRMLightArray *iface,
388 DWORD index, IDirect3DRMLight **light)
389 {
390 struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
391
392 TRACE("iface %p, index %u, light %p.\n", iface, index, light);
393
394 if (!light)
395 return D3DRMERR_BADVALUE;
396
397 if (index >= array->size)
398 {
399 *light = NULL;
400 return D3DRMERR_BADVALUE;
401 }
402
403 IDirect3DRMLight_AddRef(array->lights[index]);
404 *light = array->lights[index];
405
406 return D3DRM_OK;
407 }
408
409 static const struct IDirect3DRMLightArrayVtbl d3drm_light_array_vtbl =
410 {
411 d3drm_light_array_QueryInterface,
412 d3drm_light_array_AddRef,
413 d3drm_light_array_Release,
414 d3drm_light_array_GetSize,
415 d3drm_light_array_GetElement,
416 };
417
418 static struct d3drm_light_array *d3drm_light_array_create(unsigned int light_count, IDirect3DRMLight **lights)
419 {
420 struct d3drm_light_array *array;
421 unsigned int i;
422
423 if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
424 return NULL;
425
426 array->IDirect3DRMLightArray_iface.lpVtbl = &d3drm_light_array_vtbl;
427 array->ref = 1;
428 array->size = light_count;
429
430 if (light_count)
431 {
432 if (!(array->lights = HeapAlloc(GetProcessHeap(), 0, light_count * sizeof(*array->lights))))
433 {
434 HeapFree(GetProcessHeap(), 0, array);
435 return NULL;
436 }
437
438 for (i = 0; i < light_count; ++i)
439 {
440 array->lights[i] = lights[i];
441 IDirect3DRMLight_AddRef(array->lights[i]);
442 }
443 }
444
445 return array;
446 }
447
448 static HRESULT WINAPI d3drm_frame3_QueryInterface(IDirect3DRMFrame3 *iface, REFIID riid, void **out)
449 {
450 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
451
452 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
453
454 if (IsEqualGUID(riid, &IID_IDirect3DRMFrame)
455 || IsEqualGUID(riid, &IID_IDirect3DRMObject)
456 || IsEqualGUID(riid, &IID_IDirect3DRMVisual)
457 || IsEqualGUID(riid, &IID_IUnknown))
458 {
459 *out = &frame->IDirect3DRMFrame_iface;
460 }
461 else if (IsEqualGUID(riid, &IID_IDirect3DRMFrame2))
462 {
463 *out = &frame->IDirect3DRMFrame2_iface;
464 }
465 else if (IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
466 {
467 *out = &frame->IDirect3DRMFrame3_iface;
468 }
469 else
470 {
471 *out = NULL;
472 WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
473 return CLASS_E_CLASSNOTAVAILABLE;
474 }
475
476 IUnknown_AddRef((IUnknown *)*out);
477 return S_OK;
478 }
479
480 static HRESULT WINAPI d3drm_frame2_QueryInterface(IDirect3DRMFrame2 *iface, REFIID riid, void **out)
481 {
482 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
483
484 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
485
486 return d3drm_frame3_QueryInterface(&frame->IDirect3DRMFrame3_iface, riid, out);
487 }
488
489 static HRESULT WINAPI d3drm_frame1_QueryInterface(IDirect3DRMFrame *iface, REFIID riid, void **out)
490 {
491 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
492
493 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
494
495 return d3drm_frame3_QueryInterface(&frame->IDirect3DRMFrame3_iface, riid, out);
496 }
497
498 static ULONG WINAPI d3drm_frame3_AddRef(IDirect3DRMFrame3 *iface)
499 {
500 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
501 ULONG refcount = InterlockedIncrement(&frame->ref);
502
503 TRACE("%p increasing refcount to %u.\n", iface, refcount);
504
505 return refcount;
506 }
507
508 static ULONG WINAPI d3drm_frame2_AddRef(IDirect3DRMFrame2 *iface)
509 {
510 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
511
512 TRACE("iface %p.\n", iface);
513
514 return d3drm_frame3_AddRef(&frame->IDirect3DRMFrame3_iface);
515 }
516
517 static ULONG WINAPI d3drm_frame1_AddRef(IDirect3DRMFrame *iface)
518 {
519 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
520
521 TRACE("iface %p.\n", iface);
522
523 return d3drm_frame3_AddRef(&frame->IDirect3DRMFrame3_iface);
524 }
525
526 static ULONG WINAPI d3drm_frame3_Release(IDirect3DRMFrame3 *iface)
527 {
528 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
529 ULONG refcount = InterlockedDecrement(&frame->ref);
530 ULONG i;
531
532 TRACE("%p decreasing refcount to %u.\n", iface, refcount);
533
534 if (!refcount)
535 {
536 for (i = 0; i < frame->nb_children; ++i)
537 {
538 IDirect3DRMFrame3_Release(frame->children[i]);
539 }
540 HeapFree(GetProcessHeap(), 0, frame->children);
541 for (i = 0; i < frame->nb_visuals; ++i)
542 {
543 IDirect3DRMVisual_Release(frame->visuals[i]);
544 }
545 HeapFree(GetProcessHeap(), 0, frame->visuals);
546 for (i = 0; i < frame->nb_lights; ++i)
547 {
548 IDirect3DRMLight_Release(frame->lights[i]);
549 }
550 HeapFree(GetProcessHeap(), 0, frame->lights);
551 HeapFree(GetProcessHeap(), 0, frame);
552 }
553
554 return refcount;
555 }
556
557 static ULONG WINAPI d3drm_frame2_Release(IDirect3DRMFrame2 *iface)
558 {
559 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
560
561 TRACE("iface %p.\n", iface);
562
563 return d3drm_frame3_Release(&frame->IDirect3DRMFrame3_iface);
564 }
565
566 static ULONG WINAPI d3drm_frame1_Release(IDirect3DRMFrame *iface)
567 {
568 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
569
570 TRACE("iface %p.\n", iface);
571
572 return d3drm_frame3_Release(&frame->IDirect3DRMFrame3_iface);
573 }
574
575 static HRESULT WINAPI d3drm_frame3_Clone(IDirect3DRMFrame3 *iface,
576 IUnknown *outer, REFIID iid, void **out)
577 {
578 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
579
580 return E_NOTIMPL;
581 }
582
583 static HRESULT WINAPI d3drm_frame2_Clone(IDirect3DRMFrame2 *iface,
584 IUnknown *outer, REFIID iid, void **out)
585 {
586 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
587
588 return E_NOTIMPL;
589 }
590
591 static HRESULT WINAPI d3drm_frame1_Clone(IDirect3DRMFrame *iface,
592 IUnknown *outer, REFIID iid, void **out)
593 {
594 FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
595
596 return E_NOTIMPL;
597 }
598
599 static HRESULT WINAPI d3drm_frame3_AddDestroyCallback(IDirect3DRMFrame3 *iface,
600 D3DRMOBJECTCALLBACK cb, void *ctx)
601 {
602 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
603
604 return E_NOTIMPL;
605 }
606
607 static HRESULT WINAPI d3drm_frame2_AddDestroyCallback(IDirect3DRMFrame2 *iface,
608 D3DRMOBJECTCALLBACK cb, void *ctx)
609 {
610 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
611
612 return E_NOTIMPL;
613 }
614
615 static HRESULT WINAPI d3drm_frame1_AddDestroyCallback(IDirect3DRMFrame *iface,
616 D3DRMOBJECTCALLBACK cb, void *ctx)
617 {
618 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
619
620 return E_NOTIMPL;
621 }
622
623 static HRESULT WINAPI d3drm_frame3_DeleteDestroyCallback(IDirect3DRMFrame3 *iface,
624 D3DRMOBJECTCALLBACK cb, void *ctx)
625 {
626 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
627
628 return E_NOTIMPL;
629 }
630
631 static HRESULT WINAPI d3drm_frame2_DeleteDestroyCallback(IDirect3DRMFrame2 *iface,
632 D3DRMOBJECTCALLBACK cb, void *ctx)
633 {
634 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
635
636 return E_NOTIMPL;
637 }
638
639 static HRESULT WINAPI d3drm_frame1_DeleteDestroyCallback(IDirect3DRMFrame *iface,
640 D3DRMOBJECTCALLBACK cb, void *ctx)
641 {
642 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
643
644 return E_NOTIMPL;
645 }
646
647 static HRESULT WINAPI d3drm_frame3_SetAppData(IDirect3DRMFrame3 *iface, DWORD data)
648 {
649 FIXME("iface %p, data %#x stub!\n", iface, data);
650
651 return E_NOTIMPL;
652 }
653
654 static HRESULT WINAPI d3drm_frame2_SetAppData(IDirect3DRMFrame2 *iface, DWORD data)
655 {
656 FIXME("iface %p, data %#x stub!\n", iface, data);
657
658 return E_NOTIMPL;
659 }
660
661 static HRESULT WINAPI d3drm_frame1_SetAppData(IDirect3DRMFrame *iface, DWORD data)
662 {
663 FIXME("iface %p, data %#x stub!\n", iface, data);
664
665 return E_NOTIMPL;
666 }
667
668 static DWORD WINAPI d3drm_frame3_GetAppData(IDirect3DRMFrame3 *iface)
669 {
670 FIXME("iface %p stub!\n", iface);
671
672 return 0;
673 }
674
675 static DWORD WINAPI d3drm_frame2_GetAppData(IDirect3DRMFrame2 *iface)
676 {
677 FIXME("iface %p stub!\n", iface);
678
679 return 0;
680 }
681
682 static DWORD WINAPI d3drm_frame1_GetAppData(IDirect3DRMFrame *iface)
683 {
684 FIXME("iface %p stub!\n", iface);
685
686 return 0;
687 }
688
689 static HRESULT WINAPI d3drm_frame3_SetName(IDirect3DRMFrame3 *iface, const char *name)
690 {
691 FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
692
693 return E_NOTIMPL;
694 }
695
696 static HRESULT WINAPI d3drm_frame2_SetName(IDirect3DRMFrame2 *iface, const char *name)
697 {
698 FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
699
700 return E_NOTIMPL;
701 }
702
703 static HRESULT WINAPI d3drm_frame1_SetName(IDirect3DRMFrame *iface, const char *name)
704 {
705 FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
706
707 return E_NOTIMPL;
708 }
709
710 static HRESULT WINAPI d3drm_frame3_GetName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
711 {
712 FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
713
714 return E_NOTIMPL;
715 }
716
717 static HRESULT WINAPI d3drm_frame2_GetName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
718 {
719 FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
720
721 return E_NOTIMPL;
722 }
723
724 static HRESULT WINAPI d3drm_frame1_GetName(IDirect3DRMFrame *iface, DWORD *size, char *name)
725 {
726 FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
727
728 return E_NOTIMPL;
729 }
730
731 static HRESULT WINAPI d3drm_frame3_GetClassName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
732 {
733 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
734
735 if (!size || *size < strlen("Frame") || !name)
736 return E_INVALIDARG;
737
738 strcpy(name, "Frame");
739 *size = sizeof("Frame");
740
741 return D3DRM_OK;
742 }
743
744 static HRESULT WINAPI d3drm_frame2_GetClassName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
745 {
746 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
747
748 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
749
750 return d3drm_frame3_GetClassName(&frame->IDirect3DRMFrame3_iface, size, name);
751 }
752
753 static HRESULT WINAPI d3drm_frame1_GetClassName(IDirect3DRMFrame *iface, DWORD *size, char *name)
754 {
755 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
756
757 TRACE("iface %p, size %p, name %p.\n", iface, size, name);
758
759 return d3drm_frame3_GetClassName(&frame->IDirect3DRMFrame3_iface, size, name);
760 }
761
762 static HRESULT WINAPI d3drm_frame3_AddChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
763 {
764 struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
765 struct d3drm_frame *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
766
767 TRACE("iface %p, child %p.\n", iface, child);
768
769 if (!child_obj)
770 return D3DRMERR_BADOBJECT;
771
772 if (child_obj->parent)
773 {
774 IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
775
776 if (parent == iface)
777 {
778 /* Passed frame is already a child so return success */
779 return D3DRM_OK;
780 }
781 else
782 {
783 /* Remove parent and continue */
784 IDirect3DRMFrame3_DeleteChild(parent, child);
785 }
786 }
787
788 if ((This->nb_children + 1) > This->children_capacity)
789 {
790 ULONG new_capacity;
791 IDirect3DRMFrame3** children;
792
793 if (!This->children_capacity)
794 {
795 new_capacity = 16;
796 children = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMFrame3*));
797 }
798 else
799 {
800 new_capacity = This->children_capacity * 2;
801 children = HeapReAlloc(GetProcessHeap(), 0, This->children, new_capacity * sizeof(IDirect3DRMFrame3*));
802 }
803
804 if (!children)
805 return E_OUTOFMEMORY;
806
807 This->children_capacity = new_capacity;
808 This->children = children;
809 }
810
811 This->children[This->nb_children++] = child;
812 IDirect3DRMFrame3_AddRef(child);
813 child_obj->parent = This;
814
815 return D3DRM_OK;
816 }
817
818 static HRESULT WINAPI d3drm_frame2_AddChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
819 {
820 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
821 IDirect3DRMFrame3 *child3;
822 HRESULT hr;
823
824 TRACE("iface %p, child %p.\n", iface, child);
825
826 if (!child)
827 return D3DRMERR_BADOBJECT;
828 hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3);
829 if (hr != S_OK)
830 return D3DRMERR_BADOBJECT;
831 IDirect3DRMFrame_Release(child);
832
833 return d3drm_frame3_AddChild(&frame->IDirect3DRMFrame3_iface, child3);
834 }
835
836 static HRESULT WINAPI d3drm_frame1_AddChild(IDirect3DRMFrame *iface, IDirect3DRMFrame *child)
837 {
838 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
839 struct d3drm_frame *child_frame = unsafe_impl_from_IDirect3DRMFrame(child);
840
841 TRACE("iface %p, child %p.\n", iface, child);
842
843 if (!child_frame)
844 return D3DRMERR_BADOBJECT;
845
846 return d3drm_frame3_AddChild(&frame->IDirect3DRMFrame3_iface, &child_frame->IDirect3DRMFrame3_iface);
847 }
848
849 static HRESULT WINAPI d3drm_frame3_AddLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
850 {
851 struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
852 ULONG i;
853 IDirect3DRMLight** lights;
854
855 TRACE("iface %p, light %p.\n", iface, light);
856
857 if (!light)
858 return D3DRMERR_BADOBJECT;
859
860 /* Check if already existing and return gracefully without increasing ref count */
861 for (i = 0; i < This->nb_lights; i++)
862 if (This->lights[i] == light)
863 return D3DRM_OK;
864
865 if ((This->nb_lights + 1) > This->lights_capacity)
866 {
867 ULONG new_capacity;
868
869 if (!This->lights_capacity)
870 {
871 new_capacity = 16;
872 lights = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMLight*));
873 }
874 else
875 {
876 new_capacity = This->lights_capacity * 2;
877 lights = HeapReAlloc(GetProcessHeap(), 0, This->lights, new_capacity * sizeof(IDirect3DRMLight*));
878 }
879
880 if (!lights)
881 return E_OUTOFMEMORY;
882
883 This->lights_capacity = new_capacity;
884 This->lights = lights;
885 }
886
887 This->lights[This->nb_lights++] = light;
888 IDirect3DRMLight_AddRef(light);
889
890 return D3DRM_OK;
891 }
892
893 static HRESULT WINAPI d3drm_frame2_AddLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
894 {
895 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
896
897 TRACE("iface %p, light %p.\n", iface, light);
898
899 return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
900 }
901
902 static HRESULT WINAPI d3drm_frame1_AddLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
903 {
904 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
905
906 TRACE("iface %p, light %p.\n", iface, light);
907
908 return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
909 }
910
911 static HRESULT WINAPI d3drm_frame3_AddMoveCallback(IDirect3DRMFrame3 *iface,
912 D3DRMFRAME3MOVECALLBACK cb, void *ctx, DWORD flags)
913 {
914 FIXME("iface %p, cb %p, ctx %p flags %#x stub!\n", iface, cb, ctx, flags);
915
916 return E_NOTIMPL;
917 }
918
919 static HRESULT WINAPI d3drm_frame2_AddMoveCallback(IDirect3DRMFrame2 *iface,
920 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
921 {
922 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
923
924 return E_NOTIMPL;
925 }
926
927 static HRESULT WINAPI d3drm_frame1_AddMoveCallback(IDirect3DRMFrame *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_frame3_AddTransform(IDirect3DRMFrame3 *iface,
936 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
937 {
938 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
939
940 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
941
942 switch (type)
943 {
944 case D3DRMCOMBINE_REPLACE:
945 memcpy(frame->transform, matrix, sizeof(D3DRMMATRIX4D));
946 break;
947
948 case D3DRMCOMBINE_BEFORE:
949 FIXME("D3DRMCOMBINE_BEFORE not supported yet\n");
950 break;
951
952 case D3DRMCOMBINE_AFTER:
953 FIXME("D3DRMCOMBINE_AFTER not supported yet\n");
954 break;
955
956 default:
957 WARN("Unknown Combine Type %u\n", type);
958 return D3DRMERR_BADVALUE;
959 }
960
961 return S_OK;
962 }
963
964 static HRESULT WINAPI d3drm_frame2_AddTransform(IDirect3DRMFrame2 *iface,
965 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
966 {
967 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
968
969 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
970
971 return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
972 }
973
974 static HRESULT WINAPI d3drm_frame1_AddTransform(IDirect3DRMFrame *iface,
975 D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
976 {
977 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
978
979 TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
980
981 return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
982 }
983
984 static HRESULT WINAPI d3drm_frame3_AddTranslation(IDirect3DRMFrame3 *iface,
985 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
986 {
987 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
988
989 return E_NOTIMPL;
990 }
991
992 static HRESULT WINAPI d3drm_frame2_AddTranslation(IDirect3DRMFrame2 *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_frame1_AddTranslation(IDirect3DRMFrame *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_frame3_AddScale(IDirect3DRMFrame3 *iface,
1009 D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1010 {
1011 FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1012
1013 return E_NOTIMPL;
1014 }
1015
1016 static HRESULT WINAPI d3drm_frame2_AddScale(IDirect3DRMFrame2 *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_frame1_AddScale(IDirect3DRMFrame *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_frame3_AddRotation(IDirect3DRMFrame3 *iface,
1033 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1034 {
1035 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
1036 iface, type, x, y, z, theta);
1037
1038 return E_NOTIMPL;
1039 }
1040
1041 static HRESULT WINAPI d3drm_frame2_AddRotation(IDirect3DRMFrame2 *iface,
1042 D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1043 {
1044 FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n", iface, type, x, y, z, theta);
1045
1046 return E_NOTIMPL;
1047 }
1048
1049 static HRESULT WINAPI d3drm_frame1_AddRotation(IDirect3DRMFrame *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_frame3_AddVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1058 {
1059 struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
1060 ULONG i;
1061 IDirect3DRMVisual** visuals;
1062
1063 TRACE("iface %p, visual %p.\n", iface, visual);
1064
1065 if (!visual)
1066 return D3DRMERR_BADOBJECT;
1067
1068 /* Check if already existing and return gracefully without increasing ref count */
1069 for (i = 0; i < This->nb_visuals; i++)
1070 if (This->visuals[i] == (IDirect3DRMVisual *)visual)
1071 return D3DRM_OK;
1072
1073 if ((This->nb_visuals + 1) > This->visuals_capacity)
1074 {
1075 ULONG new_capacity;
1076
1077 if (!This->visuals_capacity)
1078 {
1079 new_capacity = 16;
1080 visuals = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMVisual*));
1081 }
1082 else
1083 {
1084 new_capacity = This->visuals_capacity * 2;
1085 visuals = HeapReAlloc(GetProcessHeap(), 0, This->visuals, new_capacity * sizeof(IDirect3DRMVisual*));
1086 }
1087
1088 if (!visuals)
1089 return E_OUTOFMEMORY;
1090
1091 This->visuals_capacity = new_capacity;
1092 This->visuals = visuals;
1093 }
1094
1095 This->visuals[This->nb_visuals++] = (IDirect3DRMVisual *)visual;
1096 IDirect3DRMVisual_AddRef(visual);
1097
1098 return D3DRM_OK;
1099 }
1100
1101 static HRESULT WINAPI d3drm_frame2_AddVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1102 {
1103 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1104
1105 TRACE("iface %p, visual %p.\n", iface, visual);
1106
1107 return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1108 }
1109
1110 static HRESULT WINAPI d3drm_frame1_AddVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1111 {
1112 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1113
1114 TRACE("iface %p, visual %p.\n", iface, visual);
1115
1116 return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1117 }
1118
1119 static HRESULT WINAPI d3drm_frame3_GetChildren(IDirect3DRMFrame3 *iface, IDirect3DRMFrameArray **children)
1120 {
1121 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1122 struct d3drm_frame_array *array;
1123
1124 TRACE("iface %p, children %p.\n", iface, children);
1125
1126 if (!children)
1127 return D3DRMERR_BADVALUE;
1128
1129 if (!(array = d3drm_frame_array_create(frame->nb_children, frame->children)))
1130 return E_OUTOFMEMORY;
1131
1132 *children = &array->IDirect3DRMFrameArray_iface;
1133
1134 return D3DRM_OK;
1135 }
1136
1137 static HRESULT WINAPI d3drm_frame2_GetChildren(IDirect3DRMFrame2 *iface, IDirect3DRMFrameArray **children)
1138 {
1139 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1140
1141 TRACE("iface %p, children %p.\n", iface, children);
1142
1143 return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1144 }
1145
1146 static HRESULT WINAPI d3drm_frame1_GetChildren(IDirect3DRMFrame *iface, IDirect3DRMFrameArray **children)
1147 {
1148 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1149
1150 TRACE("iface %p, children %p.\n", iface, children);
1151
1152 return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1153 }
1154
1155 static D3DCOLOR WINAPI d3drm_frame3_GetColor(IDirect3DRMFrame3 *iface)
1156 {
1157 FIXME("iface %p stub!\n", iface);
1158
1159 return 0;
1160 }
1161
1162 static D3DCOLOR WINAPI d3drm_frame2_GetColor(IDirect3DRMFrame2 *iface)
1163 {
1164 FIXME("iface %p stub!\n", iface);
1165
1166 return 0;
1167 }
1168
1169 static D3DCOLOR WINAPI d3drm_frame1_GetColor(IDirect3DRMFrame *iface)
1170 {
1171 FIXME("iface %p stub!\n", iface);
1172
1173 return 0;
1174 }
1175
1176 static HRESULT WINAPI d3drm_frame3_GetLights(IDirect3DRMFrame3 *iface, IDirect3DRMLightArray **lights)
1177 {
1178 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1179 struct d3drm_light_array *array;
1180
1181 TRACE("iface %p, lights %p.\n", iface, lights);
1182
1183 if (!lights)
1184 return D3DRMERR_BADVALUE;
1185
1186 if (!(array = d3drm_light_array_create(frame->nb_lights, frame->lights)))
1187 return E_OUTOFMEMORY;
1188
1189 *lights = &array->IDirect3DRMLightArray_iface;
1190
1191 return D3DRM_OK;
1192 }
1193
1194 static HRESULT WINAPI d3drm_frame2_GetLights(IDirect3DRMFrame2 *iface, IDirect3DRMLightArray **lights)
1195 {
1196 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1197
1198 TRACE("iface %p, lights %p.\n", iface, lights);
1199
1200 return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1201 }
1202
1203 static HRESULT WINAPI d3drm_frame1_GetLights(IDirect3DRMFrame *iface, IDirect3DRMLightArray **lights)
1204 {
1205 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1206
1207 TRACE("iface %p, lights %p.\n", iface, lights);
1208
1209 return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1210 }
1211
1212 static D3DRMMATERIALMODE WINAPI d3drm_frame3_GetMaterialMode(IDirect3DRMFrame3 *iface)
1213 {
1214 FIXME("iface %p stub!\n", iface);
1215
1216 return D3DRMMATERIAL_FROMPARENT;
1217 }
1218
1219 static D3DRMMATERIALMODE WINAPI d3drm_frame2_GetMaterialMode(IDirect3DRMFrame2 *iface)
1220 {
1221 FIXME("iface %p stub!\n", iface);
1222
1223 return D3DRMMATERIAL_FROMPARENT;
1224 }
1225
1226 static D3DRMMATERIALMODE WINAPI d3drm_frame1_GetMaterialMode(IDirect3DRMFrame *iface)
1227 {
1228 FIXME("iface %p stub!\n", iface);
1229
1230 return D3DRMMATERIAL_FROMPARENT;
1231 }
1232
1233 static HRESULT WINAPI d3drm_frame3_GetParent(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **parent)
1234 {
1235 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1236
1237 TRACE("iface %p, parent %p.\n", iface, parent);
1238
1239 if (!parent)
1240 return D3DRMERR_BADVALUE;
1241
1242 if (frame->parent)
1243 {
1244 *parent = &frame->parent->IDirect3DRMFrame3_iface;
1245 IDirect3DRMFrame_AddRef(*parent);
1246 }
1247 else
1248 {
1249 *parent = NULL;
1250 }
1251
1252 return D3DRM_OK;
1253 }
1254
1255 static HRESULT WINAPI d3drm_frame2_GetParent(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **parent)
1256 {
1257 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1258
1259 TRACE("iface %p, parent %p.\n", iface, parent);
1260
1261 if (!parent)
1262 return D3DRMERR_BADVALUE;
1263
1264 if (frame->parent)
1265 {
1266 *parent = &frame->parent->IDirect3DRMFrame_iface;
1267 IDirect3DRMFrame_AddRef(*parent);
1268 }
1269 else
1270 {
1271 *parent = NULL;
1272 }
1273
1274 return D3DRM_OK;
1275 }
1276
1277 static HRESULT WINAPI d3drm_frame1_GetParent(IDirect3DRMFrame *iface, IDirect3DRMFrame **parent)
1278 {
1279 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1280
1281 TRACE("iface %p, parent %p.\n", iface, parent);
1282
1283 return d3drm_frame2_GetParent(&frame->IDirect3DRMFrame2_iface, parent);
1284 }
1285
1286 static HRESULT WINAPI d3drm_frame3_GetPosition(IDirect3DRMFrame3 *iface,
1287 IDirect3DRMFrame3 *reference, D3DVECTOR *position)
1288 {
1289 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1290
1291 return E_NOTIMPL;
1292 }
1293
1294 static HRESULT WINAPI d3drm_frame2_GetPosition(IDirect3DRMFrame2 *iface,
1295 IDirect3DRMFrame *reference, D3DVECTOR *position)
1296 {
1297 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1298
1299 return E_NOTIMPL;
1300 }
1301
1302 static HRESULT WINAPI d3drm_frame1_GetPosition(IDirect3DRMFrame *iface,
1303 IDirect3DRMFrame *reference, D3DVECTOR *position)
1304 {
1305 FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1306
1307 return E_NOTIMPL;
1308 }
1309
1310
1311 static HRESULT WINAPI d3drm_frame3_GetRotation(IDirect3DRMFrame3 *iface,
1312 IDirect3DRMFrame3 *reference, D3DVECTOR *axis, D3DVALUE *theta)
1313 {
1314 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1315
1316 return E_NOTIMPL;
1317 }
1318
1319 static HRESULT WINAPI d3drm_frame2_GetRotation(IDirect3DRMFrame2 *iface,
1320 IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1321 {
1322 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1323
1324 return E_NOTIMPL;
1325 }
1326
1327 static HRESULT WINAPI d3drm_frame1_GetRotation(IDirect3DRMFrame *iface,
1328 IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1329 {
1330 FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1331
1332 return E_NOTIMPL;
1333 }
1334
1335 static HRESULT WINAPI d3drm_frame3_GetScene(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **scene)
1336 {
1337 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1338
1339 TRACE("iface %p, scene %p.\n", iface, scene);
1340
1341 if (!scene)
1342 return D3DRMERR_BADVALUE;
1343
1344 while (frame->parent)
1345 frame = frame->parent;
1346
1347 *scene = &frame->IDirect3DRMFrame3_iface;
1348 IDirect3DRMFrame3_AddRef(*scene);
1349
1350 return D3DRM_OK;
1351 }
1352
1353 static HRESULT WINAPI d3drm_frame2_GetScene(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **scene)
1354 {
1355 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1356 IDirect3DRMFrame3 *frame3;
1357 HRESULT hr;
1358
1359 TRACE("iface %p, scene %p.\n", iface, scene);
1360
1361 if (!scene)
1362 return D3DRMERR_BADVALUE;
1363
1364 hr = IDirect3DRMFrame3_GetScene(&frame->IDirect3DRMFrame3_iface, &frame3);
1365 if (FAILED(hr) || !frame3)
1366 {
1367 *scene = NULL;
1368 return hr;
1369 }
1370
1371 hr = IDirect3DRMFrame3_QueryInterface(frame3, &IID_IDirect3DRMFrame, (void **)scene);
1372 IDirect3DRMFrame3_Release(frame3);
1373
1374 return hr;
1375 }
1376
1377 static HRESULT WINAPI d3drm_frame1_GetScene(IDirect3DRMFrame *iface, IDirect3DRMFrame **scene)
1378 {
1379 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1380
1381 TRACE("iface %p, scene %p.\n", iface, scene);
1382
1383 return d3drm_frame2_GetScene(&frame->IDirect3DRMFrame2_iface, scene);
1384 }
1385
1386 static D3DRMSORTMODE WINAPI d3drm_frame3_GetSortMode(IDirect3DRMFrame3 *iface)
1387 {
1388 FIXME("iface %p stub!\n", iface);
1389
1390 return D3DRMSORT_FROMPARENT;
1391 }
1392
1393 static D3DRMSORTMODE WINAPI d3drm_frame2_GetSortMode(IDirect3DRMFrame2 *iface)
1394 {
1395 FIXME("iface %p stub!\n", iface);
1396
1397 return D3DRMSORT_FROMPARENT;
1398 }
1399
1400 static D3DRMSORTMODE WINAPI d3drm_frame1_GetSortMode(IDirect3DRMFrame *iface)
1401 {
1402 FIXME("iface %p stub!\n", iface);
1403
1404 return D3DRMSORT_FROMPARENT;
1405 }
1406
1407 static HRESULT WINAPI d3drm_frame3_GetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 **texture)
1408 {
1409 FIXME("iface %p, texture %p stub!\n", iface, texture);
1410
1411 return E_NOTIMPL;
1412 }
1413
1414 static HRESULT WINAPI d3drm_frame2_GetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture **texture)
1415 {
1416 FIXME("iface %p, texture %p stub!\n", iface, texture);
1417
1418 return E_NOTIMPL;
1419 }
1420
1421 static HRESULT WINAPI d3drm_frame1_GetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture **texture)
1422 {
1423 FIXME("iface %p, texture %p stub!\n", iface, texture);
1424
1425 return E_NOTIMPL;
1426 }
1427
1428 static HRESULT WINAPI d3drm_frame3_GetTransform(IDirect3DRMFrame3 *iface,
1429 IDirect3DRMFrame3 *reference, D3DRMMATRIX4D matrix)
1430 {
1431 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1432
1433 TRACE("iface %p, reference %p, matrix %p.\n", iface, reference, matrix);
1434
1435 if (reference)
1436 FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1437
1438 memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
1439
1440 return D3DRM_OK;
1441 }
1442
1443 static HRESULT WINAPI d3drm_frame2_GetTransform(IDirect3DRMFrame2 *iface, D3DRMMATRIX4D matrix)
1444 {
1445 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1446
1447 TRACE("iface %p, matrix %p.\n", iface, matrix);
1448
1449 memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
1450
1451 return D3DRM_OK;
1452 }
1453
1454 static HRESULT WINAPI d3drm_frame1_GetTransform(IDirect3DRMFrame *iface, D3DRMMATRIX4D matrix)
1455 {
1456 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1457
1458 TRACE("iface %p, matrix %p.\n", iface, matrix);
1459
1460 return d3drm_frame2_GetTransform(&frame->IDirect3DRMFrame2_iface, matrix);
1461 }
1462
1463 static HRESULT WINAPI d3drm_frame3_GetVelocity(IDirect3DRMFrame3 *iface,
1464 IDirect3DRMFrame3 *reference, D3DVECTOR *velocity, BOOL with_rotation)
1465 {
1466 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1467 iface, reference, velocity, with_rotation);
1468
1469 return E_NOTIMPL;
1470 }
1471
1472 static HRESULT WINAPI d3drm_frame2_GetVelocity(IDirect3DRMFrame2 *iface,
1473 IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1474 {
1475 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1476 iface, reference, velocity, with_rotation);
1477
1478 return E_NOTIMPL;
1479 }
1480
1481 static HRESULT WINAPI d3drm_frame1_GetVelocity(IDirect3DRMFrame *iface,
1482 IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1483 {
1484 FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1485 iface, reference, velocity, with_rotation);
1486
1487 return E_NOTIMPL;
1488 }
1489
1490 static HRESULT WINAPI d3drm_frame3_GetOrientation(IDirect3DRMFrame3 *iface,
1491 IDirect3DRMFrame3 *reference, D3DVECTOR *dir, D3DVECTOR *up)
1492 {
1493 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1494
1495 return E_NOTIMPL;
1496 }
1497
1498 static HRESULT WINAPI d3drm_frame2_GetOrientation(IDirect3DRMFrame2 *iface,
1499 IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1500 {
1501 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1502
1503 return E_NOTIMPL;
1504 }
1505
1506 static HRESULT WINAPI d3drm_frame1_GetOrientation(IDirect3DRMFrame *iface,
1507 IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1508 {
1509 FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1510
1511 return E_NOTIMPL;
1512 }
1513
1514 static HRESULT WINAPI d3drm_frame3_GetVisuals(IDirect3DRMFrame3 *iface, DWORD *count, IUnknown **visuals)
1515 {
1516 FIXME("iface %p, count %p, visuals %p stub!\n", iface, count, visuals);
1517
1518 return E_NOTIMPL;
1519 }
1520
1521 static HRESULT WINAPI d3drm_frame2_GetVisuals(IDirect3DRMFrame2 *iface, IDirect3DRMVisualArray **visuals)
1522 {
1523 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1524 struct d3drm_visual_array *array;
1525
1526 TRACE("iface %p, visuals %p.\n", iface, visuals);
1527
1528 if (!visuals)
1529 return D3DRMERR_BADVALUE;
1530
1531 if (!(array = d3drm_visual_array_create(frame->nb_visuals, frame->visuals)))
1532 return E_OUTOFMEMORY;
1533
1534 *visuals = &array->IDirect3DRMVisualArray_iface;
1535
1536 return D3DRM_OK;
1537 }
1538
1539 static HRESULT WINAPI d3drm_frame1_GetVisuals(IDirect3DRMFrame *iface, IDirect3DRMVisualArray **visuals)
1540 {
1541 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1542
1543 TRACE("iface %p, visuals %p.\n", iface, visuals);
1544
1545 return d3drm_frame2_GetVisuals(&frame->IDirect3DRMFrame2_iface, visuals);
1546 }
1547
1548 static HRESULT WINAPI d3drm_frame2_GetTextureTopology(IDirect3DRMFrame2 *iface, BOOL *wrap_u, BOOL *wrap_v)
1549 {
1550 FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1551
1552 return E_NOTIMPL;
1553 }
1554
1555 static HRESULT WINAPI d3drm_frame1_GetTextureTopology(IDirect3DRMFrame *iface, BOOL *wrap_u, BOOL *wrap_v)
1556 {
1557 FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1558
1559 return E_NOTIMPL;
1560 }
1561
1562 static HRESULT WINAPI d3drm_frame3_InverseTransform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
1563 {
1564 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1565
1566 return E_NOTIMPL;
1567 }
1568
1569 static HRESULT WINAPI d3drm_frame2_InverseTransform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
1570 {
1571 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1572
1573 return E_NOTIMPL;
1574 }
1575
1576 static HRESULT WINAPI d3drm_frame1_InverseTransform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
1577 {
1578 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1579
1580 return E_NOTIMPL;
1581 }
1582
1583 static HRESULT WINAPI d3drm_frame3_Load(IDirect3DRMFrame3 *iface, void *filename,
1584 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURE3CALLBACK cb, void *ctx)
1585 {
1586 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1587 iface, filename, name, flags, cb, ctx);
1588
1589 return E_NOTIMPL;
1590 }
1591
1592 static HRESULT WINAPI d3drm_frame2_Load(IDirect3DRMFrame2 *iface, void *filename,
1593 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1594 {
1595 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1596 iface, filename, name, flags, cb, ctx);
1597
1598 return E_NOTIMPL;
1599 }
1600
1601 static HRESULT WINAPI d3drm_frame1_Load(IDirect3DRMFrame *iface, void *filename,
1602 void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1603 {
1604 FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1605 iface, filename, name, flags, cb, ctx);
1606
1607 return E_NOTIMPL;
1608 }
1609
1610 static HRESULT WINAPI d3drm_frame3_LookAt(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *target,
1611 IDirect3DRMFrame3 *reference, D3DRMFRAMECONSTRAINT constraint)
1612 {
1613 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1614
1615 return E_NOTIMPL;
1616 }
1617
1618 static HRESULT WINAPI d3drm_frame2_LookAt(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *target,
1619 IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1620 {
1621 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1622
1623 return E_NOTIMPL;
1624 }
1625
1626 static HRESULT WINAPI d3drm_frame1_LookAt(IDirect3DRMFrame *iface, IDirect3DRMFrame *target,
1627 IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1628 {
1629 FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1630
1631 return E_NOTIMPL;
1632 }
1633
1634 static HRESULT WINAPI d3drm_frame3_Move(IDirect3DRMFrame3 *iface, D3DVALUE delta)
1635 {
1636 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1637
1638 return E_NOTIMPL;
1639 }
1640
1641 static HRESULT WINAPI d3drm_frame2_Move(IDirect3DRMFrame2 *iface, D3DVALUE delta)
1642 {
1643 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1644
1645 return E_NOTIMPL;
1646 }
1647
1648 static HRESULT WINAPI d3drm_frame1_Move(IDirect3DRMFrame *iface, D3DVALUE delta)
1649 {
1650 FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1651
1652 return E_NOTIMPL;
1653 }
1654
1655 static HRESULT WINAPI d3drm_frame3_DeleteChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
1656 {
1657 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1658 struct d3drm_frame *child_impl = unsafe_impl_from_IDirect3DRMFrame3(child);
1659 ULONG i;
1660
1661 TRACE("iface %p, child %p.\n", iface, child);
1662
1663 if (!child_impl)
1664 return D3DRMERR_BADOBJECT;
1665
1666 /* Check if child exists */
1667 for (i = 0; i < frame->nb_children; ++i)
1668 {
1669 if (frame->children[i] == child)
1670 break;
1671 }
1672
1673 if (i == frame->nb_children)
1674 return D3DRMERR_BADVALUE;
1675
1676 memmove(frame->children + i, frame->children + i + 1, sizeof(*frame->children) * (frame->nb_children - 1 - i));
1677 IDirect3DRMFrame3_Release(child);
1678 child_impl->parent = NULL;
1679 --frame->nb_children;
1680
1681 return D3DRM_OK;
1682 }
1683
1684 static HRESULT WINAPI d3drm_frame2_DeleteChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
1685 {
1686 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1687 IDirect3DRMFrame3 *child3;
1688 HRESULT hr;
1689
1690 TRACE("iface %p, child %p.\n", iface, child);
1691
1692 if (!child)
1693 return D3DRMERR_BADOBJECT;
1694 if (FAILED(hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3)))
1695 return D3DRMERR_BADOBJECT;
1696 IDirect3DRMFrame_Release(child);
1697
1698 return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, child3);
1699 }
1700
1701 static HRESULT WINAPI d3drm_frame1_DeleteChild(IDirect3DRMFrame *iface, IDirect3DRMFrame *child)
1702 {
1703 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1704 struct d3drm_frame *child_frame = unsafe_impl_from_IDirect3DRMFrame(child);
1705
1706 TRACE("iface %p, child %p.\n", iface, child);
1707
1708 if (!child_frame)
1709 return D3DRMERR_BADOBJECT;
1710
1711 return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, &child_frame->IDirect3DRMFrame3_iface);
1712 }
1713
1714 static HRESULT WINAPI d3drm_frame3_DeleteLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1715 {
1716 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1717 ULONG i;
1718
1719 TRACE("iface %p, light %p.\n", iface, light);
1720
1721 if (!light)
1722 return D3DRMERR_BADOBJECT;
1723
1724 /* Check if visual exists */
1725 for (i = 0; i < frame->nb_lights; ++i)
1726 {
1727 if (frame->lights[i] == light)
1728 break;
1729 }
1730
1731 if (i == frame->nb_lights)
1732 return D3DRMERR_BADVALUE;
1733
1734 memmove(frame->lights + i, frame->lights + i + 1, sizeof(*frame->lights) * (frame->nb_lights - 1 - i));
1735 IDirect3DRMLight_Release(light);
1736 --frame->nb_lights;
1737
1738 return D3DRM_OK;
1739 }
1740
1741 static HRESULT WINAPI d3drm_frame2_DeleteLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
1742 {
1743 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1744
1745 TRACE("iface %p, light %p.\n", iface, light);
1746
1747 return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1748 }
1749
1750 static HRESULT WINAPI d3drm_frame1_DeleteLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
1751 {
1752 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1753
1754 TRACE("iface %p, light %p.\n", iface, light);
1755
1756 return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1757 }
1758
1759 static HRESULT WINAPI d3drm_frame3_DeleteMoveCallback(IDirect3DRMFrame3 *iface,
1760 D3DRMFRAME3MOVECALLBACK cb, void *ctx)
1761 {
1762 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1763
1764 return E_NOTIMPL;
1765 }
1766
1767 static HRESULT WINAPI d3drm_frame2_DeleteMoveCallback(IDirect3DRMFrame2 *iface,
1768 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1769 {
1770 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1771
1772 return E_NOTIMPL;
1773 }
1774
1775 static HRESULT WINAPI d3drm_frame1_DeleteMoveCallback(IDirect3DRMFrame *iface,
1776 D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1777 {
1778 FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1779
1780 return E_NOTIMPL;
1781 }
1782
1783 static HRESULT WINAPI d3drm_frame3_DeleteVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1784 {
1785 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1786 ULONG i;
1787
1788 TRACE("iface %p, visual %p.\n", iface, visual);
1789
1790 if (!visual)
1791 return D3DRMERR_BADOBJECT;
1792
1793 /* Check if visual exists */
1794 for (i = 0; i < frame->nb_visuals; ++i)
1795 {
1796 if (frame->visuals[i] == (IDirect3DRMVisual *)visual)
1797 break;
1798 }
1799
1800 if (i == frame->nb_visuals)
1801 return D3DRMERR_BADVALUE;
1802
1803 memmove(frame->visuals + i, frame->visuals + i + 1, sizeof(*frame->visuals) * (frame->nb_visuals - 1 - i));
1804 IDirect3DRMVisual_Release(visual);
1805 --frame->nb_visuals;
1806
1807 return D3DRM_OK;
1808 }
1809
1810 static HRESULT WINAPI d3drm_frame2_DeleteVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1811 {
1812 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1813
1814 TRACE("iface %p, visual %p.\n", iface, visual);
1815
1816 return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1817 }
1818
1819 static HRESULT WINAPI d3drm_frame1_DeleteVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1820 {
1821 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1822
1823 TRACE("iface %p, visual %p.\n", iface, visual);
1824
1825 return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1826 }
1827
1828 static D3DCOLOR WINAPI d3drm_frame3_GetSceneBackground(IDirect3DRMFrame3 *iface)
1829 {
1830 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1831
1832 TRACE("iface %p.\n", iface);
1833
1834 return frame->scenebackground;
1835 }
1836
1837 static D3DCOLOR WINAPI d3drm_frame2_GetSceneBackground(IDirect3DRMFrame2 *iface)
1838 {
1839 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1840
1841 TRACE("iface %p.\n", iface);
1842
1843 return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
1844 }
1845
1846 static D3DCOLOR WINAPI d3drm_frame1_GetSceneBackground(IDirect3DRMFrame *iface)
1847 {
1848 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1849
1850 TRACE("iface %p.\n", iface);
1851
1852 return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
1853 }
1854
1855 static HRESULT WINAPI d3drm_frame3_GetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
1856 IDirectDrawSurface **surface)
1857 {
1858 FIXME("iface %p, surface %p stub!\n", iface, surface);
1859
1860 return E_NOTIMPL;
1861 }
1862
1863 static HRESULT WINAPI d3drm_frame2_GetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
1864 IDirectDrawSurface **surface)
1865 {
1866 FIXME("iface %p, surface %p stub!\n", iface, surface);
1867
1868 return E_NOTIMPL;
1869 }
1870
1871 static HRESULT WINAPI d3drm_frame1_GetSceneBackgroundDepth(IDirect3DRMFrame *iface,
1872 IDirectDrawSurface **surface)
1873 {
1874 FIXME("iface %p, surface %p stub!\n", iface, surface);
1875
1876 return E_NOTIMPL;
1877 }
1878
1879 static D3DCOLOR WINAPI d3drm_frame3_GetSceneFogColor(IDirect3DRMFrame3 *iface)
1880 {
1881 FIXME("iface %p stub!\n", iface);
1882
1883 return 0;
1884 }
1885
1886 static D3DCOLOR WINAPI d3drm_frame2_GetSceneFogColor(IDirect3DRMFrame2 *iface)
1887 {
1888 FIXME("iface %p stub!\n", iface);
1889
1890 return 0;
1891 }
1892
1893 static D3DCOLOR WINAPI d3drm_frame1_GetSceneFogColor(IDirect3DRMFrame *iface)
1894 {
1895 FIXME("iface %p stub!\n", iface);
1896
1897 return 0;
1898 }
1899
1900 static BOOL WINAPI d3drm_frame3_GetSceneFogEnable(IDirect3DRMFrame3 *iface)
1901 {
1902 FIXME("iface %p stub!\n", iface);
1903
1904 return FALSE;
1905 }
1906
1907 static BOOL WINAPI d3drm_frame2_GetSceneFogEnable(IDirect3DRMFrame2 *iface)
1908 {
1909 FIXME("iface %p stub!\n", iface);
1910
1911 return FALSE;
1912 }
1913
1914 static BOOL WINAPI d3drm_frame1_GetSceneFogEnable(IDirect3DRMFrame *iface)
1915 {
1916 FIXME("iface %p stub!\n", iface);
1917
1918 return FALSE;
1919 }
1920
1921 static D3DRMFOGMODE WINAPI d3drm_frame3_GetSceneFogMode(IDirect3DRMFrame3 *iface)
1922 {
1923 FIXME("iface %p stub!\n", iface);
1924
1925 return D3DRMFOG_LINEAR;
1926 }
1927
1928 static D3DRMFOGMODE WINAPI d3drm_frame2_GetSceneFogMode(IDirect3DRMFrame2 *iface)
1929 {
1930 FIXME("iface %p stub!\n", iface);
1931
1932 return D3DRMFOG_LINEAR;
1933 }
1934
1935 static D3DRMFOGMODE WINAPI d3drm_frame1_GetSceneFogMode(IDirect3DRMFrame *iface)
1936 {
1937 FIXME("iface %p stub!\n", iface);
1938
1939 return D3DRMFOG_LINEAR;
1940 }
1941
1942 static HRESULT WINAPI d3drm_frame3_GetSceneFogParams(IDirect3DRMFrame3 *iface,
1943 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1944 {
1945 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1946
1947 return E_NOTIMPL;
1948 }
1949
1950 static HRESULT WINAPI d3drm_frame2_GetSceneFogParams(IDirect3DRMFrame2 *iface,
1951 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1952 {
1953 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1954
1955 return E_NOTIMPL;
1956 }
1957
1958 static HRESULT WINAPI d3drm_frame1_GetSceneFogParams(IDirect3DRMFrame *iface,
1959 D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1960 {
1961 FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1962
1963 return E_NOTIMPL;
1964 }
1965
1966 static HRESULT WINAPI d3drm_frame3_SetSceneBackground(IDirect3DRMFrame3 *iface, D3DCOLOR color)
1967 {
1968 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1969
1970 TRACE("iface %p, color 0x%08x.\n", iface, color);
1971
1972 frame->scenebackground = color;
1973
1974 return D3DRM_OK;
1975 }
1976
1977 static HRESULT WINAPI d3drm_frame2_SetSceneBackground(IDirect3DRMFrame2 *iface, D3DCOLOR color)
1978 {
1979 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1980
1981 TRACE("iface %p, color 0x%08x.\n", iface, color);
1982
1983 return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
1984 }
1985
1986 static HRESULT WINAPI d3drm_frame1_SetSceneBackground(IDirect3DRMFrame *iface, D3DCOLOR color)
1987 {
1988 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1989
1990 TRACE("iface %p, color 0x%08x.\n", iface, color);
1991
1992 return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
1993 }
1994
1995 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundRGB(IDirect3DRMFrame3 *iface,
1996 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1997 {
1998 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1999
2000 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2001
2002 d3drm_set_color(&frame->scenebackground, red, green, blue, 1.0f);
2003
2004 return D3DRM_OK;
2005 }
2006
2007 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundRGB(IDirect3DRMFrame2 *iface,
2008 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2009 {
2010 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2011
2012 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2013
2014 return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2015 }
2016
2017 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundRGB(IDirect3DRMFrame *iface,
2018 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2019 {
2020 struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2021
2022 TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2023
2024 return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2025 }
2026
2027 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
2028 IDirectDrawSurface *surface)
2029 {
2030 FIXME("iface %p, surface %p stub!\n", iface, surface);
2031
2032 return E_NOTIMPL;
2033 }
2034
2035 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
2036 IDirectDrawSurface *surface)
2037 {
2038 FIXME("iface %p, surface %p stub!\n", iface, surface);
2039
2040 return E_NOTIMPL;
2041 }
2042
2043 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundDepth(IDirect3DRMFrame *iface,
2044 IDirectDrawSurface *surface)
2045 {
2046 FIXME("iface %p, surface %p stub!\n", iface, surface);
2047
2048 return E_NOTIMPL;
2049 }
2050
2051 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundImage(IDirect3DRMFrame3 *iface,
2052 IDirect3DRMTexture3 *texture)
2053 {
2054 FIXME("iface %p, texture %p stub!\n", iface, texture);
2055
2056 return E_NOTIMPL;
2057 }
2058
2059 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundImage(IDirect3DRMFrame2 *iface,
2060 IDirect3DRMTexture *texture)
2061 {
2062 FIXME("iface %p, texture %p stub!\n", iface, texture);
2063
2064 return E_NOTIMPL;
2065 }
2066
2067 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundImage(IDirect3DRMFrame *iface,
2068 IDirect3DRMTexture *texture)
2069 {
2070 FIXME("iface %p, texture %p stub!\n", iface, texture);
2071
2072 return E_NOTIMPL;
2073 }
2074
2075 static HRESULT WINAPI d3drm_frame3_SetSceneFogEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2076 {
2077 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2078
2079 return E_NOTIMPL;
2080 }
2081
2082 static HRESULT WINAPI d3drm_frame2_SetSceneFogEnable(IDirect3DRMFrame2 *iface, BOOL enable)
2083 {
2084 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2085
2086 return E_NOTIMPL;
2087 }
2088
2089 static HRESULT WINAPI d3drm_frame1_SetSceneFogEnable(IDirect3DRMFrame *iface, BOOL enable)
2090 {
2091 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2092
2093 return E_NOTIMPL;
2094 }
2095
2096 static HRESULT WINAPI d3drm_frame3_SetSceneFogColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2097 {
2098 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2099
2100 return E_NOTIMPL;
2101 }
2102
2103 static HRESULT WINAPI d3drm_frame2_SetSceneFogColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2104 {
2105 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2106
2107 return E_NOTIMPL;
2108 }
2109
2110 static HRESULT WINAPI d3drm_frame1_SetSceneFogColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2111 {
2112 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2113
2114 return E_NOTIMPL;
2115 }
2116
2117 static HRESULT WINAPI d3drm_frame3_SetSceneFogMode(IDirect3DRMFrame3 *iface, D3DRMFOGMODE mode)
2118 {
2119 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2120
2121 return E_NOTIMPL;
2122 }
2123
2124 static HRESULT WINAPI d3drm_frame2_SetSceneFogMode(IDirect3DRMFrame2 *iface, D3DRMFOGMODE mode)
2125 {
2126 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2127
2128 return E_NOTIMPL;
2129 }
2130
2131 static HRESULT WINAPI d3drm_frame1_SetSceneFogMode(IDirect3DRMFrame *iface, D3DRMFOGMODE mode)
2132 {
2133 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2134
2135 return E_NOTIMPL;
2136 }
2137
2138 static HRESULT WINAPI d3drm_frame3_SetSceneFogParams(IDirect3DRMFrame3 *iface,
2139 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2140 {
2141 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2142
2143 return E_NOTIMPL;
2144 }
2145
2146 static HRESULT WINAPI d3drm_frame2_SetSceneFogParams(IDirect3DRMFrame2 *iface,
2147 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2148 {
2149 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2150
2151 return E_NOTIMPL;
2152 }
2153
2154 static HRESULT WINAPI d3drm_frame1_SetSceneFogParams(IDirect3DRMFrame *iface,
2155 D3DVALUE start, D3DVALUE end, D3DVALUE density)
2156 {
2157 FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2158
2159 return E_NOTIMPL;
2160 }
2161
2162 static HRESULT WINAPI d3drm_frame3_SetColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2163 {
2164 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2165
2166 return E_NOTIMPL;
2167 }
2168
2169 static HRESULT WINAPI d3drm_frame2_SetColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2170 {
2171 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2172
2173 return E_NOTIMPL;
2174 }
2175
2176 static HRESULT WINAPI d3drm_frame1_SetColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2177 {
2178 FIXME("iface %p, color 0x%08x stub!\n", iface, color);
2179
2180 return E_NOTIMPL;
2181 }
2182
2183 static HRESULT WINAPI d3drm_frame3_SetColorRGB(IDirect3DRMFrame3 *iface,
2184 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2185 {
2186 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2187
2188 return E_NOTIMPL;
2189 }
2190
2191 static HRESULT WINAPI d3drm_frame2_SetColorRGB(IDirect3DRMFrame2 *iface,
2192 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2193 {
2194 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2195
2196 return E_NOTIMPL;
2197 }
2198
2199 static HRESULT WINAPI d3drm_frame1_SetColorRGB(IDirect3DRMFrame *iface,
2200 D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2201 {
2202 FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2203
2204 return E_NOTIMPL;
2205 }
2206
2207 static D3DRMZBUFFERMODE WINAPI d3drm_frame3_GetZbufferMode(IDirect3DRMFrame3 *iface)
2208 {
2209 FIXME("iface %p stub!\n", iface);
2210
2211 return D3DRMZBUFFER_FROMPARENT;
2212 }
2213
2214 static D3DRMZBUFFERMODE WINAPI d3drm_frame2_GetZbufferMode(IDirect3DRMFrame2 *iface)
2215 {
2216 FIXME("iface %p stub!\n", iface);
2217
2218 return D3DRMZBUFFER_FROMPARENT;
2219 }
2220
2221 static D3DRMZBUFFERMODE WINAPI d3drm_frame1_GetZbufferMode(IDirect3DRMFrame *iface)
2222 {
2223 FIXME("iface %p stub!\n", iface);
2224
2225 return D3DRMZBUFFER_FROMPARENT;
2226 }
2227
2228 static HRESULT WINAPI d3drm_frame3_SetMaterialMode(IDirect3DRMFrame3 *iface, D3DRMMATERIALMODE mode)
2229 {
2230 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2231
2232 return E_NOTIMPL;
2233 }
2234
2235 static HRESULT WINAPI d3drm_frame2_SetMaterialMode(IDirect3DRMFrame2 *iface, D3DRMMATERIALMODE mode)
2236 {
2237 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2238
2239 return E_NOTIMPL;
2240 }
2241
2242 static HRESULT WINAPI d3drm_frame1_SetMaterialMode(IDirect3DRMFrame *iface, D3DRMMATERIALMODE mode)
2243 {
2244 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2245
2246 return E_NOTIMPL;
2247 }
2248
2249 static HRESULT WINAPI d3drm_frame3_SetOrientation(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2250 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2251 {
2252 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2253 iface, reference, dx, dy, dz, ux, uy, uz);
2254
2255 return E_NOTIMPL;
2256 }
2257
2258 static HRESULT WINAPI d3drm_frame2_SetOrientation(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *reference,
2259 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2260 {
2261 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2262 iface, reference, dx, dy, dz, ux, uy, uz);
2263
2264 return E_NOTIMPL;
2265 }
2266
2267 static HRESULT WINAPI d3drm_frame1_SetOrientation(IDirect3DRMFrame *iface, IDirect3DRMFrame *reference,
2268 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2269 {
2270 FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2271 iface, reference, dx, dy, dz, ux, uy, uz);
2272
2273 return E_NOTIMPL;
2274 }
2275
2276 static HRESULT WINAPI d3drm_frame3_SetPosition(IDirect3DRMFrame3 *iface,
2277 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2278 {
2279 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2280
2281 return E_NOTIMPL;
2282 }
2283
2284 static HRESULT WINAPI d3drm_frame2_SetPosition(IDirect3DRMFrame2 *iface,
2285 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2286 {
2287 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2288
2289 return E_NOTIMPL;
2290 }
2291
2292 static HRESULT WINAPI d3drm_frame1_SetPosition(IDirect3DRMFrame *iface,
2293 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2294 {
2295 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2296
2297 return E_NOTIMPL;
2298 }
2299
2300 static HRESULT WINAPI d3drm_frame3_SetRotation(IDirect3DRMFrame3 *iface,
2301 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2302 {
2303 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2304 iface, reference, x, y, z, theta);
2305
2306 return E_NOTIMPL;
2307 }
2308
2309 static HRESULT WINAPI d3drm_frame2_SetRotation(IDirect3DRMFrame2 *iface,
2310 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2311 {
2312 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2313 iface, reference, x, y, z, theta);
2314
2315 return E_NOTIMPL;
2316 }
2317
2318 static HRESULT WINAPI d3drm_frame1_SetRotation(IDirect3DRMFrame *iface,
2319 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2320 {
2321 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2322 iface, reference, x, y, z, theta);
2323
2324 return E_NOTIMPL;
2325 }
2326
2327 static HRESULT WINAPI d3drm_frame3_SetSortMode(IDirect3DRMFrame3 *iface, D3DRMSORTMODE mode)
2328 {
2329 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2330
2331 return E_NOTIMPL;
2332 }
2333
2334 static HRESULT WINAPI d3drm_frame2_SetSortMode(IDirect3DRMFrame2 *iface, D3DRMSORTMODE mode)
2335 {
2336 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2337
2338 return E_NOTIMPL;
2339 }
2340
2341 static HRESULT WINAPI d3drm_frame1_SetSortMode(IDirect3DRMFrame *iface, D3DRMSORTMODE mode)
2342 {
2343 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2344
2345 return E_NOTIMPL;
2346 }
2347
2348 static HRESULT WINAPI d3drm_frame3_SetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 *texture)
2349 {
2350 FIXME("iface %p, texture %p stub!\n", iface, texture);
2351
2352 return E_NOTIMPL;
2353 }
2354
2355 static HRESULT WINAPI d3drm_frame2_SetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture *texture)
2356 {
2357 FIXME("iface %p, texture %p stub!\n", iface, texture);
2358
2359 return E_NOTIMPL;
2360 }
2361
2362 static HRESULT WINAPI d3drm_frame1_SetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture *texture)
2363 {
2364 FIXME("iface %p, texture %p stub!\n", iface, texture);
2365
2366 return E_NOTIMPL;
2367 }
2368
2369 static HRESULT WINAPI d3drm_frame2_SetTextureTopology(IDirect3DRMFrame2 *iface, BOOL wrap_u, BOOL wrap_v)
2370 {
2371 FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2372
2373 return E_NOTIMPL;
2374 }
2375
2376 static HRESULT WINAPI d3drm_frame1_SetTextureTopology(IDirect3DRMFrame *iface, BOOL wrap_u, BOOL wrap_v)
2377 {
2378 FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2379
2380 return E_NOTIMPL;
2381 }
2382
2383 static HRESULT WINAPI d3drm_frame3_SetVelocity(IDirect3DRMFrame3 *iface,
2384 IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2385 {
2386 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x.\n",
2387 iface, reference, x, y, z, with_rotation);
2388
2389 return E_NOTIMPL;
2390 }
2391
2392 static HRESULT WINAPI d3drm_frame2_SetVelocity(IDirect3DRMFrame2 *iface,
2393 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2394 {
2395 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2396 iface, reference, x, y, z, with_rotation);
2397
2398 return E_NOTIMPL;
2399 }
2400
2401 static HRESULT WINAPI d3drm_frame1_SetVelocity(IDirect3DRMFrame *iface,
2402 IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2403 {
2404 FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2405 iface, reference, x, y, z, with_rotation);
2406
2407 return E_NOTIMPL;
2408 }
2409
2410 static HRESULT WINAPI d3drm_frame3_SetZbufferMode(IDirect3DRMFrame3 *iface, D3DRMZBUFFERMODE mode)
2411 {
2412 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2413
2414 return E_NOTIMPL;
2415 }
2416
2417 static HRESULT WINAPI d3drm_frame2_SetZbufferMode(IDirect3DRMFrame2 *iface, D3DRMZBUFFERMODE mode)
2418 {
2419 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2420
2421 return E_NOTIMPL;
2422 }
2423
2424 static HRESULT WINAPI d3drm_frame1_SetZbufferMode(IDirect3DRMFrame *iface, D3DRMZBUFFERMODE mode)
2425 {
2426 FIXME("iface %p, mode %#x stub!\n", iface, mode);
2427
2428 return E_NOTIMPL;
2429 }
2430
2431 static HRESULT WINAPI d3drm_frame3_Transform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
2432 {
2433 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2434
2435 return E_NOTIMPL;
2436 }
2437
2438 static HRESULT WINAPI d3drm_frame2_Transform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
2439 {
2440 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2441
2442 return E_NOTIMPL;
2443 }
2444
2445 static HRESULT WINAPI d3drm_frame1_Transform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
2446 {
2447 FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2448
2449 return E_NOTIMPL;
2450 }
2451
2452 static HRESULT WINAPI d3drm_frame2_AddMoveCallback2(IDirect3DRMFrame2 *iface,
2453 D3DRMFRAMEMOVECALLBACK cb, void *ctx, DWORD flags)
2454 {
2455 FIXME("iface %p, cb %p, ctx %p, flags %#x stub!\n", iface, cb, ctx, flags);
2456
2457 return E_NOTIMPL;
2458 }
2459
2460 static HRESULT WINAPI d3drm_frame3_GetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2461 {
2462 FIXME("iface %p, box %p stub!\n", iface, box);
2463
2464 return E_NOTIMPL;
2465 }
2466
2467 static HRESULT WINAPI d3drm_frame2_GetBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2468 {
2469 FIXME("iface %p, box %p stub!\n", iface, box);
2470
2471 return E_NOTIMPL;
2472 }
2473
2474 static BOOL WINAPI d3drm_frame3_GetBoxEnable(IDirect3DRMFrame3 *iface)
2475 {
2476 FIXME("iface %p stub!\n", iface);
2477
2478 return FALSE;
2479 }
2480
2481 static BOOL WINAPI d3drm_frame2_GetBoxEnable(IDirect3DRMFrame2 *iface)
2482 {
2483 FIXME("iface %p stub!\n", iface);
2484
2485 return FALSE;
2486 }
2487
2488 static HRESULT WINAPI d3drm_frame3_GetAxes(IDirect3DRMFrame3 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2489 {
2490 FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2491
2492 return E_NOTIMPL;
2493 }
2494
2495 static HRESULT WINAPI d3drm_frame2_GetAxes(IDirect3DRMFrame2 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2496 {
2497 FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2498
2499 return E_NOTIMPL;
2500 }
2501
2502 static HRESULT WINAPI d3drm_frame3_GetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 **material)
2503 {
2504 FIXME("iface %p, material %p stub!\n", iface, material);
2505
2506 return E_NOTIMPL;
2507 }
2508
2509 static HRESULT WINAPI d3drm_frame2_GetMaterial(IDirect3DRMFrame2 *iface, IDirect3DRMMaterial **material)
2510 {
2511 FIXME("iface %p, material %p stub!\n", iface, material);
2512
2513 return E_NOTIMPL;
2514 }
2515
2516 static BOOL WINAPI d3drm_frame3_GetInheritAxes(IDirect3DRMFrame3 *iface)
2517 {
2518 FIXME("iface %p stub!\n", iface);
2519
2520 return FALSE;
2521 }
2522
2523 static BOOL WINAPI d3drm_frame2_GetInheritAxes(IDirect3DRMFrame2 *iface)
2524 {
2525 FIXME("iface %p stub!\n", iface);
2526
2527 return FALSE;
2528 }
2529
2530 static HRESULT WINAPI d3drm_frame3_GetHierarchyBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2531 {
2532 FIXME("iface %p, box %p stub!\n", iface, box);
2533
2534 return E_NOTIMPL;
2535 }
2536
2537 static HRESULT WINAPI d3drm_frame2_GetHierarchyBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2538 {
2539 FIXME("iface %p, box %p stub!\n", iface, box);
2540
2541 return E_NOTIMPL;
2542 }
2543
2544 static HRESULT WINAPI d3drm_frame3_SetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2545 {
2546 FIXME("iface %p, box %p stub!\n", iface, box);
2547
2548 return E_NOTIMPL;
2549 }
2550
2551 static HRESULT WINAPI d3drm_frame3_SetBoxEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2552 {
2553 FIXME("iface %p, enable %#x stub!\n", iface, enable);
2554
2555 return E_NOTIMPL;
2556 }
2557
2558 static HRESULT WINAPI d3drm_frame3_SetAxes(IDirect3DRMFrame3 *iface,
2559 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2560 {
2561 FIXME("iface %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2562 iface, dx, dy, dz, ux, uy, uz);
2563
2564 return E_NOTIMPL;
2565 }
2566
2567 static HRESULT WINAPI d3drm_frame3_SetInheritAxes(IDirect3DRMFrame3 *iface, BOOL inherit)
2568 {
2569 FIXME("iface %p, inherit %#x stub!\n", iface, inherit);
2570
2571 return E_NOTIMPL;
2572 }
2573
2574 static HRESULT WINAPI d3drm_frame3_SetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 *material)
2575 {
2576 FIXME("iface %p, material %p stub!\n", iface, material);
2577
2578 return E_NOTIMPL;
2579 }
2580
2581 static HRESULT WINAPI d3drm_frame3_SetQuaternion(IDirect3DRMFrame3 *iface,
2582 IDirect3DRMFrame3 *reference, D3DRMQUATERNION *q)
2583 {
2584 FIXME("iface %p, reference %p, q %p stub!\n", iface, reference, q);
2585
2586 return E_NOTIMPL;
2587 }
2588
2589 static HRESULT WINAPI d3drm_frame3_RayPick(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2590 D3DRMRAY *ray, DWORD flags, IDirect3DRMPicked2Array **visuals)
2591 {
2592 FIXME("iface %p, reference %p, ray %p, flags %#x, visuals %p stub!\n",
2593 iface, reference, ray, flags, visuals);
2594
2595 return E_NOTIMPL;
2596 }
2597
2598 static HRESULT WINAPI d3drm_frame3_Save(IDirect3DRMFrame3 *iface,
2599 const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags)
2600 {
2601 FIXME("iface %p, filename %s, format %#x, flags %#x stub!\n",
2602 iface, debugstr_a(filename), format, flags);
2603
2604 return E_NOTIMPL;
2605 }
2606
2607 static HRESULT WINAPI d3drm_frame3_TransformVectors(IDirect3DRMFrame3 *iface,
2608 IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2609 {
2610 FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2611
2612 return E_NOTIMPL;
2613 }
2614
2615 static HRESULT WINAPI d3drm_frame3_InverseTransformVectors(IDirect3DRMFrame3 *iface,
2616 IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2617 {
2618 FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2619
2620 return E_NOTIMPL;
2621 }
2622
2623 static HRESULT WINAPI d3drm_frame3_SetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD flags)
2624 {
2625 FIXME("iface %p, flags %#x stub!\n", iface, flags);
2626
2627 return E_NOTIMPL;
2628 }
2629
2630 static HRESULT WINAPI d3drm_frame3_GetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD *flags)
2631 {
2632 FIXME("iface %p, flags %p stub!\n", iface, flags);
2633
2634 return E_NOTIMPL;
2635 }
2636
2637 static HRESULT WINAPI d3drm_frame3_SetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD flags)
2638 {
2639 FIXME("iface %p, flags %#x stub!\n", iface, flags);
2640
2641 return E_NOTIMPL;
2642 }
2643
2644 static HRESULT WINAPI d3drm_frame3_GetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD *fog_mode)
2645 {
2646 FIXME("iface %p, fog_mode %p stub!\n", iface, fog_mode);
2647
2648 return E_NOTIMPL;
2649 }
2650
2651 static HRESULT WINAPI d3drm_frame3_SetMaterialOverride(IDirect3DRMFrame3 *iface,
2652 D3DRMMATERIALOVERRIDE *override)
2653 {
2654 FIXME("iface %p, override %p stub!\n", iface, override);
2655
2656 return E_NOTIMPL;
2657 }
2658
2659 static HRESULT WINAPI d3drm_frame3_GetMaterialOverride(IDirect3DRMFrame3 *iface,
2660 D3DRMMATERIALOVERRIDE *override)
2661 {
2662 FIXME("iface %p, override %p stub!\n", iface, override);
2663
2664 return E_NOTIMPL;
2665 }
2666
2667 static const struct IDirect3DRMFrame3Vtbl d3drm_frame3_vtbl =
2668 {
2669 d3drm_frame3_QueryInterface,
2670 d3drm_frame3_AddRef,
2671 d3drm_frame3_Release,
2672 d3drm_frame3_Clone,
2673 d3drm_frame3_AddDestroyCallback,
2674 d3drm_frame3_DeleteDestroyCallback,
2675 d3drm_frame3_SetAppData,
2676 d3drm_frame3_GetAppData,
2677 d3drm_frame3_SetName,
2678 d3drm_frame3_GetName,
2679 d3drm_frame3_GetClassName,
2680 d3drm_frame3_AddChild,
2681 d3drm_frame3_AddLight,
2682 d3drm_frame3_AddMoveCallback,
2683 d3drm_frame3_AddTransform,
2684 d3drm_frame3_AddTranslation,
2685 d3drm_frame3_AddScale,
2686 d3drm_frame3_AddRotation,
2687 d3drm_frame3_AddVisual,
2688 d3drm_frame3_GetChildren,
2689 d3drm_frame3_GetColor,
2690 d3drm_frame3_GetLights,
2691 d3drm_frame3_GetMaterialMode,
2692 d3drm_frame3_GetParent,
2693 d3drm_frame3_GetPosition,
2694 d3drm_frame3_GetRotation,
2695 d3drm_frame3_GetScene,
2696 d3drm_frame3_GetSortMode,
2697 d3drm_frame3_GetTexture,
2698 d3drm_frame3_GetTransform,
2699 d3drm_frame3_GetVelocity,
2700 d3drm_frame3_GetOrientation,
2701 d3drm_frame3_GetVisuals,
2702 d3drm_frame3_InverseTransform,
2703 d3drm_frame3_Load,
2704 d3drm_frame3_LookAt,
2705 d3drm_frame3_Move,
2706 d3drm_frame3_DeleteChild,
2707 d3drm_frame3_DeleteLight,
2708 d3drm_frame3_DeleteMoveCallback,
2709 d3drm_frame3_DeleteVisual,
2710 d3drm_frame3_GetSceneBackground,
2711 d3drm_frame3_GetSceneBackgroundDepth,
2712 d3drm_frame3_GetSceneFogColor,
2713 d3drm_frame3_GetSceneFogEnable,
2714 d3drm_frame3_GetSceneFogMode,
2715 d3drm_frame3_GetSceneFogParams,
2716 d3drm_frame3_SetSceneBackground,
2717 d3drm_frame3_SetSceneBackgroundRGB,
2718 d3drm_frame3_SetSceneBackgroundDepth,
2719 d3drm_frame3_SetSceneBackgroundImage,
2720 d3drm_frame3_SetSceneFogEnable,
2721 d3drm_frame3_SetSceneFogColor,
2722 d3drm_frame3_SetSceneFogMode,
2723 d3drm_frame3_SetSceneFogParams,
2724 d3drm_frame3_SetColor,
2725 d3drm_frame3_SetColorRGB,
2726 d3drm_frame3_GetZbufferMode,
2727 d3drm_frame3_SetMaterialMode,
2728 d3drm_frame3_SetOrientation,
2729 d3drm_frame3_SetPosition,
2730 d3drm_frame3_SetRotation,
2731 d3drm_frame3_SetSortMode,
2732 d3drm_frame3_SetTexture,
2733 d3drm_frame3_SetVelocity,
2734 d3drm_frame3_SetZbufferMode,
2735 d3drm_frame3_Transform,
2736 d3drm_frame3_GetBox,
2737 d3drm_frame3_GetBoxEnable,
2738 d3drm_frame3_GetAxes,
2739 d3drm_frame3_GetMaterial,
2740 d3drm_frame3_GetInheritAxes,
2741 d3drm_frame3_GetHierarchyBox,
2742 d3drm_frame3_SetBox,
2743 d3drm_frame3_SetBoxEnable,
2744 d3drm_frame3_SetAxes,
2745 d3drm_frame3_SetInheritAxes,
2746 d3drm_frame3_SetMaterial,
2747 d3drm_frame3_SetQuaternion,
2748 d3drm_frame3_RayPick,
2749 d3drm_frame3_Save,
2750 d3drm_frame3_TransformVectors,
2751 d3drm_frame3_InverseTransformVectors,
2752 d3drm_frame3_SetTraversalOptions,
2753 d3drm_frame3_GetTraversalOptions,
2754 d3drm_frame3_SetSceneFogMethod,
2755 d3drm_frame3_GetSceneFogMethod,
2756 d3drm_frame3_SetMaterialOverride,
2757 d3drm_frame3_GetMaterialOverride,
2758 };
2759
2760 static const struct IDirect3DRMFrame2Vtbl d3drm_frame2_vtbl =
2761 {
2762 d3drm_frame2_QueryInterface,
2763 d3drm_frame2_AddRef,
2764 d3drm_frame2_Release,
2765 d3drm_frame2_Clone,
2766 d3drm_frame2_AddDestroyCallback,
2767 d3drm_frame2_DeleteDestroyCallback,
2768 d3drm_frame2_SetAppData,
2769 d3drm_frame2_GetAppData,
2770 d3drm_frame2_SetName,
2771 d3drm_frame2_GetName,
2772 d3drm_frame2_GetClassName,
2773 d3drm_frame2_AddChild,
2774 d3drm_frame2_AddLight,
2775 d3drm_frame2_AddMoveCallback,
2776 d3drm_frame2_AddTransform,
2777 d3drm_frame2_AddTranslation,
2778 d3drm_frame2_AddScale,
2779 d3drm_frame2_AddRotation,
2780 d3drm_frame2_AddVisual,
2781 d3drm_frame2_GetChildren,
2782 d3drm_frame2_GetColor,
2783 d3drm_frame2_GetLights,
2784 d3drm_frame2_GetMaterialMode,
2785 d3drm_frame2_GetParent,
2786 d3drm_frame2_GetPosition,
2787 d3drm_frame2_GetRotation,
2788 d3drm_frame2_GetScene,
2789 d3drm_frame2_GetSortMode,
2790 d3drm_frame2_GetTexture,
2791 d3drm_frame2_GetTransform,
2792 d3drm_frame2_GetVelocity,
2793 d3drm_frame2_GetOrientation,
2794 d3drm_frame2_GetVisuals,
2795 d3drm_frame2_GetTextureTopology,
2796 d3drm_frame2_InverseTransform,
2797 d3drm_frame2_Load,
2798 d3drm_frame2_LookAt,
2799 d3drm_frame2_Move,
2800 d3drm_frame2_DeleteChild,
2801 d3drm_frame2_DeleteLight,
2802 d3drm_frame2_DeleteMoveCallback,
2803 d3drm_frame2_DeleteVisual,
2804 d3drm_frame2_GetSceneBackground,
2805 d3drm_frame2_GetSceneBackgroundDepth,
2806 d3drm_frame2_GetSceneFogColor,
2807 d3drm_frame2_GetSceneFogEnable,
2808 d3drm_frame2_GetSceneFogMode,
2809 d3drm_frame2_GetSceneFogParams,
2810 d3drm_frame2_SetSceneBackground,
2811 d3drm_frame2_SetSceneBackgroundRGB,
2812 d3drm_frame2_SetSceneBackgroundDepth,
2813 d3drm_frame2_SetSceneBackgroundImage,
2814 d3drm_frame2_SetSceneFogEnable,
2815 d3drm_frame2_SetSceneFogColor,
2816 d3drm_frame2_SetSceneFogMode,
2817 d3drm_frame2_SetSceneFogParams,
2818 d3drm_frame2_SetColor,
2819 d3drm_frame2_SetColorRGB,
2820 d3drm_frame2_GetZbufferMode,
2821 d3drm_frame2_SetMaterialMode,
2822 d3drm_frame2_SetOrientation,
2823 d3drm_frame2_SetPosition,
2824 d3drm_frame2_SetRotation,
2825 d3drm_frame2_SetSortMode,
2826 d3drm_frame2_SetTexture,
2827 d3drm_frame2_SetTextureTopology,
2828 d3drm_frame2_SetVelocity,
2829 d3drm_frame2_SetZbufferMode,
2830 d3drm_frame2_Transform,
2831 d3drm_frame2_AddMoveCallback2,
2832 d3drm_frame2_GetBox,
2833 d3drm_frame2_GetBoxEnable,
2834 d3drm_frame2_GetAxes,
2835 d3drm_frame2_GetMaterial,
2836 d3drm_frame2_GetInheritAxes,
2837 d3drm_frame2_GetHierarchyBox,
2838 };
2839
2840 static const struct IDirect3DRMFrameVtbl d3drm_frame1_vtbl =
2841 {
2842 d3drm_frame1_QueryInterface,
2843 d3drm_frame1_AddRef,
2844 d3drm_frame1_Release,
2845 d3drm_frame1_Clone,
2846 d3drm_frame1_AddDestroyCallback,
2847 d3drm_frame1_DeleteDestroyCallback,
2848 d3drm_frame1_SetAppData,
2849 d3drm_frame1_GetAppData,
2850 d3drm_frame1_SetName,
2851 d3drm_frame1_GetName,
2852 d3drm_frame1_GetClassName,
2853 d3drm_frame1_AddChild,
2854 d3drm_frame1_AddLight,
2855 d3drm_frame1_AddMoveCallback,
2856 d3drm_frame1_AddTransform,
2857 d3drm_frame1_AddTranslation,
2858 d3drm_frame1_AddScale,
2859 d3drm_frame1_AddRotation,
2860 d3drm_frame1_AddVisual,
2861 d3drm_frame1_GetChildren,
2862 d3drm_frame1_GetColor,
2863 d3drm_frame1_GetLights,
2864 d3drm_frame1_GetMaterialMode,
2865 d3drm_frame1_GetParent,
2866 d3drm_frame1_GetPosition,
2867 d3drm_frame1_GetRotation,
2868 d3drm_frame1_GetScene,
2869 d3drm_frame1_GetSortMode,
2870 d3drm_frame1_GetTexture,
2871 d3drm_frame1_GetTransform,
2872 d3drm_frame1_GetVelocity,
2873 d3drm_frame1_GetOrientation,
2874 d3drm_frame1_GetVisuals,
2875 d3drm_frame1_GetTextureTopology,
2876 d3drm_frame1_InverseTransform,
2877 d3drm_frame1_Load,
2878 d3drm_frame1_LookAt,
2879 d3drm_frame1_Move,
2880 d3drm_frame1_DeleteChild,
2881 d3drm_frame1_DeleteLight,
2882 d3drm_frame1_DeleteMoveCallback,
2883 d3drm_frame1_DeleteVisual,
2884 d3drm_frame1_GetSceneBackground,
2885 d3drm_frame1_GetSceneBackgroundDepth,
2886 d3drm_frame1_GetSceneFogColor,
2887 d3drm_frame1_GetSceneFogEnable,
2888 d3drm_frame1_GetSceneFogMode,
2889 d3drm_frame1_GetSceneFogParams,
2890 d3drm_frame1_SetSceneBackground,
2891 d3drm_frame1_SetSceneBackgroundRGB,
2892 d3drm_frame1_SetSceneBackgroundDepth,
2893 d3drm_frame1_SetSceneBackgroundImage,
2894 d3drm_frame1_SetSceneFogEnable,
2895 d3drm_frame1_SetSceneFogColor,
2896 d3drm_frame1_SetSceneFogMode,
2897 d3drm_frame1_SetSceneFogParams,
2898 d3drm_frame1_SetColor,
2899 d3drm_frame1_SetColorRGB,
2900 d3drm_frame1_GetZbufferMode,
2901 d3drm_frame1_SetMaterialMode,
2902 d3drm_frame1_SetOrientation,
2903 d3drm_frame1_SetPosition,
2904 d3drm_frame1_SetRotation,
2905 d3drm_frame1_SetSortMode,
2906 d3drm_frame1_SetTexture,
2907 d3drm_frame1_SetTextureTopology,
2908 d3drm_frame1_SetVelocity,
2909 d3drm_frame1_SetZbufferMode,
2910 d3drm_frame1_Transform,
2911 };
2912
2913 static inline struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2914 {
2915 if (!iface)
2916 return NULL;
2917 assert(iface->lpVtbl == &d3drm_frame3_vtbl);
2918
2919 return impl_from_IDirect3DRMFrame3(iface);
2920 }
2921
2922 struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame(IDirect3DRMFrame *iface)
2923 {
2924 if (!iface)
2925 return NULL;
2926 assert(iface->lpVtbl == &d3drm_frame1_vtbl);
2927
2928 return impl_from_IDirect3DRMFrame(iface);
2929 }
2930
2931 HRESULT d3drm_frame_create(struct d3drm_frame **frame, IUnknown *parent_frame, IDirect3DRM *d3drm)
2932 {
2933 struct d3drm_frame *object;
2934 HRESULT hr = D3DRM_OK;
2935
2936 TRACE("frame %p, parent_frame %p, d3drm %p.\n", frame, parent_frame, d3drm);
2937
2938 if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2939 return E_OUTOFMEMORY;
2940
2941 object->IDirect3DRMFrame_iface.lpVtbl = &d3drm_frame1_vtbl;
2942 object->IDirect3DRMFrame2_iface.lpVtbl = &d3drm_frame2_vtbl;
2943 object->IDirect3DRMFrame3_iface.lpVtbl = &d3drm_frame3_vtbl;
2944 object->d3drm = d3drm;
2945 object->ref = 1;
2946 d3drm_set_color(&object->scenebackground, 0.0f, 0.0f, 0.0f, 1.0f);
2947
2948 memcpy(object->transform, identity, sizeof(D3DRMMATRIX4D));
2949
2950 if (parent_frame)
2951 {
2952 IDirect3DRMFrame3 *p;
2953
2954 if (FAILED(hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&p)))
2955 {
2956 HeapFree(GetProcessHeap(), 0, object);
2957 return hr;
2958 }
2959 IDirect3DRMFrame_Release(parent_frame);
2960 IDirect3DRMFrame3_AddChild(p, &object->IDirect3DRMFrame3_iface);
2961 }
2962
2963 *frame = object;
2964
2965 return hr;
2966 }
Windows API implementation