?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dbghelp: Bump limits
[wine/multimedia.git] / dlls / d3drm / frame.c
blobf0e1cd0978b052cd3ff3baeac23aab0caf8ce3c3
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 typedef struct IDirect3DRMFrameImpl IDirect3DRMFrameImpl;
42
43 struct IDirect3DRMFrameImpl {
44 IDirect3DRMFrame2 IDirect3DRMFrame2_iface;
45 IDirect3DRMFrame3 IDirect3DRMFrame3_iface;
46 LONG ref;
47 IDirect3DRMFrameImpl* parent;
48 ULONG nb_children;
49 ULONG children_capacity;
50 IDirect3DRMFrame3** children;
51 ULONG nb_visuals;
52 ULONG visuals_capacity;
53 IDirect3DRMVisual** visuals;
54 ULONG nb_lights;
55 ULONG lights_capacity;
56 IDirect3DRMLight** lights;
57 D3DRMMATRIX4D transform;
58 };
59
60 typedef struct {
61 IDirect3DRMFrameArray IDirect3DRMFrameArray_iface;
62 LONG ref;
63 ULONG size;
64 LPDIRECT3DRMFRAME* frames;
65 } IDirect3DRMFrameArrayImpl;
66
67 typedef struct {
68 IDirect3DRMVisualArray IDirect3DRMVisualArray_iface;
69 LONG ref;
70 ULONG size;
71 LPDIRECT3DRMVISUAL* visuals;
72 } IDirect3DRMVisualArrayImpl;
73
74 typedef struct {
75 IDirect3DRMLightArray IDirect3DRMLightArray_iface;
76 LONG ref;
77 ULONG size;
78 LPDIRECT3DRMLIGHT* lights;
79 } IDirect3DRMLightArrayImpl;
80
81 HRESULT Direct3DRMFrameArray_create(IDirect3DRMFrameArray** obj);
82 HRESULT Direct3DRMVisualArray_create(IDirect3DRMVisualArray** ret_iface);
83 HRESULT Direct3DRMLightArray_create(IDirect3DRMLightArray** ret_iface);
84
85 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
86 {
87 return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame2_iface);
88 }
89
90 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
91 {
92 return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame3_iface);
93 }
94
95 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface);
96 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface);
97
98 static inline IDirect3DRMLightArrayImpl *impl_from_IDirect3DRMLightArray(IDirect3DRMLightArray *iface)
99 {
100 return CONTAINING_RECORD(iface, IDirect3DRMLightArrayImpl, IDirect3DRMLightArray_iface);
101 }
102
103 /*** IUnknown methods ***/
104 static HRESULT WINAPI IDirect3DRMFrame2Impl_QueryInterface(IDirect3DRMFrame2* iface,
105 REFIID riid, void** object)
106 {
107 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
108
109 TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
110
111 *object = NULL;
112
113 if(IsEqualGUID(riid, &IID_IUnknown) ||
114 IsEqualGUID(riid, &IID_IDirect3DRMFrame) ||
115 IsEqualGUID(riid, &IID_IDirect3DRMFrame2))
116 {
117 *object = &This->IDirect3DRMFrame2_iface;
118 }
119 else if(IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
120 {
121 *object = &This->IDirect3DRMFrame3_iface;
122 }
123 else
124 {
125 FIXME("interface %s not implemented\n", debugstr_guid(riid));
126 return E_NOINTERFACE;
127 }
128
129 IDirect3DRMFrame2_AddRef(iface);
130 return S_OK;
131 }
132
133 static ULONG WINAPI IDirect3DRMFrame2Impl_AddRef(IDirect3DRMFrame2* iface)
134 {
135 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
136 ULONG ref = InterlockedIncrement(&This->ref);
137
138 TRACE("(%p)->(): new ref = %d\n", This, ref);
139
140 return ref;
141 }
142
143 static ULONG WINAPI IDirect3DRMFrame2Impl_Release(IDirect3DRMFrame2* iface)
144 {
145 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
146 ULONG ref = InterlockedDecrement(&This->ref);
147 ULONG i;
148
149 TRACE("(%p)->(): new ref = %d\n", This, ref);
150
151 if (!ref)
152 {
153 for (i = 0; i < This->nb_children; i++)
154 IDirect3DRMFrame3_Release(This->children[i]);
155 HeapFree(GetProcessHeap(), 0, This->children);
156 for (i = 0; i < This->nb_visuals; i++)
157 IDirect3DRMVisual_Release(This->visuals[i]);
158 HeapFree(GetProcessHeap(), 0, This->visuals);
159 for (i = 0; i < This->nb_lights; i++)
160 IDirect3DRMLight_Release(This->lights[i]);
161 HeapFree(GetProcessHeap(), 0, This->lights);
162 HeapFree(GetProcessHeap(), 0, This);
163 }
164
165 return ref;
166 }
167
168 /*** IDirect3DRMObject methods ***/
169 static HRESULT WINAPI IDirect3DRMFrame2Impl_Clone(IDirect3DRMFrame2* iface,
170 LPUNKNOWN unkwn, REFIID riid,
171 LPVOID* object)
172 {
173 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
174
175 FIXME("(%p/%p)->(%p, %s, %p): stub\n", iface, This, unkwn, debugstr_guid(riid), object);
176
177 return E_NOTIMPL;
178 }
179
180 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddDestroyCallback(IDirect3DRMFrame2* iface,
181 D3DRMOBJECTCALLBACK cb,
182 LPVOID argument)
183 {
184 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
185
186 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
187
188 return E_NOTIMPL;
189 }
190
191 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteDestroyCallback(IDirect3DRMFrame2* iface,
192 D3DRMOBJECTCALLBACK cb,
193 LPVOID argument)
194 {
195 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
196
197 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
198
199 return E_NOTIMPL;
200 }
201
202 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetAppData(IDirect3DRMFrame2* iface,
203 DWORD data)
204 {
205 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
206
207 FIXME("(%p/%p)->(%u): stub\n", iface, This, data);
208
209 return E_NOTIMPL;
210 }
211
212 static DWORD WINAPI IDirect3DRMFrame2Impl_GetAppData(IDirect3DRMFrame2* iface)
213 {
214 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
215
216 FIXME("(%p/%p)->(): stub\n", iface, This);
217
218 return 0;
219 }
220
221 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetName(IDirect3DRMFrame2* iface, LPCSTR name)
222 {
223 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
224
225 FIXME("(%p/%p)->(%s): stub\n", iface, This, name);
226
227 return E_NOTIMPL;
228 }
229
230 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetName(IDirect3DRMFrame2* iface,
231 LPDWORD size, LPSTR name)
232 {
233 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
234
235 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
236
237 return E_NOTIMPL;
238 }
239
240 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetClassName(IDirect3DRMFrame2* iface,
241 LPDWORD size, LPSTR name)
242 {
243 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
244
245 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
246
247 return E_NOTIMPL;
248 }
249
250 /*** IDirect3DRMFrame methods ***/
251 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddChild(IDirect3DRMFrame2* iface,
252 LPDIRECT3DRMFRAME child)
253 {
254 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
255 IDirect3DRMFrameImpl *frame = unsafe_impl_from_IDirect3DRMFrame2((LPDIRECT3DRMFRAME2)child);
256
257 TRACE("(%p/%p)->(%p)\n", iface, This, child);
258
259 if (!frame)
260 return D3DRMERR_BADOBJECT;
261
262 return IDirect3DRMFrame3_AddChild(&This->IDirect3DRMFrame3_iface, &frame->IDirect3DRMFrame3_iface);
263 }
264
265 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddLight(IDirect3DRMFrame2* iface,
266 LPDIRECT3DRMLIGHT light)
267 {
268 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
269
270 TRACE("(%p/%p)->(%p)\n", iface, This, light);
271
272 return IDirect3DRMFrame3_AddLight(&This->IDirect3DRMFrame3_iface, light);
273 }
274
275 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback(IDirect3DRMFrame2* iface,
276 D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
277 {
278 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
279
280 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
281
282 return E_NOTIMPL;
283 }
284
285 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTransform(IDirect3DRMFrame2* iface,
286 D3DRMCOMBINETYPE type,
287 D3DRMMATRIX4D matrix)
288 {
289 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
290
291 TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
292
293 return IDirect3DRMFrame3_AddTransform(&This->IDirect3DRMFrame3_iface, type, matrix);
294 }
295
296 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTranslation(IDirect3DRMFrame2* iface,
297 D3DRMCOMBINETYPE type,
298 D3DVALUE x, D3DVALUE y, D3DVALUE z)
299 {
300 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
301
302 FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
303
304 return E_NOTIMPL;
305 }
306
307 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddScale(IDirect3DRMFrame2* iface,
308 D3DRMCOMBINETYPE type,
309 D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
310 {
311 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
312
313 FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
314
315 return E_NOTIMPL;
316 }
317
318 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddRotation(IDirect3DRMFrame2* iface,
319 D3DRMCOMBINETYPE type,
320 D3DVALUE x, D3DVALUE y, D3DVALUE z,
321 D3DVALUE theta)
322 {
323 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
324
325 FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
326
327 return E_NOTIMPL;
328 }
329
330 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddVisual(IDirect3DRMFrame2* iface,
331 LPDIRECT3DRMVISUAL vis)
332 {
333 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
334
335 TRACE("(%p/%p)->(%p)\n", iface, This, vis);
336
337 return IDirect3DRMFrame3_AddVisual(&This->IDirect3DRMFrame3_iface, (LPUNKNOWN)vis);
338 }
339
340 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetChildren(IDirect3DRMFrame2* iface,
341 LPDIRECT3DRMFRAMEARRAY *children)
342 {
343 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
344
345 TRACE("(%p/%p)->(%p)\n", iface, This, children);
346
347 return IDirect3DRMFrame3_GetChildren(&This->IDirect3DRMFrame3_iface, children);
348 }
349
350 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetColor(IDirect3DRMFrame2* iface)
351 {
352 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
353
354 FIXME("(%p/%p)->(): stub\n", iface, This);
355
356 return 0;
357 }
358
359 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetLights(IDirect3DRMFrame2* iface,
360 LPDIRECT3DRMLIGHTARRAY *lights)
361 {
362 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
363
364 TRACE("(%p/%p)->(%p)\n", iface, This, lights);
365
366 return IDirect3DRMFrame3_GetLights(&This->IDirect3DRMFrame3_iface, lights);
367 }
368
369 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame2Impl_GetMaterialMode(IDirect3DRMFrame2* iface)
370 {
371 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
372
373 FIXME("(%p/%p)->(): stub\n", iface, This);
374
375 return D3DRMMATERIAL_FROMPARENT;
376 }
377
378 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetParent(IDirect3DRMFrame2* iface,
379 LPDIRECT3DRMFRAME * frame)
380 {
381 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
382
383 TRACE("(%p/%p)->(%p)\n", iface, This, frame);
384
385 if (!frame)
386 return D3DRMERR_BADVALUE;
387
388 if (This->parent)
389 {
390 *frame = (LPDIRECT3DRMFRAME)&This->parent->IDirect3DRMFrame2_iface;
391 IDirect3DRMFrame_AddRef(*frame);
392 }
393 else
394 {
395 *frame = NULL;
396 }
397
398 return D3DRM_OK;
399 }
400
401 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetPosition(IDirect3DRMFrame2* iface,
402 LPDIRECT3DRMFRAME reference,
403 LPD3DVECTOR return_position)
404 {
405 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
406
407 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
408
409 return E_NOTIMPL;
410 }
411
412 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetRotation(IDirect3DRMFrame2* iface,
413 LPDIRECT3DRMFRAME reference,
414 LPD3DVECTOR axis, LPD3DVALUE return_theta)
415 {
416 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
417
418 FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
419
420 return E_NOTIMPL;
421 }
422
423 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetScene(IDirect3DRMFrame2* iface,
424 LPDIRECT3DRMFRAME * frame)
425 {
426 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
427
428 FIXME("(%p/%p)->(%p): stub\n", iface, This, frame);
429
430 return E_NOTIMPL;
431 }
432
433 static D3DRMSORTMODE WINAPI IDirect3DRMFrame2Impl_GetSortMode(IDirect3DRMFrame2* iface)
434 {
435 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
436
437 FIXME("(%p/%p)->(): stub\n", iface, This);
438
439 return D3DRMSORT_FROMPARENT;
440 }
441
442 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTexture(IDirect3DRMFrame2* iface,
443 LPDIRECT3DRMTEXTURE * tex)
444 {
445 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
446
447 FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
448
449 return E_NOTIMPL;
450 }
451
452 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTransform(IDirect3DRMFrame2* iface,
453 D3DRMMATRIX4D return_matrix)
454 {
455 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
456
457 TRACE("(%p/%p)->(%p)\n", iface, This, return_matrix);
458
459 memcpy(&return_matrix[0][0], &This->transform[0][0], sizeof(D3DRMMATRIX4D));
460
461 return D3DRM_OK;
462 }
463
464 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetVelocity(IDirect3DRMFrame2* iface,
465 LPDIRECT3DRMFRAME reference,
466 LPD3DVECTOR return_velocity,
467 BOOL with_rotation)
468 {
469 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
470
471 FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
472
473 return E_NOTIMPL;
474 }
475
476 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetOrientation(IDirect3DRMFrame2* iface,
477 LPDIRECT3DRMFRAME reference,
478 LPD3DVECTOR dir, LPD3DVECTOR up)
479 {
480 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
481
482 FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, dir, up);
483
484 return E_NOTIMPL;
485 }
486
487 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetVisuals(IDirect3DRMFrame2* iface,
488 LPDIRECT3DRMVISUALARRAY *visuals)
489 {
490 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
491 IDirect3DRMVisualArrayImpl* obj;
492 HRESULT hr;
493
494 TRACE("(%p/%p)->(%p)\n", iface, This, visuals);
495
496 if (!visuals)
497 return D3DRMERR_BADVALUE;
498
499 hr = Direct3DRMVisualArray_create(visuals);
500
501 if (hr != D3DRM_OK)
502 return hr;
503
504 obj = (IDirect3DRMVisualArrayImpl*)*visuals;
505
506 obj->size = This->nb_visuals;
507 if (This->nb_visuals)
508 {
509 ULONG i;
510 obj->visuals = HeapAlloc(GetProcessHeap(), 0, This->nb_visuals * sizeof(LPDIRECT3DRMVISUAL));
511 if (!obj->visuals)
512 return E_OUTOFMEMORY;
513 for (i = 0; i < This->nb_visuals; i++)
514 {
515 obj->visuals[i] = This->visuals[i];
516 IDirect3DRMVisual_AddRef(This->visuals[i]);
517 }
518 }
519
520 return D3DRM_OK;
521 }
522
523 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTextureTopology(IDirect3DRMFrame2* iface,
524 BOOL *wrap_u, BOOL *wrap_v)
525 {
526 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
527
528 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, wrap_u, wrap_v);
529
530 return E_NOTIMPL;
531 }
532
533 static HRESULT WINAPI IDirect3DRMFrame2Impl_InverseTransform(IDirect3DRMFrame2* iface,
534 D3DVECTOR *d, D3DVECTOR *s)
535 {
536 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
537
538 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
539
540 return E_NOTIMPL;
541 }
542
543 static HRESULT WINAPI IDirect3DRMFrame2Impl_Load(IDirect3DRMFrame2* iface, LPVOID filename,
544 LPVOID name, D3DRMLOADOPTIONS loadflags,
545 D3DRMLOADTEXTURECALLBACK cb, LPVOID lpArg)
546 {
547 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
548
549 FIXME("(%p/%p)->(%p,%p,%u,%p,%p): stub\n", iface, This, filename, name, loadflags, cb, lpArg);
550
551 return E_NOTIMPL;
552 }
553
554 static HRESULT WINAPI IDirect3DRMFrame2Impl_LookAt(IDirect3DRMFrame2* iface,
555 LPDIRECT3DRMFRAME target,
556 LPDIRECT3DRMFRAME reference,
557 D3DRMFRAMECONSTRAINT constraint)
558 {
559 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
560
561 FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, target, reference, constraint);
562
563 return E_NOTIMPL;
564 }
565
566 static HRESULT WINAPI IDirect3DRMFrame2Impl_Move(IDirect3DRMFrame2* iface, D3DVALUE delta)
567 {
568 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
569
570 FIXME("(%p/%p)->(%f): stub\n", iface, This, delta);
571
572 return E_NOTIMPL;
573 }
574
575 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteChild(IDirect3DRMFrame2* iface,
576 LPDIRECT3DRMFRAME frame)
577 {
578 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
579 IDirect3DRMFrameImpl *child = unsafe_impl_from_IDirect3DRMFrame2((LPDIRECT3DRMFRAME2)frame);
580
581 TRACE("(%p/%p)->(%p)\n", iface, This, frame);
582
583 if (!child)
584 return D3DRMERR_BADOBJECT;
585
586 return IDirect3DRMFrame3_DeleteChild(&This->IDirect3DRMFrame3_iface, &child->IDirect3DRMFrame3_iface);
587 }
588
589 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteLight(IDirect3DRMFrame2* iface,
590 LPDIRECT3DRMLIGHT light)
591 {
592 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
593
594 TRACE("(%p/%p)->(%p)\n", iface, This, light);
595
596 return IDirect3DRMFrame3_DeleteLight(&This->IDirect3DRMFrame3_iface, light);
597 }
598
599 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteMoveCallback(IDirect3DRMFrame2* iface,
600 D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
601 {
602 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
603
604 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
605
606 return E_NOTIMPL;
607 }
608
609 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteVisual(IDirect3DRMFrame2* iface,
610 LPDIRECT3DRMVISUAL vis)
611 {
612 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
613
614 TRACE("(%p/%p)->(%p)\n", iface, This, vis);
615
616 return IDirect3DRMFrame3_DeleteVisual(&This->IDirect3DRMFrame3_iface, (LPUNKNOWN)vis);
617 }
618
619 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneBackground(IDirect3DRMFrame2* iface)
620 {
621 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
622
623 FIXME("(%p/%p)->(): stub\n", iface, This);
624
625 return 0;
626 }
627
628 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneBackgroundDepth(IDirect3DRMFrame2* iface,
629 LPDIRECTDRAWSURFACE * surface)
630 {
631 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
632
633 FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
634
635 return E_NOTIMPL;
636 }
637
638 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneFogColor(IDirect3DRMFrame2* iface)
639 {
640 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
641
642 FIXME("(%p/%p)->(): stub\n", iface, This);
643
644 return 0;
645 }
646
647 static BOOL WINAPI IDirect3DRMFrame2Impl_GetSceneFogEnable(IDirect3DRMFrame2* iface)
648 {
649 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
650
651 FIXME("(%p/%p)->(): stub\n", iface, This);
652
653 return FALSE;
654 }
655
656 static D3DRMFOGMODE WINAPI IDirect3DRMFrame2Impl_GetSceneFogMode(IDirect3DRMFrame2* iface)
657 {
658 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
659
660 FIXME("(%p/%p)->(): stub\n", iface, This);
661
662 return D3DRMFOG_LINEAR;
663 }
664
665 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneFogParams(IDirect3DRMFrame2* iface,
666 D3DVALUE *return_start,
667 D3DVALUE *return_end,
668 D3DVALUE *return_density)
669 {
670 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
671
672 FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
673
674 return E_NOTIMPL;
675 }
676
677 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackground(IDirect3DRMFrame2* iface,
678 D3DCOLOR color)
679 {
680 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
681
682 FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
683
684 return E_NOTIMPL;
685 }
686
687 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundRGB(IDirect3DRMFrame2* iface,
688 D3DVALUE red, D3DVALUE green,
689 D3DVALUE blue)
690 {
691 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
692
693 FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
694
695 return E_NOTIMPL;
696 }
697
698 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundDepth(IDirect3DRMFrame2* iface,
699 LPDIRECTDRAWSURFACE surface)
700 {
701 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
702
703 FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
704
705 return E_NOTIMPL;
706 }
707
708 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundImage(IDirect3DRMFrame2* iface,
709 LPDIRECT3DRMTEXTURE texture)
710 {
711 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
712
713 FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
714
715 return E_NOTIMPL;
716 }
717
718 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogEnable(IDirect3DRMFrame2* iface, BOOL enable)
719 {
720 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
721
722 FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
723
724 return E_NOTIMPL;
725 }
726
727 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogColor(IDirect3DRMFrame2* iface,
728 D3DCOLOR color)
729 {
730 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
731
732 FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
733
734 return E_NOTIMPL;
735 }
736
737 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogMode(IDirect3DRMFrame2* iface,
738 D3DRMFOGMODE mode)
739 {
740 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
741
742 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
743
744 return E_NOTIMPL;
745 }
746
747 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogParams(IDirect3DRMFrame2* iface,
748 D3DVALUE start, D3DVALUE end,
749 D3DVALUE density)
750 {
751 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
752
753 FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
754
755 return E_NOTIMPL;
756 }
757
758 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColor(IDirect3DRMFrame2* iface, D3DCOLOR color)
759 {
760 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
761
762 FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
763
764 return E_NOTIMPL;
765 }
766
767 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColorRGB(IDirect3DRMFrame2* iface, D3DVALUE red,
768 D3DVALUE green, D3DVALUE blue)
769 {
770 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
771
772 FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
773
774 return E_NOTIMPL;
775 }
776
777 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame2Impl_GetZbufferMode(IDirect3DRMFrame2* iface)
778 {
779 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
780
781 FIXME("(%p/%p)->(): stub\n", iface, This);
782
783 return D3DRMZBUFFER_FROMPARENT;
784 }
785
786 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetMaterialMode(IDirect3DRMFrame2* iface,
787 D3DRMMATERIALMODE mode)
788 {
789 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
790
791 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
792
793 return E_NOTIMPL;
794 }
795
796 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetOrientation(IDirect3DRMFrame2* iface,
797 LPDIRECT3DRMFRAME reference,
798 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
799 D3DVALUE ux, D3DVALUE uy, D3DVALUE uz )
800 {
801 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
802
803 FIXME("(%p/%p)->(%p,%f,%f,%f,%f,%f,%f): stub\n", iface, This, reference,
804 dx, dy, dz, ux, uy, uz);
805
806 return E_NOTIMPL;
807 }
808
809 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetPosition(IDirect3DRMFrame2* iface,
810 LPDIRECT3DRMFRAME reference,
811 D3DVALUE x, D3DVALUE y, D3DVALUE z)
812 {
813 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
814
815 FIXME("(%p/%p)->(%p,%f,%f,%f): stub\n", iface, This, reference, x, y, z);
816
817 return E_NOTIMPL;
818 }
819
820 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetRotation(IDirect3DRMFrame2* iface,
821 LPDIRECT3DRMFRAME reference,
822 D3DVALUE x, D3DVALUE y, D3DVALUE z,
823 D3DVALUE theta)
824 {
825 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
826
827 FIXME("(%p/%p)->(%p,%f,%f,%f,%f): stub\n", iface, This, reference, x, y, z, theta);
828
829 return E_NOTIMPL;
830 }
831
832 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSortMode(IDirect3DRMFrame2* iface,
833 D3DRMSORTMODE mode)
834 {
835 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
836
837 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
838
839 return E_NOTIMPL;
840 }
841
842 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTexture(IDirect3DRMFrame2* iface,
843 LPDIRECT3DRMTEXTURE texture)
844 {
845 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
846
847 FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
848
849 return E_NOTIMPL;
850 }
851
852 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTextureTopology(IDirect3DRMFrame2* iface,
853 BOOL wrap_u, BOOL wrap_v)
854 {
855 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
856
857 FIXME("(%p/%p)->(%d,%d): stub\n", iface, This, wrap_u, wrap_v);
858
859 return E_NOTIMPL;
860 }
861
862 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetVelocity(IDirect3DRMFrame2* iface,
863 LPDIRECT3DRMFRAME reference,
864 D3DVALUE x, D3DVALUE y, D3DVALUE z,
865 BOOL with_rotation)
866 {
867 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
868
869 FIXME("(%p/%p)->(%p,%f,%f,%f,%d): stub\n", iface, This, reference, x, y, z, with_rotation);
870
871 return E_NOTIMPL;
872 }
873
874 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetZbufferMode(IDirect3DRMFrame2* iface,
875 D3DRMZBUFFERMODE mode)
876 {
877 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
878
879 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
880
881 return E_NOTIMPL;
882 }
883
884 static HRESULT WINAPI IDirect3DRMFrame2Impl_Transform(IDirect3DRMFrame2* iface, D3DVECTOR *d,
885 D3DVECTOR *s)
886 {
887 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
888
889 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
890
891 return E_NOTIMPL;
892 }
893
894 /*** IDirect3DRMFrame2 methods ***/
895 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback2(IDirect3DRMFrame2* iface,
896 D3DRMFRAMEMOVECALLBACK cb, VOID *arg,
897 DWORD flags)
898 {
899 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
900
901 FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
902
903 return E_NOTIMPL;
904 }
905
906 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetBox(IDirect3DRMFrame2* iface, LPD3DRMBOX box)
907 {
908 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
909
910 FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
911
912 return E_NOTIMPL;
913 }
914
915 static BOOL WINAPI IDirect3DRMFrame2Impl_GetBoxEnable(IDirect3DRMFrame2* iface)
916 {
917 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
918
919 FIXME("(%p/%p)->(): stub\n", iface, This);
920
921 return E_NOTIMPL;
922 }
923
924 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetAxes(IDirect3DRMFrame2* iface,
925 LPD3DVECTOR dir, LPD3DVECTOR up)
926 {
927 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
928
929 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
930
931 return E_NOTIMPL;
932 }
933
934 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetMaterial(IDirect3DRMFrame2* iface,
935 LPDIRECT3DRMMATERIAL *material)
936 {
937 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
938
939 FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
940
941 return E_NOTIMPL;
942 }
943
944 static BOOL WINAPI IDirect3DRMFrame2Impl_GetInheritAxes(IDirect3DRMFrame2* iface)
945 {
946 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
947
948 FIXME("(%p/%p)->(): stub\n", iface, This);
949
950 return E_NOTIMPL;
951 }
952
953 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetHierarchyBox(IDirect3DRMFrame2* iface,
954 LPD3DRMBOX box)
955 {
956 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
957
958 FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
959
960 return E_NOTIMPL;
961 }
962
963 static const struct IDirect3DRMFrame2Vtbl Direct3DRMFrame2_Vtbl =
964 {
965 /*** IUnknown methods ***/
966 IDirect3DRMFrame2Impl_QueryInterface,
967 IDirect3DRMFrame2Impl_AddRef,
968 IDirect3DRMFrame2Impl_Release,
969 /*** IDirect3DRMObject methods ***/
970 IDirect3DRMFrame2Impl_Clone,
971 IDirect3DRMFrame2Impl_AddDestroyCallback,
972 IDirect3DRMFrame2Impl_DeleteDestroyCallback,
973 IDirect3DRMFrame2Impl_SetAppData,
974 IDirect3DRMFrame2Impl_GetAppData,
975 IDirect3DRMFrame2Impl_SetName,
976 IDirect3DRMFrame2Impl_GetName,
977 IDirect3DRMFrame2Impl_GetClassName,
978 /*** IDirect3DRMFrame methods ***/
979 IDirect3DRMFrame2Impl_AddChild,
980 IDirect3DRMFrame2Impl_AddLight,
981 IDirect3DRMFrame2Impl_AddMoveCallback,
982 IDirect3DRMFrame2Impl_AddTransform,
983 IDirect3DRMFrame2Impl_AddTranslation,
984 IDirect3DRMFrame2Impl_AddScale,
985 IDirect3DRMFrame2Impl_AddRotation,
986 IDirect3DRMFrame2Impl_AddVisual,
987 IDirect3DRMFrame2Impl_GetChildren,
988 IDirect3DRMFrame2Impl_GetColor,
989 IDirect3DRMFrame2Impl_GetLights,
990 IDirect3DRMFrame2Impl_GetMaterialMode,
991 IDirect3DRMFrame2Impl_GetParent,
992 IDirect3DRMFrame2Impl_GetPosition,
993 IDirect3DRMFrame2Impl_GetRotation,
994 IDirect3DRMFrame2Impl_GetScene,
995 IDirect3DRMFrame2Impl_GetSortMode,
996 IDirect3DRMFrame2Impl_GetTexture,
997 IDirect3DRMFrame2Impl_GetTransform,
998 IDirect3DRMFrame2Impl_GetVelocity,
999 IDirect3DRMFrame2Impl_GetOrientation,
1000 IDirect3DRMFrame2Impl_GetVisuals,
1001 IDirect3DRMFrame2Impl_GetTextureTopology,
1002 IDirect3DRMFrame2Impl_InverseTransform,
1003 IDirect3DRMFrame2Impl_Load,
1004 IDirect3DRMFrame2Impl_LookAt,
1005 IDirect3DRMFrame2Impl_Move,
1006 IDirect3DRMFrame2Impl_DeleteChild,
1007 IDirect3DRMFrame2Impl_DeleteLight,
1008 IDirect3DRMFrame2Impl_DeleteMoveCallback,
1009 IDirect3DRMFrame2Impl_DeleteVisual,
1010 IDirect3DRMFrame2Impl_GetSceneBackground,
1011 IDirect3DRMFrame2Impl_GetSceneBackgroundDepth,
1012 IDirect3DRMFrame2Impl_GetSceneFogColor,
1013 IDirect3DRMFrame2Impl_GetSceneFogEnable,
1014 IDirect3DRMFrame2Impl_GetSceneFogMode,
1015 IDirect3DRMFrame2Impl_GetSceneFogParams,
1016 IDirect3DRMFrame2Impl_SetSceneBackground,
1017 IDirect3DRMFrame2Impl_SetSceneBackgroundRGB,
1018 IDirect3DRMFrame2Impl_SetSceneBackgroundDepth,
1019 IDirect3DRMFrame2Impl_SetSceneBackgroundImage,
1020 IDirect3DRMFrame2Impl_SetSceneFogEnable,
1021 IDirect3DRMFrame2Impl_SetSceneFogColor,
1022 IDirect3DRMFrame2Impl_SetSceneFogMode,
1023 IDirect3DRMFrame2Impl_SetSceneFogParams,
1024 IDirect3DRMFrame2Impl_SetColor,
1025 IDirect3DRMFrame2Impl_SetColorRGB,
1026 IDirect3DRMFrame2Impl_GetZbufferMode,
1027 IDirect3DRMFrame2Impl_SetMaterialMode,
1028 IDirect3DRMFrame2Impl_SetOrientation,
1029 IDirect3DRMFrame2Impl_SetPosition,
1030 IDirect3DRMFrame2Impl_SetRotation,
1031 IDirect3DRMFrame2Impl_SetSortMode,
1032 IDirect3DRMFrame2Impl_SetTexture,
1033 IDirect3DRMFrame2Impl_SetTextureTopology,
1034 IDirect3DRMFrame2Impl_SetVelocity,
1035 IDirect3DRMFrame2Impl_SetZbufferMode,
1036 IDirect3DRMFrame2Impl_Transform,
1037 /*** IDirect3DRMFrame2 methods ***/
1038 IDirect3DRMFrame2Impl_AddMoveCallback2,
1039 IDirect3DRMFrame2Impl_GetBox,
1040 IDirect3DRMFrame2Impl_GetBoxEnable,
1041 IDirect3DRMFrame2Impl_GetAxes,
1042 IDirect3DRMFrame2Impl_GetMaterial,
1043 IDirect3DRMFrame2Impl_GetInheritAxes,
1044 IDirect3DRMFrame2Impl_GetHierarchyBox
1045 };
1046
1047 /*** IUnknown methods ***/
1048 static HRESULT WINAPI IDirect3DRMFrame3Impl_QueryInterface(IDirect3DRMFrame3* iface,
1049 REFIID riid, void** object)
1050 {
1051 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1052 return IDirect3DRMFrame_QueryInterface(&This->IDirect3DRMFrame2_iface, riid, object);
1053 }
1054
1055 static ULONG WINAPI IDirect3DRMFrame3Impl_AddRef(IDirect3DRMFrame3* iface)
1056 {
1057 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1058 return IDirect3DRMFrame2_AddRef(&This->IDirect3DRMFrame2_iface);
1059 }
1060
1061 static ULONG WINAPI IDirect3DRMFrame3Impl_Release(IDirect3DRMFrame3* iface)
1062 {
1063 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1064 return IDirect3DRMFrame2_Release(&This->IDirect3DRMFrame2_iface);
1065 }
1066
1067 /*** IDirect3DRMObject methods ***/
1068 static HRESULT WINAPI IDirect3DRMFrame3Impl_Clone(IDirect3DRMFrame3* iface,
1069 LPUNKNOWN unkwn, REFIID riid,
1070 LPVOID* object)
1071 {
1072 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1073
1074 FIXME("(%p/%p)->(%p, %s, %p): stub\n", iface, This, unkwn, debugstr_guid(riid), object);
1075
1076 return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddDestroyCallback(IDirect3DRMFrame3* iface,
1080 D3DRMOBJECTCALLBACK cb,
1081 LPVOID argument)
1082 {
1083 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1084
1085 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1086
1087 return E_NOTIMPL;
1088 }
1089
1090 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteDestroyCallback(IDirect3DRMFrame3* iface,
1091 D3DRMOBJECTCALLBACK cb,
1092 LPVOID argument)
1093 {
1094 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1095
1096 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1097
1098 return E_NOTIMPL;
1099 }
1100
1101 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAppData(IDirect3DRMFrame3* iface,
1102 DWORD data)
1103 {
1104 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1105
1106 FIXME("(%p/%p)->(%u): stub\n", iface, This, data);
1107
1108 return E_NOTIMPL;
1109 }
1110
1111 static DWORD WINAPI IDirect3DRMFrame3Impl_GetAppData(IDirect3DRMFrame3* iface)
1112 {
1113 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1114
1115 FIXME("(%p/%p)->(): stub\n", iface, This);
1116
1117 return 0;
1118 }
1119
1120 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetName(IDirect3DRMFrame3* iface, LPCSTR name)
1121 {
1122 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1123
1124 FIXME("(%p/%p)->(%s): stub\n", iface, This, name);
1125
1126 return E_NOTIMPL;
1127 }
1128
1129 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetName(IDirect3DRMFrame3* iface,
1130 LPDWORD size, LPSTR name)
1131 {
1132 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1133
1134 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
1135
1136 return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetClassName(IDirect3DRMFrame3* iface,
1140 LPDWORD size, LPSTR name)
1141 {
1142 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1143
1144 FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
1145
1146 return E_NOTIMPL;
1147 }
1148
1149 /*** IDirect3DRMFrame methods ***/
1150 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddChild(IDirect3DRMFrame3* iface,
1151 LPDIRECT3DRMFRAME3 child)
1152 {
1153 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1154 IDirect3DRMFrameImpl *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
1155
1156 TRACE("(%p/%p)->(%p)\n", iface, This, child);
1157
1158 if (!child_obj)
1159 return D3DRMERR_BADOBJECT;
1160
1161 if (child_obj->parent)
1162 {
1163 IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
1164
1165 if (parent == iface)
1166 {
1167 /* Passed frame is already a child so return success */
1168 return D3DRM_OK;
1169 }
1170 else
1171 {
1172 /* Remove parent and continue */
1173 IDirect3DRMFrame3_DeleteChild(parent, child);
1174 }
1175 }
1176
1177 if ((This->nb_children + 1) > This->children_capacity)
1178 {
1179 ULONG new_capacity;
1180 IDirect3DRMFrame3** children;
1181
1182 if (!This->children_capacity)
1183 {
1184 new_capacity = 16;
1185 children = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMFrame3*));
1186 }
1187 else
1188 {
1189 new_capacity = This->children_capacity * 2;
1190 children = HeapReAlloc(GetProcessHeap(), 0, This->children, new_capacity * sizeof(IDirect3DRMFrame3*));
1191 }
1192
1193 if (!children)
1194 return E_OUTOFMEMORY;
1195
1196 This->children_capacity = new_capacity;
1197 This->children = children;
1198 }
1199
1200 This->children[This->nb_children++] = child;
1201 IDirect3DRMFrame3_AddRef(child);
1202 child_obj->parent = This;
1203
1204 return D3DRM_OK;
1205 }
1206
1207 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddLight(IDirect3DRMFrame3* iface,
1208 LPDIRECT3DRMLIGHT light)
1209 {
1210 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1211 ULONG i;
1212 IDirect3DRMLight** lights;
1213
1214 TRACE("(%p/%p)->(%p)\n", iface, This, light);
1215
1216 if (!light)
1217 return D3DRMERR_BADOBJECT;
1218
1219 /* Check if already existing and return gracefully without increasing ref count */
1220 for (i = 0; i < This->nb_lights; i++)
1221 if (This->lights[i] == light)
1222 return D3DRM_OK;
1223
1224 if ((This->nb_lights + 1) > This->lights_capacity)
1225 {
1226 ULONG new_capacity;
1227
1228 if (!This->lights_capacity)
1229 {
1230 new_capacity = 16;
1231 lights = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMLight*));
1232 }
1233 else
1234 {
1235 new_capacity = This->lights_capacity * 2;
1236 lights = HeapReAlloc(GetProcessHeap(), 0, This->lights, new_capacity * sizeof(IDirect3DRMLight*));
1237 }
1238
1239 if (!lights)
1240 return E_OUTOFMEMORY;
1241
1242 This->lights_capacity = new_capacity;
1243 This->lights = lights;
1244 }
1245
1246 This->lights[This->nb_lights++] = light;
1247 IDirect3DRMLight_AddRef(light);
1248
1249 return D3DRM_OK;
1250 }
1251
1252 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddMoveCallback(IDirect3DRMFrame3* iface,
1253 D3DRMFRAME3MOVECALLBACK cb, VOID *arg,
1254 DWORD flags)
1255 {
1256 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1257
1258 FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
1259
1260 return E_NOTIMPL;
1261 }
1262
1263 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTransform(IDirect3DRMFrame3* iface,
1264 D3DRMCOMBINETYPE type,
1265 D3DRMMATRIX4D matrix)
1266 {
1267 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1268
1269 TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
1270
1271 switch (type)
1272 {
1273 case D3DRMCOMBINE_REPLACE:
1274 memcpy(&This->transform[0][0], &matrix[0][0], sizeof(D3DRMMATRIX4D));
1275 break;
1276
1277 case D3DRMCOMBINE_BEFORE:
1278 FIXME("D3DRMCOMBINE_BEFORE not supported yed\n");
1279 break;
1280
1281 case D3DRMCOMBINE_AFTER:
1282 FIXME("D3DRMCOMBINE_AFTER not supported yed\n");
1283 break;
1284
1285 default:
1286 WARN("Unknown Combine Type %u\n", type);
1287 return D3DRMERR_BADVALUE;
1288 }
1289
1290 return S_OK;
1291 }
1292
1293 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTranslation(IDirect3DRMFrame3* iface,
1294 D3DRMCOMBINETYPE type,
1295 D3DVALUE x, D3DVALUE y, D3DVALUE z)
1296 {
1297 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1298
1299 FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
1300
1301 return E_NOTIMPL;
1302 }
1303
1304 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddScale(IDirect3DRMFrame3* iface,
1305 D3DRMCOMBINETYPE type,
1306 D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1307 {
1308 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1309
1310 FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
1311
1312 return E_NOTIMPL;
1313 }
1314
1315 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddRotation(IDirect3DRMFrame3* iface,
1316 D3DRMCOMBINETYPE type,
1317 D3DVALUE x, D3DVALUE y, D3DVALUE z,
1318 D3DVALUE theta)
1319 {
1320 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1321
1322 FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
1323
1324 return E_NOTIMPL;
1325 }
1326
1327 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
1328 {
1329 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1330 ULONG i;
1331 IDirect3DRMVisual** visuals;
1332
1333 TRACE("(%p/%p)->(%p)\n", iface, This, vis);
1334
1335 if (!vis)
1336 return D3DRMERR_BADOBJECT;
1337
1338 /* Check if already existing and return gracefully without increasing ref count */
1339 for (i = 0; i < This->nb_visuals; i++)
1340 if (This->visuals[i] == (IDirect3DRMVisual*)vis)
1341 return D3DRM_OK;
1342
1343 if ((This->nb_visuals + 1) > This->visuals_capacity)
1344 {
1345 ULONG new_capacity;
1346
1347 if (!This->visuals_capacity)
1348 {
1349 new_capacity = 16;
1350 visuals = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMVisual*));
1351 }
1352 else
1353 {
1354 new_capacity = This->visuals_capacity * 2;
1355 visuals = HeapReAlloc(GetProcessHeap(), 0, This->visuals, new_capacity * sizeof(IDirect3DRMVisual*));
1356 }
1357
1358 if (!visuals)
1359 return E_OUTOFMEMORY;
1360
1361 This->visuals_capacity = new_capacity;
1362 This->visuals = visuals;
1363 }
1364
1365 This->visuals[This->nb_visuals++] = (IDirect3DRMVisual*)vis;
1366 IDirect3DRMVisual_AddRef(vis);
1367
1368 return D3DRM_OK;
1369 }
1370
1371 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetChildren(IDirect3DRMFrame3* iface,
1372 LPDIRECT3DRMFRAMEARRAY *children)
1373 {
1374 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1375 IDirect3DRMFrameArrayImpl* obj;
1376 HRESULT hr;
1377
1378 TRACE("(%p/%p)->(%p)\n", iface, This, children);
1379
1380 if (!children)
1381 return D3DRMERR_BADVALUE;
1382
1383 hr = Direct3DRMFrameArray_create(children);
1384
1385 if (hr != D3DRM_OK)
1386 return hr;
1387
1388 obj = (IDirect3DRMFrameArrayImpl*)*children;
1389
1390 obj->size = This->nb_children;
1391 if (This->nb_children)
1392 {
1393 ULONG i;
1394 obj->frames = HeapAlloc(GetProcessHeap(), 0, This->nb_children * sizeof(LPDIRECT3DRMFRAME));
1395 if (!obj->frames)
1396 return E_OUTOFMEMORY;
1397 for (i = 0; i < This->nb_children; i++)
1398 IDirect3DRMFrame3_QueryInterface(This->children[i], &IID_IDirect3DRMFrame, (void**)&obj->frames[i]);
1399 }
1400
1401 return D3DRM_OK;
1402 }
1403
1404 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetColor(IDirect3DRMFrame3* iface)
1405 {
1406 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1407
1408 FIXME("(%p/%p)->(): stub\n", iface, This);
1409
1410 return 0;
1411 }
1412
1413 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetLights(IDirect3DRMFrame3* iface,
1414 LPDIRECT3DRMLIGHTARRAY *lights)
1415 {
1416 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1417 IDirect3DRMLightArrayImpl* obj;
1418 HRESULT hr;
1419
1420 TRACE("(%p/%p)->(%p)\n", iface, This, lights);
1421
1422 if (!lights)
1423 return D3DRMERR_BADVALUE;
1424
1425 hr = Direct3DRMLightArray_create(lights);
1426
1427 if (hr != D3DRM_OK)
1428 return hr;
1429
1430 obj = (IDirect3DRMLightArrayImpl*)*lights;
1431
1432 obj->size = This->nb_lights;
1433 if (This->nb_lights)
1434 {
1435 ULONG i;
1436 obj->lights = HeapAlloc(GetProcessHeap(), 0, This->nb_lights * sizeof(LPDIRECT3DRMLIGHT));
1437 if (!obj->lights)
1438 return E_OUTOFMEMORY;
1439 for (i = 0; i < This->nb_lights; i++)
1440 IDirect3DRMLight_QueryInterface(This->lights[i], &IID_IDirect3DRMLight, (void**)&obj->lights[i]);
1441 }
1442
1443 return D3DRM_OK;
1444 }
1445
1446 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame3Impl_GetMaterialMode(IDirect3DRMFrame3* iface)
1447 {
1448 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1449
1450 FIXME("(%p/%p)->(): stub\n", iface, This);
1451
1452 return D3DRMMATERIAL_FROMPARENT;
1453 }
1454
1455 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetParent(IDirect3DRMFrame3* iface,
1456 LPDIRECT3DRMFRAME3 * frame)
1457 {
1458 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1459
1460 TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1461
1462 if (!frame)
1463 return D3DRMERR_BADVALUE;
1464
1465 if (This->parent)
1466 {
1467 *frame = &This->parent->IDirect3DRMFrame3_iface;
1468 IDirect3DRMFrame_AddRef(*frame);
1469 }
1470 else
1471 {
1472 *frame = NULL;
1473 }
1474
1475 return D3DRM_OK;
1476 }
1477
1478 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetPosition(IDirect3DRMFrame3* iface,
1479 LPDIRECT3DRMFRAME3 reference,
1480 LPD3DVECTOR return_position)
1481 {
1482 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1483
1484 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
1485
1486 return E_NOTIMPL;
1487 }
1488
1489 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetRotation(IDirect3DRMFrame3* iface,
1490 LPDIRECT3DRMFRAME3 reference,
1491 LPD3DVECTOR axis, LPD3DVALUE return_theta)
1492 {
1493 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1494
1495 FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
1496
1497 return E_NOTIMPL;
1498 }
1499
1500 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetScene(IDirect3DRMFrame3* iface,
1501 LPDIRECT3DRMFRAME3 * frame)
1502 {
1503 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1504
1505 FIXME("(%p/%p)->(%p): stub\n", iface, This, frame);
1506
1507 return E_NOTIMPL;
1508 }
1509
1510 static D3DRMSORTMODE WINAPI IDirect3DRMFrame3Impl_GetSortMode(IDirect3DRMFrame3* iface)
1511 {
1512 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1513
1514 FIXME("(%p/%p)->(): stub\n", iface, This);
1515
1516 return D3DRMSORT_FROMPARENT;
1517 }
1518
1519 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTexture(IDirect3DRMFrame3* iface,
1520 LPDIRECT3DRMTEXTURE3 * tex)
1521 {
1522 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1523
1524 FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
1525
1526 return E_NOTIMPL;
1527 }
1528
1529 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTransform(IDirect3DRMFrame3* iface,
1530 LPDIRECT3DRMFRAME3 reference,
1531 D3DRMMATRIX4D return_matrix)
1532 {
1533 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1534
1535 TRACE("(%p/%p)->(%p,%p)\n", iface, This, reference, return_matrix);
1536
1537 if (reference)
1538 FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1539
1540 memcpy(&return_matrix[0][0], &This->transform[0][0], sizeof(D3DRMMATRIX4D));
1541
1542 return D3DRM_OK;
1543 }
1544
1545 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVelocity(IDirect3DRMFrame3* iface,
1546 LPDIRECT3DRMFRAME3 reference,
1547 LPD3DVECTOR return_velocity,
1548 BOOL with_rotation)
1549 {
1550 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1551
1552 FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
1553
1554 return E_NOTIMPL;
1555 }
1556
1557 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetOrientation(IDirect3DRMFrame3* iface,
1558 LPDIRECT3DRMFRAME3 reference,
1559 LPD3DVECTOR dir, LPD3DVECTOR up)
1560 {
1561 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1562
1563 FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, dir, up);
1564
1565 return E_NOTIMPL;
1566 }
1567
1568 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVisuals(IDirect3DRMFrame3* iface, LPDWORD num,
1569 LPUNKNOWN *visuals)
1570 {
1571 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1572
1573 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, num, visuals);
1574
1575 return E_NOTIMPL;
1576 }
1577
1578 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransform(IDirect3DRMFrame3* iface,
1579 D3DVECTOR *d, D3DVECTOR *s)
1580 {
1581 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1582
1583 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1584
1585 return E_NOTIMPL;
1586 }
1587
1588 static HRESULT WINAPI IDirect3DRMFrame3Impl_Load(IDirect3DRMFrame3* iface, LPVOID filename,
1589 LPVOID name, D3DRMLOADOPTIONS loadflags,
1590 D3DRMLOADTEXTURE3CALLBACK cb, LPVOID lpArg)
1591 {
1592 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1593
1594 FIXME("(%p/%p)->(%p,%p,%u,%p,%p): stub\n", iface, This, filename, name, loadflags, cb, lpArg);
1595
1596 return E_NOTIMPL;
1597 }
1598
1599 static HRESULT WINAPI IDirect3DRMFrame3Impl_LookAt(IDirect3DRMFrame3* iface,
1600 LPDIRECT3DRMFRAME3 target,
1601 LPDIRECT3DRMFRAME3 reference,
1602 D3DRMFRAMECONSTRAINT constraint)
1603 {
1604 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1605
1606 FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, target, reference, constraint);
1607
1608 return E_NOTIMPL;
1609 }
1610
1611 static HRESULT WINAPI IDirect3DRMFrame3Impl_Move(IDirect3DRMFrame3* iface, D3DVALUE delta)
1612 {
1613 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1614
1615 FIXME("(%p/%p)->(%f): stub\n", iface, This, delta);
1616
1617 return E_NOTIMPL;
1618 }
1619
1620 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteChild(IDirect3DRMFrame3* iface,
1621 LPDIRECT3DRMFRAME3 frame)
1622 {
1623 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1624 IDirect3DRMFrameImpl *frame_obj = unsafe_impl_from_IDirect3DRMFrame3(frame);
1625 ULONG i;
1626
1627 TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1628
1629 if (!frame_obj)
1630 return D3DRMERR_BADOBJECT;
1631
1632 /* Check if child exists */
1633 for (i = 0; i < This->nb_children; i++)
1634 if (This->children[i] == frame)
1635 break;
1636
1637 if (i == This->nb_children)
1638 return D3DRMERR_BADVALUE;
1639
1640 memmove(This->children + i, This->children + i + 1, sizeof(IDirect3DRMFrame3*) * (This->nb_children - 1 - i));
1641 IDirect3DRMFrame3_Release(frame);
1642 frame_obj->parent = NULL;
1643 This->nb_children--;
1644
1645 return D3DRM_OK;
1646 }
1647
1648 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteLight(IDirect3DRMFrame3* iface,
1649 LPDIRECT3DRMLIGHT light)
1650 {
1651 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1652 ULONG i;
1653
1654 TRACE("(%p/%p)->(%p)\n", iface, This, light);
1655
1656 if (!light)
1657 return D3DRMERR_BADOBJECT;
1658
1659 /* Check if visual exists */
1660 for (i = 0; i < This->nb_lights; i++)
1661 if (This->lights[i] == light)
1662 break;
1663
1664 if (i == This->nb_lights)
1665 return D3DRMERR_BADVALUE;
1666
1667 memmove(This->lights + i, This->lights + i + 1, sizeof(IDirect3DRMLight*) * (This->nb_lights - 1 - i));
1668 IDirect3DRMLight_Release(light);
1669 This->nb_lights--;
1670
1671 return D3DRM_OK;
1672 }
1673
1674 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteMoveCallback(IDirect3DRMFrame3* iface,
1675 D3DRMFRAME3MOVECALLBACK cb,
1676 VOID *arg)
1677 {
1678 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1679
1680 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
1681
1682 return E_NOTIMPL;
1683 }
1684
1685 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
1686 {
1687 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1688 ULONG i;
1689
1690 TRACE("(%p/%p)->(%p)\n", iface, This, vis);
1691
1692 if (!vis)
1693 return D3DRMERR_BADOBJECT;
1694
1695 /* Check if visual exists */
1696 for (i = 0; i < This->nb_visuals; i++)
1697 if (This->visuals[i] == (IDirect3DRMVisual*)vis)
1698 break;
1699
1700 if (i == This->nb_visuals)
1701 return D3DRMERR_BADVALUE;
1702
1703 memmove(This->visuals + i, This->visuals + i + 1, sizeof(IDirect3DRMVisual*) * (This->nb_visuals - 1 - i));
1704 IDirect3DRMVisual_Release(vis);
1705 This->nb_visuals--;
1706
1707 return D3DRM_OK;
1708 }
1709
1710 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneBackground(IDirect3DRMFrame3* iface)
1711 {
1712 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1713
1714 FIXME("(%p/%p)->(): stub\n", iface, This);
1715
1716 return 0;
1717 }
1718
1719 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneBackgroundDepth(IDirect3DRMFrame3* iface,
1720 LPDIRECTDRAWSURFACE * surface)
1721 {
1722 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1723
1724 FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
1725
1726 return E_NOTIMPL;
1727 }
1728
1729 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneFogColor(IDirect3DRMFrame3* iface)
1730 {
1731 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1732
1733 FIXME("(%p/%p)->(): stub\n", iface, This);
1734
1735 return 0;
1736 }
1737
1738 static BOOL WINAPI IDirect3DRMFrame3Impl_GetSceneFogEnable(IDirect3DRMFrame3* iface)
1739 {
1740 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1741
1742 FIXME("(%p/%p)->(): stub\n", iface, This);
1743
1744 return FALSE;
1745 }
1746
1747 static D3DRMFOGMODE WINAPI IDirect3DRMFrame3Impl_GetSceneFogMode(IDirect3DRMFrame3* iface)
1748 {
1749 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1750
1751 FIXME("(%p/%p)->(): stub\n", iface, This);
1752
1753 return D3DRMFOG_LINEAR;
1754 }
1755
1756 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogParams(IDirect3DRMFrame3* iface,
1757 D3DVALUE *return_start,
1758 D3DVALUE *return_end,
1759 D3DVALUE *return_density)
1760 {
1761 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1762
1763 FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
1764
1765 return E_NOTIMPL;
1766 }
1767
1768 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackground(IDirect3DRMFrame3* iface,
1769 D3DCOLOR color)
1770 {
1771 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1772
1773 FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1774
1775 return E_NOTIMPL;
1776 }
1777
1778 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundRGB(IDirect3DRMFrame3* iface,
1779 D3DVALUE red, D3DVALUE green,
1780 D3DVALUE blue)
1781 {
1782 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1783
1784 FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
1785
1786 return E_NOTIMPL;
1787 }
1788
1789 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundDepth(IDirect3DRMFrame3* iface,
1790 LPDIRECTDRAWSURFACE surface)
1791 {
1792 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1793
1794 FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
1795
1796 return E_NOTIMPL;
1797 }
1798
1799 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundImage(IDirect3DRMFrame3* iface,
1800 LPDIRECT3DRMTEXTURE3 texture)
1801 {
1802 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1803
1804 FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1805
1806 return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogEnable(IDirect3DRMFrame3* iface, BOOL enable)
1810 {
1811 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1812
1813 FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
1814
1815 return E_NOTIMPL;
1816 }
1817
1818 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogColor(IDirect3DRMFrame3* iface,
1819 D3DCOLOR color)
1820 {
1821 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1822
1823 FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1824
1825 return E_NOTIMPL;
1826 }
1827
1828 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMode(IDirect3DRMFrame3* iface,
1829 D3DRMFOGMODE mode)
1830 {
1831 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1832
1833 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1834
1835 return E_NOTIMPL;
1836 }
1837
1838 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogParams(IDirect3DRMFrame3* iface,
1839 D3DVALUE start, D3DVALUE end,
1840 D3DVALUE density)
1841 {
1842 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1843
1844 FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
1845
1846 return E_NOTIMPL;
1847 }
1848
1849 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColor(IDirect3DRMFrame3* iface, D3DCOLOR color)
1850 {
1851 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1852
1853 FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1854
1855 return E_NOTIMPL;
1856 }
1857
1858 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColorRGB(IDirect3DRMFrame3* iface, D3DVALUE red,
1859 D3DVALUE green, D3DVALUE blue)
1860 {
1861 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1862
1863 FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
1864
1865 return E_NOTIMPL;
1866 }
1867
1868 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame3Impl_GetZbufferMode(IDirect3DRMFrame3* iface)
1869 {
1870 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1871
1872 FIXME("(%p/%p)->(): stub\n", iface, This);
1873
1874 return D3DRMZBUFFER_FROMPARENT;
1875 }
1876
1877 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialMode(IDirect3DRMFrame3* iface,
1878 D3DRMMATERIALMODE mode)
1879 {
1880 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1881
1882 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1883
1884 return E_NOTIMPL;
1885 }
1886
1887 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetOrientation(IDirect3DRMFrame3* iface,
1888 LPDIRECT3DRMFRAME3 reference,
1889 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
1890 D3DVALUE ux, D3DVALUE uy, D3DVALUE uz )
1891 {
1892 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1893
1894 FIXME("(%p/%p)->(%p,%f,%f,%f,%f,%f,%f): stub\n", iface, This, reference,
1895 dx, dy, dz, ux, uy, uz);
1896
1897 return E_NOTIMPL;
1898 }
1899
1900 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetPosition(IDirect3DRMFrame3* iface,
1901 LPDIRECT3DRMFRAME3 reference,
1902 D3DVALUE x, D3DVALUE y, D3DVALUE z)
1903 {
1904 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1905
1906 FIXME("(%p/%p)->(%p,%f,%f,%f): stub\n", iface, This, reference, x, y, z);
1907
1908 return E_NOTIMPL;
1909 }
1910
1911 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetRotation(IDirect3DRMFrame3* iface,
1912 LPDIRECT3DRMFRAME3 reference,
1913 D3DVALUE x, D3DVALUE y, D3DVALUE z,
1914 D3DVALUE theta)
1915 {
1916 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1917
1918 FIXME("(%p/%p)->(%p,%f,%f,%f,%f): stub\n", iface, This, reference, x, y, z, theta);
1919
1920 return E_NOTIMPL;
1921 }
1922
1923 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSortMode(IDirect3DRMFrame3* iface,
1924 D3DRMSORTMODE mode)
1925 {
1926 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1927
1928 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1929
1930 return E_NOTIMPL;
1931 }
1932
1933 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTexture(IDirect3DRMFrame3* iface,
1934 LPDIRECT3DRMTEXTURE3 texture)
1935 {
1936 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1937
1938 FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1939
1940 return E_NOTIMPL;
1941 }
1942
1943 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetVelocity(IDirect3DRMFrame3* iface,
1944 LPDIRECT3DRMFRAME3 reference,
1945 D3DVALUE x, D3DVALUE y, D3DVALUE z,
1946 BOOL with_rotation)
1947 {
1948 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1949
1950 FIXME("(%p/%p)->(%p,%f,%f,%f,%d): stub\n", iface, This, reference, x, y, z, with_rotation);
1951
1952 return E_NOTIMPL;
1953 }
1954
1955 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetZbufferMode(IDirect3DRMFrame3* iface,
1956 D3DRMZBUFFERMODE mode)
1957 {
1958 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1959
1960 FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1961
1962 return E_NOTIMPL;
1963 }
1964
1965 static HRESULT WINAPI IDirect3DRMFrame3Impl_Transform(IDirect3DRMFrame3* iface, D3DVECTOR *d,
1966 D3DVECTOR *s)
1967 {
1968 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1969
1970 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1971
1972 return E_NOTIMPL;
1973 }
1974
1975 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetBox(IDirect3DRMFrame3* iface, LPD3DRMBOX box)
1976 {
1977 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1978
1979 FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
1980
1981 return E_NOTIMPL;
1982 }
1983
1984 static BOOL WINAPI IDirect3DRMFrame3Impl_GetBoxEnable(IDirect3DRMFrame3* iface)
1985 {
1986 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1987
1988 FIXME("(%p/%p)->(): stub\n", iface, This);
1989
1990 return E_NOTIMPL;
1991 }
1992
1993 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetAxes(IDirect3DRMFrame3* iface,
1994 LPD3DVECTOR dir, LPD3DVECTOR up)
1995 {
1996 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1997
1998 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
1999
2000 return E_NOTIMPL;
2001 }
2002
2003 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterial(IDirect3DRMFrame3* iface,
2004 LPDIRECT3DRMMATERIAL2 *material)
2005 {
2006 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2007
2008 FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2009
2010 return E_NOTIMPL;
2011 }
2012
2013 static BOOL WINAPI IDirect3DRMFrame3Impl_GetInheritAxes(IDirect3DRMFrame3* iface)
2014 {
2015 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2016
2017 FIXME("(%p/%p)->(): stub\n", iface, This);
2018
2019 return E_NOTIMPL;
2020 }
2021
2022 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetHierarchyBox(IDirect3DRMFrame3* iface,
2023 LPD3DRMBOX box)
2024 {
2025 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2026
2027 FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2028
2029 return E_NOTIMPL;
2030 }
2031
2032 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBox(IDirect3DRMFrame3* iface, LPD3DRMBOX box)
2033 {
2034 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2035
2036 FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2037
2038 return E_NOTIMPL;
2039 }
2040
2041 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBoxEnable(IDirect3DRMFrame3* iface, BOOL enable)
2042 {
2043 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2044
2045 FIXME("(%p/%p)->(%u): stub\n", iface, This, enable);
2046
2047 return E_NOTIMPL;
2048 }
2049
2050 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAxes(IDirect3DRMFrame3* iface,
2051 D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
2052 D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2053 {
2054 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2055
2056 FIXME("(%p/%p)->(%f,%f,%f,%f,%f,%f): stub\n", iface, This, dx, dy, dz, ux, uy, uz);
2057
2058 return E_NOTIMPL;
2059 }
2060
2061 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetInheritAxes(IDirect3DRMFrame3* iface,
2062 BOOL inherit_from_parent)
2063 {
2064 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2065
2066 FIXME("(%p/%p)->(%u): stub\n", iface, This, inherit_from_parent);
2067
2068 return E_NOTIMPL;
2069 }
2070
2071 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterial(IDirect3DRMFrame3* iface,
2072 LPDIRECT3DRMMATERIAL2 material)
2073 {
2074 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2075
2076 FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2077
2078 return E_NOTIMPL;
2079 }
2080
2081 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetQuaternion(IDirect3DRMFrame3* iface,
2082 LPDIRECT3DRMFRAME3 reference,
2083 D3DRMQUATERNION *q)
2084 {
2085 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2086
2087 FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, q);
2088
2089 return E_NOTIMPL;
2090 }
2091
2092 static HRESULT WINAPI IDirect3DRMFrame3Impl_RayPick(IDirect3DRMFrame3* iface,
2093 LPDIRECT3DRMFRAME3 reference, LPD3DRMRAY ray,
2094 DWORD flags,
2095 LPDIRECT3DRMPICKED2ARRAY *return_visuals)
2096 {
2097 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2098
2099 FIXME("(%p/%p)->(%p,%p,%u,%p): stub\n", iface, This, reference, ray, flags, return_visuals);
2100
2101 return E_NOTIMPL;
2102 }
2103
2104 static HRESULT WINAPI IDirect3DRMFrame3Impl_Save(IDirect3DRMFrame3* iface, LPCSTR filename,
2105 D3DRMXOFFORMAT d3dFormat,
2106 D3DRMSAVEOPTIONS d3dSaveFlags)
2107 {
2108 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2109
2110 FIXME("(%p/%p)->(%p,%u,%u): stub\n", iface, This, filename, d3dFormat, d3dSaveFlags);
2111
2112 return E_NOTIMPL;
2113 }
2114
2115 static HRESULT WINAPI IDirect3DRMFrame3Impl_TransformVectors(IDirect3DRMFrame3* iface,
2116 LPDIRECT3DRMFRAME3 reference,
2117 DWORD num, LPD3DVECTOR dst,
2118 LPD3DVECTOR src)
2119 {
2120 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2121
2122 FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2123
2124 return E_NOTIMPL;
2125 }
2126
2127 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransformVectors(IDirect3DRMFrame3* iface,
2128 LPDIRECT3DRMFRAME3 reference,
2129 DWORD num, LPD3DVECTOR dst,
2130 LPD3DVECTOR src)
2131 {
2132 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2133
2134 FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2135
2136 return E_NOTIMPL;
2137 }
2138
2139 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTraversalOptions(IDirect3DRMFrame3* iface,
2140 DWORD flags)
2141 {
2142 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2143
2144 FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2145
2146 return E_NOTIMPL;
2147 }
2148
2149 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTraversalOptions(IDirect3DRMFrame3* iface,
2150 LPDWORD flags)
2151 {
2152 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2153
2154 FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2155
2156 return E_NOTIMPL;
2157 }
2158
2159 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMethod(IDirect3DRMFrame3* iface,
2160 DWORD flags)
2161 {
2162 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2163
2164 FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2165
2166 return E_NOTIMPL;
2167 }
2168
2169 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogMethod(IDirect3DRMFrame3* iface,
2170 LPDWORD flags)
2171 {
2172 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2173
2174 FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2175
2176 return E_NOTIMPL;
2177 }
2178
2179 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialOverride(IDirect3DRMFrame3* iface,
2180 LPD3DRMMATERIALOVERRIDE override)
2181 {
2182 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2183
2184 FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2185
2186 return E_NOTIMPL;
2187 }
2188
2189 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterialOverride(IDirect3DRMFrame3* iface,
2190 LPD3DRMMATERIALOVERRIDE override)
2191 {
2192 IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2193
2194 FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2195
2196 return E_NOTIMPL;
2197 }
2198
2199 static const struct IDirect3DRMFrame3Vtbl Direct3DRMFrame3_Vtbl =
2200 {
2201 /*** IUnknown methods ***/
2202 IDirect3DRMFrame3Impl_QueryInterface,
2203 IDirect3DRMFrame3Impl_AddRef,
2204 IDirect3DRMFrame3Impl_Release,
2205 /*** IDirect3DRMObject methods ***/
2206 IDirect3DRMFrame3Impl_Clone,
2207 IDirect3DRMFrame3Impl_AddDestroyCallback,
2208 IDirect3DRMFrame3Impl_DeleteDestroyCallback,
2209 IDirect3DRMFrame3Impl_SetAppData,
2210 IDirect3DRMFrame3Impl_GetAppData,
2211 IDirect3DRMFrame3Impl_SetName,
2212 IDirect3DRMFrame3Impl_GetName,
2213 IDirect3DRMFrame3Impl_GetClassName,
2214 /*** IDirect3DRMFrame3 methods ***/
2215 IDirect3DRMFrame3Impl_AddChild,
2216 IDirect3DRMFrame3Impl_AddLight,
2217 IDirect3DRMFrame3Impl_AddMoveCallback,
2218 IDirect3DRMFrame3Impl_AddTransform,
2219 IDirect3DRMFrame3Impl_AddTranslation,
2220 IDirect3DRMFrame3Impl_AddScale,
2221 IDirect3DRMFrame3Impl_AddRotation,
2222 IDirect3DRMFrame3Impl_AddVisual,
2223 IDirect3DRMFrame3Impl_GetChildren,
2224 IDirect3DRMFrame3Impl_GetColor,
2225 IDirect3DRMFrame3Impl_GetLights,
2226 IDirect3DRMFrame3Impl_GetMaterialMode,
2227 IDirect3DRMFrame3Impl_GetParent,
2228 IDirect3DRMFrame3Impl_GetPosition,
2229 IDirect3DRMFrame3Impl_GetRotation,
2230 IDirect3DRMFrame3Impl_GetScene,
2231 IDirect3DRMFrame3Impl_GetSortMode,
2232 IDirect3DRMFrame3Impl_GetTexture,
2233 IDirect3DRMFrame3Impl_GetTransform,
2234 IDirect3DRMFrame3Impl_GetVelocity,
2235 IDirect3DRMFrame3Impl_GetOrientation,
2236 IDirect3DRMFrame3Impl_GetVisuals,
2237 IDirect3DRMFrame3Impl_InverseTransform,
2238 IDirect3DRMFrame3Impl_Load,
2239 IDirect3DRMFrame3Impl_LookAt,
2240 IDirect3DRMFrame3Impl_Move,
2241 IDirect3DRMFrame3Impl_DeleteChild,
2242 IDirect3DRMFrame3Impl_DeleteLight,
2243 IDirect3DRMFrame3Impl_DeleteMoveCallback,
2244 IDirect3DRMFrame3Impl_DeleteVisual,
2245 IDirect3DRMFrame3Impl_GetSceneBackground,
2246 IDirect3DRMFrame3Impl_GetSceneBackgroundDepth,
2247 IDirect3DRMFrame3Impl_GetSceneFogColor,
2248 IDirect3DRMFrame3Impl_GetSceneFogEnable,
2249 IDirect3DRMFrame3Impl_GetSceneFogMode,
2250 IDirect3DRMFrame3Impl_GetSceneFogParams,
2251 IDirect3DRMFrame3Impl_SetSceneBackground,
2252 IDirect3DRMFrame3Impl_SetSceneBackgroundRGB,
2253 IDirect3DRMFrame3Impl_SetSceneBackgroundDepth,
2254 IDirect3DRMFrame3Impl_SetSceneBackgroundImage,
2255 IDirect3DRMFrame3Impl_SetSceneFogEnable,
2256 IDirect3DRMFrame3Impl_SetSceneFogColor,
2257 IDirect3DRMFrame3Impl_SetSceneFogMode,
2258 IDirect3DRMFrame3Impl_SetSceneFogParams,
2259 IDirect3DRMFrame3Impl_SetColor,
2260 IDirect3DRMFrame3Impl_SetColorRGB,
2261 IDirect3DRMFrame3Impl_GetZbufferMode,
2262 IDirect3DRMFrame3Impl_SetMaterialMode,
2263 IDirect3DRMFrame3Impl_SetOrientation,
2264 IDirect3DRMFrame3Impl_SetPosition,
2265 IDirect3DRMFrame3Impl_SetRotation,
2266 IDirect3DRMFrame3Impl_SetSortMode,
2267 IDirect3DRMFrame3Impl_SetTexture,
2268 IDirect3DRMFrame3Impl_SetVelocity,
2269 IDirect3DRMFrame3Impl_SetZbufferMode,
2270 IDirect3DRMFrame3Impl_Transform,
2271 IDirect3DRMFrame3Impl_GetBox,
2272 IDirect3DRMFrame3Impl_GetBoxEnable,
2273 IDirect3DRMFrame3Impl_GetAxes,
2274 IDirect3DRMFrame3Impl_GetMaterial,
2275 IDirect3DRMFrame3Impl_GetInheritAxes,
2276 IDirect3DRMFrame3Impl_GetHierarchyBox,
2277 IDirect3DRMFrame3Impl_SetBox,
2278 IDirect3DRMFrame3Impl_SetBoxEnable,
2279 IDirect3DRMFrame3Impl_SetAxes,
2280 IDirect3DRMFrame3Impl_SetInheritAxes,
2281 IDirect3DRMFrame3Impl_SetMaterial,
2282 IDirect3DRMFrame3Impl_SetQuaternion,
2283 IDirect3DRMFrame3Impl_RayPick,
2284 IDirect3DRMFrame3Impl_Save,
2285 IDirect3DRMFrame3Impl_TransformVectors,
2286 IDirect3DRMFrame3Impl_InverseTransformVectors,
2287 IDirect3DRMFrame3Impl_SetTraversalOptions,
2288 IDirect3DRMFrame3Impl_GetTraversalOptions,
2289 IDirect3DRMFrame3Impl_SetSceneFogMethod,
2290 IDirect3DRMFrame3Impl_GetSceneFogMethod,
2291 IDirect3DRMFrame3Impl_SetMaterialOverride,
2292 IDirect3DRMFrame3Impl_GetMaterialOverride
2293 };
2294
2295 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
2296 {
2297 if (!iface)
2298 return NULL;
2299 assert(iface->lpVtbl == &Direct3DRMFrame2_Vtbl);
2300
2301 return impl_from_IDirect3DRMFrame2(iface);
2302 }
2303
2304 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2305 {
2306 if (!iface)
2307 return NULL;
2308 assert(iface->lpVtbl == &Direct3DRMFrame3_Vtbl);
2309
2310 return impl_from_IDirect3DRMFrame3(iface);
2311 }
2312
2313 HRESULT Direct3DRMFrame_create(REFIID riid, IUnknown* parent, IUnknown** ret_iface)
2314 {
2315 IDirect3DRMFrameImpl* object;
2316
2317 TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), parent, ret_iface);
2318
2319 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMFrameImpl));
2320 if (!object)
2321 {
2322 ERR("Out of memory\n");
2323 return E_OUTOFMEMORY;
2324 }
2325
2326 object->IDirect3DRMFrame2_iface.lpVtbl = &Direct3DRMFrame2_Vtbl;
2327 object->IDirect3DRMFrame3_iface.lpVtbl = &Direct3DRMFrame3_Vtbl;
2328 object->ref = 1;
2329
2330 memcpy(&object->transform[0][0], &identity[0][0], sizeof(D3DRMMATRIX4D));
2331
2332 if (IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
2333 {
2334 if (parent)
2335 IDirect3DRMFrame3_AddChild((IDirect3DRMFrame3*)parent, &object->IDirect3DRMFrame3_iface);
2336 *ret_iface = (IUnknown*)&object->IDirect3DRMFrame3_iface;
2337 }
2338 else
2339 {
2340 if (parent)
2341 IDirect3DRMFrame2_AddChild((IDirect3DRMFrame2*)parent, (IDirect3DRMFrame*)&object->IDirect3DRMFrame2_iface);
2342 *ret_iface = (IUnknown*)&object->IDirect3DRMFrame2_iface;
2343 }
2344
2345 return S_OK;
2346 }
2347
2348 /*** IUnknown methods ***/
2349 static HRESULT WINAPI IDirect3DRMFrameArrayImpl_QueryInterface(IDirect3DRMFrameArray* iface,
2350 REFIID riid, void** object)
2351 {
2352 IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2353
2354 TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
2355
2356 *object = NULL;
2357
2358 if (IsEqualGUID(riid, &IID_IUnknown) ||
2359 IsEqualGUID(riid, &IID_IDirect3DRMFrameArray))
2360 {
2361 *object = &This->IDirect3DRMFrameArray_iface;
2362 }
2363 else
2364 {
2365 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2366 return E_NOINTERFACE;
2367 }
2368
2369 IDirect3DRMFrameArray_AddRef(iface);
2370 return S_OK;
2371 }
2372
2373 static ULONG WINAPI IDirect3DRMFrameArrayImpl_AddRef(IDirect3DRMFrameArray* iface)
2374 {
2375 IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2376 ULONG ref = InterlockedIncrement(&This->ref);
2377
2378 TRACE("(%p)->(): new ref = %u\n", This, ref);
2379
2380 return ref;
2381 }
2382
2383 static ULONG WINAPI IDirect3DRMFrameArrayImpl_Release(IDirect3DRMFrameArray* iface)
2384 {
2385 IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2386 ULONG ref = InterlockedDecrement(&This->ref);
2387 ULONG i;
2388
2389 TRACE("(%p)->(): new ref = %u\n", This, ref);
2390
2391 if (!ref)
2392 {
2393 for (i = 0; i < This->size; i++)
2394 IDirect3DRMFrame_Release(This->frames[i]);
2395 HeapFree(GetProcessHeap(), 0, This->frames);
2396 HeapFree(GetProcessHeap(), 0, This);
2397 }
2398
2399 return ref;
2400 }
2401
2402 /*** IDirect3DRMArray methods ***/
2403 static DWORD WINAPI IDirect3DRMFrameArrayImpl_GetSize(IDirect3DRMFrameArray* iface)
2404 {
2405 IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2406
2407 TRACE("(%p)->() = %d\n", This, This->size);
2408
2409 return This->size;
2410 }
2411
2412 /*** IDirect3DRMFrameArray methods ***/
2413 static HRESULT WINAPI IDirect3DRMFrameArrayImpl_GetElement(IDirect3DRMFrameArray* iface, DWORD index, LPDIRECT3DRMFRAME* frame)
2414 {
2415 IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2416
2417 TRACE("(%p)->(%u, %p)\n", This, index, frame);
2418
2419 if (!frame)
2420 return D3DRMERR_BADVALUE;
2421
2422 *frame = NULL;
2423
2424 if (index >= This->size)
2425 return D3DRMERR_BADVALUE;
2426
2427 IDirect3DRMFrame_AddRef(This->frames[index]);
2428 *frame = This->frames[index];
2429
2430 return D3DRM_OK;
2431 }
2432
2433 static const struct IDirect3DRMFrameArrayVtbl Direct3DRMFrameArray_Vtbl =
2434 {
2435 /*** IUnknown methods ***/
2436 IDirect3DRMFrameArrayImpl_QueryInterface,
2437 IDirect3DRMFrameArrayImpl_AddRef,
2438 IDirect3DRMFrameArrayImpl_Release,
2439 /*** IDirect3DRMArray methods ***/
2440 IDirect3DRMFrameArrayImpl_GetSize,
2441 /*** IDirect3DRMFrameArray methods ***/
2442 IDirect3DRMFrameArrayImpl_GetElement
2443 };
2444
2445 HRESULT Direct3DRMFrameArray_create(IDirect3DRMFrameArray** obj)
2446 {
2447 IDirect3DRMFrameArrayImpl* object;
2448
2449 TRACE("(%p)\n", obj);
2450
2451 *obj = NULL;
2452
2453 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMFrameArrayImpl));
2454 if (!object)
2455 {
2456 ERR("Out of memory\n");
2457 return E_OUTOFMEMORY;
2458 }
2459
2460 object->IDirect3DRMFrameArray_iface.lpVtbl = &Direct3DRMFrameArray_Vtbl;
2461 object->ref = 1;
2462
2463 *obj = &object->IDirect3DRMFrameArray_iface;
2464
2465 return S_OK;
2466 }
2467
2468 /*** IUnknown methods ***/
2469 static HRESULT WINAPI IDirect3DRMVisualArrayImpl_QueryInterface(IDirect3DRMVisualArray* iface,
2470 REFIID riid, void** ret_iface)
2471 {
2472 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
2473
2474 if (IsEqualGUID(riid, &IID_IUnknown) ||
2475 IsEqualGUID(riid, &IID_IDirect3DRMFrameArray))
2476 {
2477 *ret_iface = iface;
2478 IDirect3DRMVisualArray_AddRef(iface);
2479 return S_OK;
2480 }
2481
2482 *ret_iface = NULL;
2483
2484 WARN("Interface %s not implemented\n", debugstr_guid(riid));
2485
2486 return E_NOINTERFACE;
2487 }
2488
2489 static ULONG WINAPI IDirect3DRMVisualArrayImpl_AddRef(IDirect3DRMVisualArray* iface)
2490 {
2491 IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2492 ULONG ref = InterlockedIncrement(&This->ref);
2493
2494 TRACE("(%p)->(): new ref = %u\n", iface, ref);
2495
2496 return ref;
2497 }
2498
2499 static ULONG WINAPI IDirect3DRMVisualArrayImpl_Release(IDirect3DRMVisualArray* iface)
2500 {
2501 IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2502 ULONG ref = InterlockedDecrement(&This->ref);
2503 ULONG i;
2504
2505 TRACE("(%p)->(): new ref = %u\n", iface, ref);
2506
2507 if (!ref)
2508 {
2509 for (i = 0; i < This->size; i++)
2510 IDirect3DRMVisual_Release(This->visuals[i]);
2511 HeapFree(GetProcessHeap(), 0, This->visuals);
2512 HeapFree(GetProcessHeap(), 0, This);
2513 }
2514
2515 return ref;
2516 }
2517
2518 /*** IDirect3DRMArray methods ***/
2519 static DWORD WINAPI IDirect3DRMVisualArrayImpl_GetSize(IDirect3DRMVisualArray* iface)
2520 {
2521 IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2522
2523 TRACE("(%p)->() = %d\n", iface, This->size);
2524
2525 return This->size;
2526 }
2527
2528 /*** IDirect3DRMVisualArray methods ***/
2529 static HRESULT WINAPI IDirect3DRMVisualArrayImpl_GetElement(IDirect3DRMVisualArray* iface, DWORD index, LPDIRECT3DRMVISUAL* visual)
2530 {
2531 IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2532
2533 TRACE("(%p)->(%u, %p)\n", iface, index, visual);
2534
2535 if (!visual)
2536 return D3DRMERR_BADVALUE;
2537
2538 *visual = NULL;
2539
2540 if (index >= This->size)
2541 return D3DRMERR_BADVALUE;
2542
2543 IDirect3DRMVisual_AddRef(This->visuals[index]);
2544 *visual = This->visuals[index];
2545
2546 return D3DRM_OK;
2547 }
2548
2549 static const struct IDirect3DRMVisualArrayVtbl Direct3DRMVisualArray_Vtbl =
2550 {
2551 /*** IUnknown methods ***/
2552 IDirect3DRMVisualArrayImpl_QueryInterface,
2553 IDirect3DRMVisualArrayImpl_AddRef,
2554 IDirect3DRMVisualArrayImpl_Release,
2555 /*** IDirect3DRMArray methods ***/
2556 IDirect3DRMVisualArrayImpl_GetSize,
2557 /*** IDirect3DRMVisualArray methods ***/
2558 IDirect3DRMVisualArrayImpl_GetElement
2559 };
2560
2561 HRESULT Direct3DRMVisualArray_create(IDirect3DRMVisualArray** ret_iface)
2562 {
2563 IDirect3DRMVisualArrayImpl* object;
2564
2565 TRACE("(%p)\n", ret_iface);
2566
2567 *ret_iface = NULL;
2568
2569 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMVisualArrayImpl));
2570 if (!object)
2571 {
2572 ERR("Out of memory\n");
2573 return E_OUTOFMEMORY;
2574 }
2575
2576 object->IDirect3DRMVisualArray_iface.lpVtbl = &Direct3DRMVisualArray_Vtbl;
2577 object->ref = 1;
2578
2579 *ret_iface = &object->IDirect3DRMVisualArray_iface;
2580
2581 return S_OK;
2582 }
2583
2584 /*** IUnknown methods ***/
2585 static HRESULT WINAPI IDirect3DRMLightArrayImpl_QueryInterface(IDirect3DRMLightArray* iface,
2586 REFIID riid, void** object)
2587 {
2588 IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2589
2590 TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
2591
2592 *object = NULL;
2593
2594 if (IsEqualGUID(riid, &IID_IUnknown) ||
2595 IsEqualGUID(riid, &IID_IDirect3DRMLightArray))
2596 {
2597 *object = &This->IDirect3DRMLightArray_iface;
2598 }
2599 else
2600 {
2601 FIXME("interface %s not implemented\n", debugstr_guid(riid));
2602 return E_NOINTERFACE;
2603 }
2604
2605 IDirect3DRMLightArray_AddRef(iface);
2606 return S_OK;
2607 }
2608
2609 static ULONG WINAPI IDirect3DRMLightArrayImpl_AddRef(IDirect3DRMLightArray* iface)
2610 {
2611 IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2612 ULONG ref = InterlockedIncrement(&This->ref);
2613
2614 TRACE("(%p)->(): new ref = %u\n", This, ref);
2615
2616 return ref;
2617 }
2618
2619 static ULONG WINAPI IDirect3DRMLightArrayImpl_Release(IDirect3DRMLightArray* iface)
2620 {
2621 IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2622 ULONG ref = InterlockedDecrement(&This->ref);
2623 ULONG i;
2624
2625 TRACE("(%p)->(): new ref = %u\n", This, ref);
2626
2627 if (!ref)
2628 {
2629 for (i = 0; i < This->size; i++)
2630 IDirect3DRMLight_Release(This->lights[i]);
2631 HeapFree(GetProcessHeap(), 0, This->lights);
2632 HeapFree(GetProcessHeap(), 0, This);
2633 }
2634
2635 return ref;
2636 }
2637
2638 /*** IDirect3DRMArray methods ***/
2639 static DWORD WINAPI IDirect3DRMLightArrayImpl_GetSize(IDirect3DRMLightArray* iface)
2640 {
2641 IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2642
2643 TRACE("(%p)->() = %d\n", This, This->size);
2644
2645 return This->size;
2646 }
2647
2648 /*** IDirect3DRMLightArray methods ***/
2649 static HRESULT WINAPI IDirect3DRMLightArrayImpl_GetElement(IDirect3DRMLightArray* iface, DWORD index, LPDIRECT3DRMLIGHT* light)
2650 {
2651 IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2652
2653 TRACE("(%p)->(%u, %p)\n", This, index, light);
2654
2655 if (!light)
2656 return D3DRMERR_BADVALUE;
2657
2658 *light = NULL;
2659
2660 if (index >= This->size)
2661 return D3DRMERR_BADVALUE;
2662
2663 IDirect3DRMLight_AddRef(This->lights[index]);
2664 *light = This->lights[index];
2665
2666 return D3DRM_OK;
2667 }
2668
2669 static const struct IDirect3DRMLightArrayVtbl Direct3DRMLightArray_Vtbl =
2670 {
2671 /*** IUnknown methods ***/
2672 IDirect3DRMLightArrayImpl_QueryInterface,
2673 IDirect3DRMLightArrayImpl_AddRef,
2674 IDirect3DRMLightArrayImpl_Release,
2675 /*** IDirect3DRMArray methods ***/
2676 IDirect3DRMLightArrayImpl_GetSize,
2677 /*** IDirect3DRMLightArray methods ***/
2678 IDirect3DRMLightArrayImpl_GetElement
2679 };
2680
2681 HRESULT Direct3DRMLightArray_create(IDirect3DRMLightArray** obj)
2682 {
2683 IDirect3DRMLightArrayImpl* object;
2684
2685 TRACE("(%p)\n", obj);
2686
2687 *obj = NULL;
2688
2689 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMLightArrayImpl));
2690 if (!object)
2691 {
2692 ERR("Out of memory\n");
2693 return E_OUTOFMEMORY;
2694 }
2695
2696 object->IDirect3DRMLightArray_iface.lpVtbl = &Direct3DRMLightArray_Vtbl;
2697 object->ref = 1;
2698
2699 *obj = &object->IDirect3DRMLightArray_iface;
2700
2701 return S_OK;
2702 }
Maarten's multimedia branch