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