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