VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/d3d9/texture.c@ 69496

Last change on this file since 69496 was 63024, checked in by vboxsync, 9 years ago

GA/NT/Graphics: warnings
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 44.5 KB
Line 
1/*
2 * Copyright 2002-2005 Jason Edmeades
3 * Copyright 2002-2005 Raphael Junqueira
4 * Copyright 2005 Oliver Stieber
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21/*
22 * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
23 * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
24 * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
25 * a choice of LGPL license versions is made available with the language indicating
26 * that LGPLv2 or any later version may be used, or where a choice of which version
27 * of the LGPL is applied is otherwise unspecified.
28 */
29
30#include "config.h"
31#include "d3d9_private.h"
32
33WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
34
35static inline struct d3d9_texture *impl_from_IDirect3DTexture9(IDirect3DTexture9 *iface)
36{
37 return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
38}
39
40static inline struct d3d9_texture *impl_from_IDirect3DCubeTexture9(IDirect3DCubeTexture9 *iface)
41{
42 return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
43}
44
45static inline struct d3d9_texture *impl_from_IDirect3DVolumeTexture9(IDirect3DVolumeTexture9 *iface)
46{
47 return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
48}
49
50static HRESULT WINAPI d3d9_texture_2d_QueryInterface(IDirect3DTexture9 *iface, REFIID riid, void **out)
51{
52 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
53
54 if (IsEqualGUID(riid, &IID_IDirect3DTexture9)
55 || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
56 || IsEqualGUID(riid, &IID_IDirect3DResource9)
57 || IsEqualGUID(riid, &IID_IUnknown))
58 {
59 IDirect3DTexture9_AddRef(iface);
60 *out = iface;
61 return S_OK;
62 }
63
64 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
65
66 *out = NULL;
67 return E_NOINTERFACE;
68}
69
70static ULONG WINAPI d3d9_texture_2d_AddRef(IDirect3DTexture9 *iface)
71{
72 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
73 ULONG ref = InterlockedIncrement(&texture->refcount);
74
75 TRACE("%p increasing refcount to %u.\n", iface, ref);
76
77 if (ref == 1)
78 {
79 IDirect3DDevice9Ex_AddRef(texture->parent_device);
80 wined3d_mutex_lock();
81 wined3d_texture_incref(texture->wined3d_texture);
82 wined3d_mutex_unlock();
83 }
84
85 return ref;
86}
87
88static ULONG WINAPI d3d9_texture_2d_Release(IDirect3DTexture9 *iface)
89{
90 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
91 ULONG ref = InterlockedDecrement(&texture->refcount);
92
93 TRACE("%p decreasing refcount to %u.\n", iface, ref);
94
95 if (!ref)
96 {
97 IDirect3DDevice9Ex *parent_device = texture->parent_device;
98
99 wined3d_mutex_lock();
100 wined3d_texture_decref(texture->wined3d_texture);
101 wined3d_mutex_unlock();
102
103 /* Release the device last, as it may cause the device to be destroyed. */
104 IDirect3DDevice9Ex_Release(parent_device);
105 }
106 return ref;
107}
108
109static HRESULT WINAPI d3d9_texture_2d_GetDevice(IDirect3DTexture9 *iface, IDirect3DDevice9 **device)
110{
111 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
112
113 TRACE("iface %p, device %p.\n", iface, device);
114
115 *device = (IDirect3DDevice9 *)texture->parent_device;
116 IDirect3DDevice9_AddRef(*device);
117
118 TRACE("Returning device %p.\n", *device);
119
120 return D3D_OK;
121}
122
123static HRESULT WINAPI d3d9_texture_2d_SetPrivateData(IDirect3DTexture9 *iface,
124 REFGUID guid, const void *data, DWORD data_size, DWORD flags)
125{
126 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
127 struct wined3d_resource *resource;
128 HRESULT hr;
129
130 TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
131 iface, debugstr_guid(guid), data, data_size, flags);
132
133 wined3d_mutex_lock();
134 resource = wined3d_texture_get_resource(texture->wined3d_texture);
135 hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
136 wined3d_mutex_unlock();
137
138 return hr;
139}
140
141static HRESULT WINAPI d3d9_texture_2d_GetPrivateData(IDirect3DTexture9 *iface,
142 REFGUID guid, void *data, DWORD *data_size)
143{
144 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
145 struct wined3d_resource *resource;
146 HRESULT hr;
147
148 TRACE("iface %p, guid %s, data %p, data_size %p.\n",
149 iface, debugstr_guid(guid), data, data_size);
150
151 wined3d_mutex_lock();
152 resource = wined3d_texture_get_resource(texture->wined3d_texture);
153 hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
154 wined3d_mutex_unlock();
155
156 return hr;
157}
158
159static HRESULT WINAPI d3d9_texture_2d_FreePrivateData(IDirect3DTexture9 *iface, REFGUID guid)
160{
161 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
162 struct wined3d_resource *resource;
163 HRESULT hr;
164
165 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
166
167 wined3d_mutex_lock();
168 resource = wined3d_texture_get_resource(texture->wined3d_texture);
169 hr = wined3d_resource_free_private_data(resource, guid);
170 wined3d_mutex_unlock();
171
172 return hr;
173}
174
175static DWORD WINAPI d3d9_texture_2d_SetPriority(IDirect3DTexture9 *iface, DWORD priority)
176{
177 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
178 DWORD ret;
179
180 TRACE("iface %p, priority %u.\n", iface, priority);
181
182 wined3d_mutex_lock();
183 ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
184 wined3d_mutex_unlock();
185
186 return ret;
187}
188
189static DWORD WINAPI d3d9_texture_2d_GetPriority(IDirect3DTexture9 *iface)
190{
191 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
192 DWORD ret;
193
194 TRACE("iface %p.\n", iface);
195
196 wined3d_mutex_lock();
197 ret = wined3d_texture_get_priority(texture->wined3d_texture);
198 wined3d_mutex_unlock();
199
200 return ret;
201}
202
203static void WINAPI d3d9_texture_2d_PreLoad(IDirect3DTexture9 *iface)
204{
205 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
206
207 TRACE("iface %p.\n", iface);
208
209 wined3d_mutex_lock();
210 wined3d_texture_preload(texture->wined3d_texture);
211 wined3d_mutex_unlock();
212}
213
214static D3DRESOURCETYPE WINAPI d3d9_texture_2d_GetType(IDirect3DTexture9 *iface)
215{
216 TRACE("iface %p.\n", iface);
217
218 return D3DRTYPE_TEXTURE;
219}
220
221static DWORD WINAPI d3d9_texture_2d_SetLOD(IDirect3DTexture9 *iface, DWORD lod)
222{
223 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
224 DWORD ret;
225
226 TRACE("iface %p, lod %u.\n", iface, lod);
227
228 wined3d_mutex_lock();
229 ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
230 wined3d_mutex_unlock();
231
232 return ret;
233}
234
235static DWORD WINAPI d3d9_texture_2d_GetLOD(IDirect3DTexture9 *iface)
236{
237 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
238 DWORD ret;
239
240 TRACE("iface %p.\n", iface);
241
242 wined3d_mutex_lock();
243 ret = wined3d_texture_get_lod(texture->wined3d_texture);
244 wined3d_mutex_unlock();
245
246 return ret;
247}
248
249static DWORD WINAPI d3d9_texture_2d_GetLevelCount(IDirect3DTexture9 *iface)
250{
251 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
252 DWORD ret;
253
254 TRACE("iface %p.\n", iface);
255
256 wined3d_mutex_lock();
257 ret = wined3d_texture_get_level_count(texture->wined3d_texture);
258 wined3d_mutex_unlock();
259
260 return ret;
261}
262
263static HRESULT WINAPI d3d9_texture_2d_SetAutoGenFilterType(IDirect3DTexture9 *iface, D3DTEXTUREFILTERTYPE filter_type)
264{
265 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
266 HRESULT hr;
267
268 TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
269
270 wined3d_mutex_lock();
271 hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
272 (enum wined3d_texture_filter_type)filter_type);
273 wined3d_mutex_unlock();
274
275 return hr;
276}
277
278static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_2d_GetAutoGenFilterType(IDirect3DTexture9 *iface)
279{
280 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
281 D3DTEXTUREFILTERTYPE ret;
282
283 TRACE("iface %p.\n", iface);
284
285 wined3d_mutex_lock();
286 ret = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
287 wined3d_mutex_unlock();
288
289 return ret;
290}
291
292static void WINAPI d3d9_texture_2d_GenerateMipSubLevels(IDirect3DTexture9 *iface)
293{
294 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
295
296 TRACE("iface %p.\n", iface);
297
298 wined3d_mutex_lock();
299 wined3d_texture_generate_mipmaps(texture->wined3d_texture);
300 wined3d_mutex_unlock();
301}
302
303static HRESULT WINAPI d3d9_texture_2d_GetLevelDesc(IDirect3DTexture9 *iface, UINT level, D3DSURFACE_DESC *desc)
304{
305 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
306 struct wined3d_resource *sub_resource;
307 HRESULT hr = D3D_OK;
308
309 TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
310
311 wined3d_mutex_lock();
312 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
313 hr = D3DERR_INVALIDCALL;
314 else
315 {
316 struct wined3d_resource_desc wined3d_desc;
317
318 wined3d_resource_get_desc(sub_resource, &wined3d_desc);
319 desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
320 desc->Type = wined3d_desc.resource_type;
321 desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
322 desc->Pool = wined3d_desc.pool;
323 desc->MultiSampleType = wined3d_desc.multisample_type;
324 desc->MultiSampleQuality = wined3d_desc.multisample_quality;
325 desc->Width = wined3d_desc.width;
326 desc->Height = wined3d_desc.height;
327 }
328 wined3d_mutex_unlock();
329
330 return hr;
331}
332
333static HRESULT WINAPI d3d9_texture_2d_GetSurfaceLevel(IDirect3DTexture9 *iface,
334 UINT level, IDirect3DSurface9 **surface)
335{
336 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
337 struct wined3d_resource *sub_resource;
338 struct d3d9_surface *surface_impl;
339
340 TRACE("iface %p, level %u, surface %p.\n", iface, level, surface);
341
342 wined3d_mutex_lock();
343 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
344 {
345 wined3d_mutex_unlock();
346 return D3DERR_INVALIDCALL;
347 }
348
349 surface_impl = wined3d_resource_get_parent(sub_resource);
350 *surface = &surface_impl->IDirect3DSurface9_iface;
351 IDirect3DSurface9_AddRef(*surface);
352 wined3d_mutex_unlock();
353
354 return D3D_OK;
355}
356
357static HRESULT WINAPI d3d9_texture_2d_LockRect(IDirect3DTexture9 *iface,
358 UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect, DWORD flags)
359{
360 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
361 struct wined3d_resource *sub_resource;
362 struct d3d9_surface *surface_impl;
363 HRESULT hr;
364
365 TRACE("iface %p, level %u, locked_rect %p, rect %p, flags %#x.\n",
366 iface, level, locked_rect, rect, flags);
367
368 wined3d_mutex_lock();
369 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
370 hr = D3DERR_INVALIDCALL;
371 else
372 {
373 surface_impl = wined3d_resource_get_parent(sub_resource);
374 hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags);
375 }
376 wined3d_mutex_unlock();
377
378 return hr;
379}
380
381static HRESULT WINAPI d3d9_texture_2d_UnlockRect(IDirect3DTexture9 *iface, UINT level)
382{
383 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
384 struct wined3d_resource *sub_resource;
385 struct d3d9_surface *surface_impl;
386 HRESULT hr;
387
388 TRACE("iface %p, level %u.\n", iface, level);
389
390 wined3d_mutex_lock();
391 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
392 hr = D3DERR_INVALIDCALL;
393 else
394 {
395 surface_impl = wined3d_resource_get_parent(sub_resource);
396 hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface);
397 }
398 wined3d_mutex_unlock();
399
400 return hr;
401}
402
403static HRESULT WINAPI d3d9_texture_2d_AddDirtyRect(IDirect3DTexture9 *iface, const RECT *dirty_rect)
404{
405 struct d3d9_texture *texture = impl_from_IDirect3DTexture9(iface);
406 HRESULT hr;
407
408 TRACE("iface %p, dirty_rect %s.\n",
409 iface, wine_dbgstr_rect(dirty_rect));
410
411 wined3d_mutex_lock();
412 if (!dirty_rect)
413 hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, NULL);
414 else
415 {
416 struct wined3d_box dirty_region;
417
418 dirty_region.left = dirty_rect->left;
419 dirty_region.top = dirty_rect->top;
420 dirty_region.right = dirty_rect->right;
421 dirty_region.bottom = dirty_rect->bottom;
422 dirty_region.front = 0;
423 dirty_region.back = 1;
424 hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, &dirty_region);
425 }
426 wined3d_mutex_unlock();
427
428 return hr;
429}
430
431static const IDirect3DTexture9Vtbl d3d9_texture_2d_vtbl =
432{
433 /* IUnknown */
434 d3d9_texture_2d_QueryInterface,
435 d3d9_texture_2d_AddRef,
436 d3d9_texture_2d_Release,
437 /* IDirect3DResource9 */
438 d3d9_texture_2d_GetDevice,
439 d3d9_texture_2d_SetPrivateData,
440 d3d9_texture_2d_GetPrivateData,
441 d3d9_texture_2d_FreePrivateData,
442 d3d9_texture_2d_SetPriority,
443 d3d9_texture_2d_GetPriority,
444 d3d9_texture_2d_PreLoad,
445 d3d9_texture_2d_GetType,
446 /* IDirect3dBaseTexture9 */
447 d3d9_texture_2d_SetLOD,
448 d3d9_texture_2d_GetLOD,
449 d3d9_texture_2d_GetLevelCount,
450 d3d9_texture_2d_SetAutoGenFilterType,
451 d3d9_texture_2d_GetAutoGenFilterType,
452 d3d9_texture_2d_GenerateMipSubLevels,
453 /* IDirect3DTexture9 */
454 d3d9_texture_2d_GetLevelDesc,
455 d3d9_texture_2d_GetSurfaceLevel,
456 d3d9_texture_2d_LockRect,
457 d3d9_texture_2d_UnlockRect,
458 d3d9_texture_2d_AddDirtyRect,
459};
460
461static HRESULT WINAPI d3d9_texture_cube_QueryInterface(IDirect3DCubeTexture9 *iface, REFIID riid, void **out)
462{
463 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
464
465 if (IsEqualGUID(riid, &IID_IDirect3DCubeTexture9)
466 || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
467 || IsEqualGUID(riid, &IID_IDirect3DResource9)
468 || IsEqualGUID(riid, &IID_IUnknown))
469 {
470 IDirect3DCubeTexture9_AddRef(iface);
471 *out = iface;
472 return S_OK;
473 }
474
475 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
476
477 *out = NULL;
478 return E_NOINTERFACE;
479}
480
481static ULONG WINAPI d3d9_texture_cube_AddRef(IDirect3DCubeTexture9 *iface)
482{
483 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
484 ULONG ref = InterlockedIncrement(&texture->refcount);
485
486 TRACE("%p increasing refcount to %u.\n", iface, ref);
487
488 if (ref == 1)
489 {
490 IDirect3DDevice9Ex_AddRef(texture->parent_device);
491 wined3d_mutex_lock();
492 wined3d_texture_incref(texture->wined3d_texture);
493 wined3d_mutex_unlock();
494 }
495
496 return ref;
497}
498
499static ULONG WINAPI d3d9_texture_cube_Release(IDirect3DCubeTexture9 *iface)
500{
501 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
502 ULONG ref = InterlockedDecrement(&texture->refcount);
503
504 TRACE("%p decreasing refcount to %u.\n", iface, ref);
505
506 if (!ref)
507 {
508 IDirect3DDevice9Ex *parent_device = texture->parent_device;
509
510 TRACE("Releasing child %p.\n", texture->wined3d_texture);
511
512 wined3d_mutex_lock();
513 wined3d_texture_decref(texture->wined3d_texture);
514 wined3d_mutex_unlock();
515
516 /* Release the device last, as it may cause the device to be destroyed. */
517 IDirect3DDevice9Ex_Release(parent_device);
518 }
519 return ref;
520}
521
522static HRESULT WINAPI d3d9_texture_cube_GetDevice(IDirect3DCubeTexture9 *iface, IDirect3DDevice9 **device)
523{
524 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
525
526 TRACE("iface %p, device %p.\n", iface, device);
527
528 *device = (IDirect3DDevice9 *)texture->parent_device;
529 IDirect3DDevice9_AddRef(*device);
530
531 TRACE("Returning device %p.\n", *device);
532
533 return D3D_OK;
534}
535
536static HRESULT WINAPI d3d9_texture_cube_SetPrivateData(IDirect3DCubeTexture9 *iface,
537 REFGUID guid, const void *data, DWORD data_size, DWORD flags)
538{
539 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
540 struct wined3d_resource *resource;
541 HRESULT hr;
542
543 TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
544 iface, debugstr_guid(guid), data, data_size, flags);
545
546 wined3d_mutex_lock();
547 resource = wined3d_texture_get_resource(texture->wined3d_texture);
548 hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
549 wined3d_mutex_unlock();
550
551 return hr;
552}
553
554static HRESULT WINAPI d3d9_texture_cube_GetPrivateData(IDirect3DCubeTexture9 *iface,
555 REFGUID guid, void *data, DWORD *data_size)
556{
557 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
558 struct wined3d_resource *resource;
559 HRESULT hr;
560
561 TRACE("iface %p, guid %s, data %p, data_size %p.\n",
562 iface, debugstr_guid(guid), data, data_size);
563
564 wined3d_mutex_lock();
565 resource = wined3d_texture_get_resource(texture->wined3d_texture);
566 hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
567 wined3d_mutex_unlock();
568
569 return hr;
570}
571
572static HRESULT WINAPI d3d9_texture_cube_FreePrivateData(IDirect3DCubeTexture9 *iface, REFGUID guid)
573{
574 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
575 struct wined3d_resource *resource;
576 HRESULT hr;
577
578 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
579
580 wined3d_mutex_lock();
581 resource = wined3d_texture_get_resource(texture->wined3d_texture);
582 hr = wined3d_resource_free_private_data(resource, guid);
583 wined3d_mutex_unlock();
584
585 return hr;
586}
587
588static DWORD WINAPI d3d9_texture_cube_SetPriority(IDirect3DCubeTexture9 *iface, DWORD priority)
589{
590 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
591 DWORD ret;
592
593 TRACE("iface %p, priority %u.\n", iface, priority);
594
595 wined3d_mutex_lock();
596 ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
597 wined3d_mutex_unlock();
598
599 return ret;
600}
601
602static DWORD WINAPI d3d9_texture_cube_GetPriority(IDirect3DCubeTexture9 *iface)
603{
604 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
605 DWORD ret;
606
607 TRACE("iface %p.\n", iface);
608
609 wined3d_mutex_lock();
610 ret = wined3d_texture_get_priority(texture->wined3d_texture);
611 wined3d_mutex_unlock();
612
613 return ret;
614}
615
616static void WINAPI d3d9_texture_cube_PreLoad(IDirect3DCubeTexture9 *iface)
617{
618 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
619
620 TRACE("iface %p.\n", iface);
621
622 wined3d_mutex_lock();
623 wined3d_texture_preload(texture->wined3d_texture);
624 wined3d_mutex_unlock();
625}
626
627static D3DRESOURCETYPE WINAPI d3d9_texture_cube_GetType(IDirect3DCubeTexture9 *iface)
628{
629 TRACE("iface %p.\n", iface);
630
631 return D3DRTYPE_CUBETEXTURE;
632}
633
634static DWORD WINAPI d3d9_texture_cube_SetLOD(IDirect3DCubeTexture9 *iface, DWORD lod)
635{
636 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
637 DWORD ret;
638
639 TRACE("iface %p, lod %u.\n", iface, lod);
640
641 wined3d_mutex_lock();
642 ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
643 wined3d_mutex_unlock();
644
645 return ret;
646}
647
648static DWORD WINAPI d3d9_texture_cube_GetLOD(IDirect3DCubeTexture9 *iface)
649{
650 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
651 DWORD ret;
652
653 TRACE("iface %p.\n", iface);
654
655 wined3d_mutex_lock();
656 ret = wined3d_texture_get_lod(texture->wined3d_texture);
657 wined3d_mutex_unlock();
658
659 return ret;
660}
661
662static DWORD WINAPI d3d9_texture_cube_GetLevelCount(IDirect3DCubeTexture9 *iface)
663{
664 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
665 DWORD ret;
666
667 TRACE("iface %p.\n", iface);
668
669 wined3d_mutex_lock();
670 ret = wined3d_texture_get_level_count(texture->wined3d_texture);
671 wined3d_mutex_unlock();
672
673 return ret;
674}
675
676static HRESULT WINAPI d3d9_texture_cube_SetAutoGenFilterType(IDirect3DCubeTexture9 *iface,
677 D3DTEXTUREFILTERTYPE filter_type)
678{
679 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
680 HRESULT hr;
681
682 TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
683
684 wined3d_mutex_lock();
685 hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
686 (enum wined3d_texture_filter_type)filter_type);
687 wined3d_mutex_unlock();
688
689 return hr;
690}
691
692static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_cube_GetAutoGenFilterType(IDirect3DCubeTexture9 *iface)
693{
694 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
695 D3DTEXTUREFILTERTYPE ret;
696
697 TRACE("iface %p.\n", iface);
698
699 wined3d_mutex_lock();
700 ret = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
701 wined3d_mutex_unlock();
702
703 return ret;
704}
705
706static void WINAPI d3d9_texture_cube_GenerateMipSubLevels(IDirect3DCubeTexture9 *iface)
707{
708 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
709
710 TRACE("iface %p.\n", iface);
711
712 wined3d_mutex_lock();
713 wined3d_texture_generate_mipmaps(texture->wined3d_texture);
714 wined3d_mutex_unlock();
715}
716
717static HRESULT WINAPI d3d9_texture_cube_GetLevelDesc(IDirect3DCubeTexture9 *iface, UINT level, D3DSURFACE_DESC *desc)
718{
719 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
720 struct wined3d_resource *sub_resource;
721 HRESULT hr = D3D_OK;
722 DWORD level_count;
723
724 TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
725
726 wined3d_mutex_lock();
727 level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
728 if (level >= level_count)
729 {
730 wined3d_mutex_unlock();
731 return D3DERR_INVALIDCALL;
732 }
733
734 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
735 hr = D3DERR_INVALIDCALL;
736 else
737 {
738 struct wined3d_resource_desc wined3d_desc;
739
740 wined3d_resource_get_desc(sub_resource, &wined3d_desc);
741 desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
742 desc->Type = wined3d_desc.resource_type;
743 desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
744 desc->Pool = wined3d_desc.pool;
745 desc->MultiSampleType = wined3d_desc.multisample_type;
746 desc->MultiSampleQuality = wined3d_desc.multisample_quality;
747 desc->Width = wined3d_desc.width;
748 desc->Height = wined3d_desc.height;
749 }
750 wined3d_mutex_unlock();
751
752 return hr;
753}
754
755static HRESULT WINAPI d3d9_texture_cube_GetCubeMapSurface(IDirect3DCubeTexture9 *iface,
756 D3DCUBEMAP_FACES face, UINT level, IDirect3DSurface9 **surface)
757{
758 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
759 struct wined3d_resource *sub_resource;
760 struct d3d9_surface *surface_impl;
761 UINT sub_resource_idx;
762 DWORD level_count;
763
764 TRACE("iface %p, face %#x, level %u, surface %p.\n", iface, face, level, surface);
765
766 wined3d_mutex_lock();
767 level_count = wined3d_texture_get_level_count(texture->wined3d_texture);
768 if (level >= level_count)
769 {
770 wined3d_mutex_unlock();
771 return D3DERR_INVALIDCALL;
772 }
773
774 sub_resource_idx = level_count * face + level;
775 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
776 {
777 wined3d_mutex_unlock();
778 return D3DERR_INVALIDCALL;
779 }
780
781 surface_impl = wined3d_resource_get_parent(sub_resource);
782 *surface = &surface_impl->IDirect3DSurface9_iface;
783 IDirect3DSurface9_AddRef(*surface);
784 wined3d_mutex_unlock();
785
786 return D3D_OK;
787}
788
789static HRESULT WINAPI d3d9_texture_cube_LockRect(IDirect3DCubeTexture9 *iface,
790 D3DCUBEMAP_FACES face, UINT level, D3DLOCKED_RECT *locked_rect, const RECT *rect,
791 DWORD flags)
792{
793 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
794 struct wined3d_resource *sub_resource;
795 struct d3d9_surface *surface_impl;
796 UINT sub_resource_idx;
797 HRESULT hr;
798
799 TRACE("iface %p, face %#x, level %u, locked_rect %p, rect %p, flags %#x.\n",
800 iface, face, level, locked_rect, rect, flags);
801
802 wined3d_mutex_lock();
803 sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
804 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
805 hr = D3DERR_INVALIDCALL;
806 else
807 {
808 surface_impl = wined3d_resource_get_parent(sub_resource);
809 hr = IDirect3DSurface9_LockRect(&surface_impl->IDirect3DSurface9_iface, locked_rect, rect, flags);
810 }
811 wined3d_mutex_unlock();
812
813 return hr;
814}
815
816static HRESULT WINAPI d3d9_texture_cube_UnlockRect(IDirect3DCubeTexture9 *iface,
817 D3DCUBEMAP_FACES face, UINT level)
818{
819 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
820 struct wined3d_resource *sub_resource;
821 struct d3d9_surface *surface_impl;
822 UINT sub_resource_idx;
823 HRESULT hr;
824
825 TRACE("iface %p, face %#x, level %u.\n", iface, face, level);
826
827 wined3d_mutex_lock();
828 sub_resource_idx = wined3d_texture_get_level_count(texture->wined3d_texture) * face + level;
829 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, sub_resource_idx)))
830 hr = D3DERR_INVALIDCALL;
831 else
832 {
833 surface_impl = wined3d_resource_get_parent(sub_resource);
834 hr = IDirect3DSurface9_UnlockRect(&surface_impl->IDirect3DSurface9_iface);
835 }
836 wined3d_mutex_unlock();
837
838 return hr;
839}
840
841static HRESULT WINAPI d3d9_texture_cube_AddDirtyRect(IDirect3DCubeTexture9 *iface,
842 D3DCUBEMAP_FACES face, const RECT *dirty_rect)
843{
844 struct d3d9_texture *texture = impl_from_IDirect3DCubeTexture9(iface);
845 HRESULT hr;
846
847 TRACE("iface %p, face %#x, dirty_rect %s.\n",
848 iface, face, wine_dbgstr_rect(dirty_rect));
849
850 wined3d_mutex_lock();
851 if (!dirty_rect)
852 hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, NULL);
853 else
854 {
855 struct wined3d_box dirty_region;
856
857 dirty_region.left = dirty_rect->left;
858 dirty_region.top = dirty_rect->top;
859 dirty_region.right = dirty_rect->right;
860 dirty_region.bottom = dirty_rect->bottom;
861 dirty_region.front = 0;
862 dirty_region.back = 1;
863 hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, face, &dirty_region);
864 }
865 wined3d_mutex_unlock();
866
867 return hr;
868}
869
870static const IDirect3DCubeTexture9Vtbl d3d9_texture_cube_vtbl =
871{
872 /* IUnknown */
873 d3d9_texture_cube_QueryInterface,
874 d3d9_texture_cube_AddRef,
875 d3d9_texture_cube_Release,
876 /* IDirect3DResource9 */
877 d3d9_texture_cube_GetDevice,
878 d3d9_texture_cube_SetPrivateData,
879 d3d9_texture_cube_GetPrivateData,
880 d3d9_texture_cube_FreePrivateData,
881 d3d9_texture_cube_SetPriority,
882 d3d9_texture_cube_GetPriority,
883 d3d9_texture_cube_PreLoad,
884 d3d9_texture_cube_GetType,
885 /* IDirect3DBaseTexture9 */
886 d3d9_texture_cube_SetLOD,
887 d3d9_texture_cube_GetLOD,
888 d3d9_texture_cube_GetLevelCount,
889 d3d9_texture_cube_SetAutoGenFilterType,
890 d3d9_texture_cube_GetAutoGenFilterType,
891 d3d9_texture_cube_GenerateMipSubLevels,
892 /* IDirect3DCubeTexture9 */
893 d3d9_texture_cube_GetLevelDesc,
894 d3d9_texture_cube_GetCubeMapSurface,
895 d3d9_texture_cube_LockRect,
896 d3d9_texture_cube_UnlockRect,
897 d3d9_texture_cube_AddDirtyRect,
898};
899
900static HRESULT WINAPI d3d9_texture_3d_QueryInterface(IDirect3DVolumeTexture9 *iface, REFIID riid, void **out)
901{
902 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
903
904 if (IsEqualGUID(riid, &IID_IDirect3DVolumeTexture9)
905 || IsEqualGUID(riid, &IID_IDirect3DBaseTexture9)
906 || IsEqualGUID(riid, &IID_IDirect3DResource9)
907 || IsEqualGUID(riid, &IID_IUnknown))
908 {
909 IDirect3DVolumeTexture9_AddRef(iface);
910 *out = iface;
911 return S_OK;
912 }
913
914 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
915
916 *out = NULL;
917 return E_NOINTERFACE;
918}
919
920static ULONG WINAPI d3d9_texture_3d_AddRef(IDirect3DVolumeTexture9 *iface)
921{
922 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
923 ULONG ref = InterlockedIncrement(&texture->refcount);
924
925 TRACE("%p increasing refcount to %u.\n", iface, ref);
926
927 if (ref == 1)
928 {
929 IDirect3DDevice9Ex_AddRef(texture->parent_device);
930 wined3d_mutex_lock();
931 wined3d_texture_incref(texture->wined3d_texture);
932 wined3d_mutex_unlock();
933 }
934
935 return ref;
936}
937
938static ULONG WINAPI d3d9_texture_3d_Release(IDirect3DVolumeTexture9 *iface)
939{
940 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
941 ULONG ref = InterlockedDecrement(&texture->refcount);
942
943 TRACE("%p decreasing refcount to %u.\n", iface, ref);
944
945 if (!ref)
946 {
947 IDirect3DDevice9Ex *parent_device = texture->parent_device;
948
949 wined3d_mutex_lock();
950 wined3d_texture_decref(texture->wined3d_texture);
951 wined3d_mutex_unlock();
952
953 /* Release the device last, as it may cause the device to be destroyed. */
954 IDirect3DDevice9Ex_Release(parent_device);
955 }
956 return ref;
957}
958
959static HRESULT WINAPI d3d9_texture_3d_GetDevice(IDirect3DVolumeTexture9 *iface, IDirect3DDevice9 **device)
960{
961 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
962
963 TRACE("iface %p, device %p.\n", iface, device);
964
965 *device = (IDirect3DDevice9 *)texture->parent_device;
966 IDirect3DDevice9_AddRef(*device);
967
968 TRACE("Returning device %p.\n", *device);
969
970 return D3D_OK;
971}
972
973static HRESULT WINAPI d3d9_texture_3d_SetPrivateData(IDirect3DVolumeTexture9 *iface,
974 REFGUID guid, const void *data, DWORD data_size, DWORD flags)
975{
976 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
977 struct wined3d_resource *resource;
978 HRESULT hr;
979
980 TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
981 iface, debugstr_guid(guid), data, data_size, flags);
982
983 wined3d_mutex_lock();
984 resource = wined3d_texture_get_resource(texture->wined3d_texture);
985 hr = wined3d_resource_set_private_data(resource, guid, data, data_size, flags);
986 wined3d_mutex_unlock();
987
988 return hr;
989}
990
991static HRESULT WINAPI d3d9_texture_3d_GetPrivateData(IDirect3DVolumeTexture9 *iface,
992 REFGUID guid, void *data, DWORD *data_size)
993{
994 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
995 struct wined3d_resource *resource;
996 HRESULT hr;
997
998 TRACE("iface %p, guid %s, data %p, data_size %p.\n",
999 iface, debugstr_guid(guid), data, data_size);
1000
1001 wined3d_mutex_lock();
1002 resource = wined3d_texture_get_resource(texture->wined3d_texture);
1003 hr = wined3d_resource_get_private_data(resource, guid, data, data_size);
1004 wined3d_mutex_unlock();
1005
1006 return hr;
1007}
1008
1009static HRESULT WINAPI d3d9_texture_3d_FreePrivateData(IDirect3DVolumeTexture9 *iface, REFGUID guid)
1010{
1011 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1012 struct wined3d_resource *resource;
1013 HRESULT hr;
1014
1015 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1016
1017 wined3d_mutex_lock();
1018 resource = wined3d_texture_get_resource(texture->wined3d_texture);
1019 hr = wined3d_resource_free_private_data(resource, guid);
1020 wined3d_mutex_unlock();
1021
1022 return hr;
1023}
1024
1025static DWORD WINAPI d3d9_texture_3d_SetPriority(IDirect3DVolumeTexture9 *iface, DWORD priority)
1026{
1027 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1028 DWORD ret;
1029
1030 TRACE("iface %p, priority %u.\n", iface, priority);
1031
1032 wined3d_mutex_lock();
1033 ret = wined3d_texture_set_priority(texture->wined3d_texture, priority);
1034 wined3d_mutex_unlock();
1035
1036 return ret;
1037}
1038
1039static DWORD WINAPI d3d9_texture_3d_GetPriority(IDirect3DVolumeTexture9 *iface)
1040{
1041 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1042 DWORD ret;
1043
1044 TRACE("iface %p.\n", iface);
1045
1046 wined3d_mutex_lock();
1047 ret = wined3d_texture_get_priority(texture->wined3d_texture);
1048 wined3d_mutex_unlock();
1049
1050 return ret;
1051}
1052
1053static void WINAPI d3d9_texture_3d_PreLoad(IDirect3DVolumeTexture9 *iface)
1054{
1055 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1056
1057 TRACE("iface %p.\n", iface);
1058
1059 wined3d_mutex_lock();
1060 wined3d_texture_preload(texture->wined3d_texture);
1061 wined3d_mutex_unlock();
1062}
1063
1064static D3DRESOURCETYPE WINAPI d3d9_texture_3d_GetType(IDirect3DVolumeTexture9 *iface)
1065{
1066 TRACE("iface %p.\n", iface);
1067
1068 return D3DRTYPE_VOLUMETEXTURE;
1069}
1070
1071static DWORD WINAPI d3d9_texture_3d_SetLOD(IDirect3DVolumeTexture9 *iface, DWORD lod)
1072{
1073 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1074 DWORD ret;
1075
1076 TRACE("iface %p, lod %u.\n", iface, lod);
1077
1078 wined3d_mutex_lock();
1079 ret = wined3d_texture_set_lod(texture->wined3d_texture, lod);
1080 wined3d_mutex_unlock();
1081
1082 return ret;
1083}
1084
1085static DWORD WINAPI d3d9_texture_3d_GetLOD(IDirect3DVolumeTexture9 *iface)
1086{
1087 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1088 DWORD ret;
1089
1090 TRACE("iface %p.\n", iface);
1091
1092 wined3d_mutex_lock();
1093 ret = wined3d_texture_get_lod(texture->wined3d_texture);
1094 wined3d_mutex_unlock();
1095
1096 return ret;
1097}
1098
1099static DWORD WINAPI d3d9_texture_3d_GetLevelCount(IDirect3DVolumeTexture9 *iface)
1100{
1101 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1102 DWORD ret;
1103
1104 TRACE("iface %p.\n", iface);
1105
1106 wined3d_mutex_lock();
1107 ret = wined3d_texture_get_level_count(texture->wined3d_texture);
1108 wined3d_mutex_unlock();
1109
1110 return ret;
1111}
1112
1113static HRESULT WINAPI d3d9_texture_3d_SetAutoGenFilterType(IDirect3DVolumeTexture9 *iface,
1114 D3DTEXTUREFILTERTYPE filter_type)
1115{
1116 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1117 HRESULT hr;
1118
1119 TRACE("iface %p, filter_type %#x.\n", iface, filter_type);
1120
1121 wined3d_mutex_lock();
1122 hr = wined3d_texture_set_autogen_filter_type(texture->wined3d_texture,
1123 (enum wined3d_texture_filter_type)filter_type);
1124 wined3d_mutex_unlock();
1125
1126 return hr;
1127}
1128
1129static D3DTEXTUREFILTERTYPE WINAPI d3d9_texture_3d_GetAutoGenFilterType(IDirect3DVolumeTexture9 *iface)
1130{
1131 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1132 D3DTEXTUREFILTERTYPE filter_type;
1133
1134 TRACE("iface %p.\n", iface);
1135
1136 wined3d_mutex_lock();
1137 filter_type = (D3DTEXTUREFILTERTYPE)wined3d_texture_get_autogen_filter_type(texture->wined3d_texture);
1138 wined3d_mutex_unlock();
1139
1140 return filter_type;
1141}
1142
1143static void WINAPI d3d9_texture_3d_GenerateMipSubLevels(IDirect3DVolumeTexture9 *iface)
1144{
1145 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1146
1147 TRACE("iface %p.\n", iface);
1148
1149 wined3d_mutex_lock();
1150 wined3d_texture_generate_mipmaps(texture->wined3d_texture);
1151 wined3d_mutex_unlock();
1152}
1153
1154static HRESULT WINAPI d3d9_texture_3d_GetLevelDesc(IDirect3DVolumeTexture9 *iface, UINT level, D3DVOLUME_DESC *desc)
1155{
1156 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1157 struct wined3d_resource *sub_resource;
1158 HRESULT hr = D3D_OK;
1159
1160 TRACE("iface %p, level %u, desc %p.\n", iface, level, desc);
1161
1162 wined3d_mutex_lock();
1163 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1164 hr = D3DERR_INVALIDCALL;
1165 else
1166 {
1167 struct wined3d_resource_desc wined3d_desc;
1168
1169 wined3d_resource_get_desc(sub_resource, &wined3d_desc);
1170 desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
1171 desc->Type = wined3d_desc.resource_type;
1172 desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
1173 desc->Pool = wined3d_desc.pool;
1174 desc->Width = wined3d_desc.width;
1175 desc->Height = wined3d_desc.height;
1176 desc->Depth = wined3d_desc.depth;
1177 }
1178 wined3d_mutex_unlock();
1179
1180 return hr;
1181}
1182
1183static HRESULT WINAPI d3d9_texture_3d_GetVolumeLevel(IDirect3DVolumeTexture9 *iface,
1184 UINT level, IDirect3DVolume9 **volume)
1185{
1186 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1187 struct wined3d_resource *sub_resource;
1188 struct d3d9_volume *volume_impl;
1189
1190 TRACE("iface %p, level %u, volume %p.\n", iface, level, volume);
1191
1192 wined3d_mutex_lock();
1193 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1194 {
1195 wined3d_mutex_unlock();
1196 return D3DERR_INVALIDCALL;
1197 }
1198
1199 volume_impl = wined3d_resource_get_parent(sub_resource);
1200 *volume = &volume_impl->IDirect3DVolume9_iface;
1201 IDirect3DVolume9_AddRef(*volume);
1202 wined3d_mutex_unlock();
1203
1204 return D3D_OK;
1205}
1206
1207static HRESULT WINAPI d3d9_texture_3d_LockBox(IDirect3DVolumeTexture9 *iface,
1208 UINT level, D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
1209{
1210 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1211 struct wined3d_resource *sub_resource;
1212 struct d3d9_volume *volume_impl;
1213 HRESULT hr;
1214
1215 TRACE("iface %p, level %u, locked_box %p, box %p, flags %#x.\n",
1216 iface, level, locked_box, box, flags);
1217
1218 wined3d_mutex_lock();
1219 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1220 hr = D3DERR_INVALIDCALL;
1221 else
1222 {
1223 volume_impl = wined3d_resource_get_parent(sub_resource);
1224 hr = IDirect3DVolume9_LockBox(&volume_impl->IDirect3DVolume9_iface, locked_box, box, flags);
1225 }
1226 wined3d_mutex_unlock();
1227
1228 return hr;
1229}
1230
1231static HRESULT WINAPI d3d9_texture_3d_UnlockBox(IDirect3DVolumeTexture9 *iface, UINT level)
1232{
1233 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1234 struct wined3d_resource *sub_resource;
1235 struct d3d9_volume *volume_impl;
1236 HRESULT hr;
1237
1238 TRACE("iface %p, level %u.\n", iface, level);
1239
1240 wined3d_mutex_lock();
1241 if (!(sub_resource = wined3d_texture_get_sub_resource(texture->wined3d_texture, level)))
1242 hr = D3DERR_INVALIDCALL;
1243 else
1244 {
1245 volume_impl = wined3d_resource_get_parent(sub_resource);
1246 hr = IDirect3DVolume9_UnlockBox(&volume_impl->IDirect3DVolume9_iface);
1247 }
1248 wined3d_mutex_unlock();
1249
1250 return hr;
1251}
1252
1253static HRESULT WINAPI d3d9_texture_3d_AddDirtyBox(IDirect3DVolumeTexture9 *iface, const D3DBOX *dirty_box)
1254{
1255 struct d3d9_texture *texture = impl_from_IDirect3DVolumeTexture9(iface);
1256 HRESULT hr;
1257
1258 TRACE("iface %p, dirty_box %p.\n", iface, dirty_box);
1259
1260 wined3d_mutex_lock();
1261 hr = wined3d_texture_add_dirty_region(texture->wined3d_texture, 0, (const struct wined3d_box *)dirty_box);
1262 wined3d_mutex_unlock();
1263
1264 return hr;
1265}
1266
1267
1268static const IDirect3DVolumeTexture9Vtbl d3d9_texture_3d_vtbl =
1269{
1270 /* IUnknown */
1271 d3d9_texture_3d_QueryInterface,
1272 d3d9_texture_3d_AddRef,
1273 d3d9_texture_3d_Release,
1274 /* IDirect3DResource9 */
1275 d3d9_texture_3d_GetDevice,
1276 d3d9_texture_3d_SetPrivateData,
1277 d3d9_texture_3d_GetPrivateData,
1278 d3d9_texture_3d_FreePrivateData,
1279 d3d9_texture_3d_SetPriority,
1280 d3d9_texture_3d_GetPriority,
1281 d3d9_texture_3d_PreLoad,
1282 d3d9_texture_3d_GetType,
1283 /* IDirect3DBaseTexture9 */
1284 d3d9_texture_3d_SetLOD,
1285 d3d9_texture_3d_GetLOD,
1286 d3d9_texture_3d_GetLevelCount,
1287 d3d9_texture_3d_SetAutoGenFilterType,
1288 d3d9_texture_3d_GetAutoGenFilterType,
1289 d3d9_texture_3d_GenerateMipSubLevels,
1290 /* IDirect3DVolumeTexture9 */
1291 d3d9_texture_3d_GetLevelDesc,
1292 d3d9_texture_3d_GetVolumeLevel,
1293 d3d9_texture_3d_LockBox,
1294 d3d9_texture_3d_UnlockBox,
1295 d3d9_texture_3d_AddDirtyBox,
1296};
1297
1298struct d3d9_texture *unsafe_impl_from_IDirect3DBaseTexture9(IDirect3DBaseTexture9 *iface)
1299{
1300 if (!iface)
1301 return NULL;
1302 assert(iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl
1303 || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl
1304 || iface->lpVtbl == (const IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl);
1305 return CONTAINING_RECORD(iface, struct d3d9_texture, IDirect3DBaseTexture9_iface);
1306}
1307
1308static void STDMETHODCALLTYPE d3d9_texture_wined3d_object_destroyed(void *parent)
1309{
1310 HeapFree(GetProcessHeap(), 0, parent);
1311}
1312
1313static const struct wined3d_parent_ops d3d9_texture_wined3d_parent_ops =
1314{
1315 d3d9_texture_wined3d_object_destroyed,
1316};
1317
1318HRESULT texture_init(struct d3d9_texture *texture, struct d3d9_device *device,
1319 UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool
1320#ifdef VBOX_WITH_WDDM
1321 , HANDLE *shared_handle
1322 , void **pavClientMem
1323#endif
1324 )
1325{
1326 struct wined3d_resource_desc desc;
1327 DWORD surface_flags = 0;
1328 HRESULT hr;
1329
1330 texture->IDirect3DBaseTexture9_iface.lpVtbl = (/*const*/ IDirect3DBaseTexture9Vtbl *)&d3d9_texture_2d_vtbl;
1331 texture->refcount = 1;
1332
1333 desc.resource_type = WINED3D_RTYPE_TEXTURE;
1334 desc.format = wined3dformat_from_d3dformat(format);
1335 desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1336 desc.multisample_quality = 0;
1337 desc.usage = usage & WINED3DUSAGE_MASK;
1338 desc.pool = pool;
1339 desc.width = width;
1340 desc.height = height;
1341 desc.depth = 1;
1342 desc.size = 0;
1343
1344 if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC))
1345 surface_flags |= WINED3D_SURFACE_MAPPABLE;
1346
1347 wined3d_mutex_lock();
1348 hr = wined3d_texture_create_2d(device->wined3d_device, &desc, levels, surface_flags,
1349 texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture
1350#ifdef VBOX_WITH_WDDM
1351 , shared_handle
1352 , pavClientMem
1353#endif
1354 );
1355 wined3d_mutex_unlock();
1356 if (FAILED(hr))
1357 {
1358 WARN("Failed to create wined3d texture, hr %#x.\n", hr);
1359 return hr;
1360 }
1361
1362 texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1363 IDirect3DDevice9Ex_AddRef(texture->parent_device);
1364
1365 return D3D_OK;
1366}
1367
1368HRESULT cubetexture_init(struct d3d9_texture *texture, struct d3d9_device *device,
1369 UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool
1370#ifdef VBOX_WITH_WDDM
1371 , HANDLE *shared_handle
1372 , void **pavClientMem
1373#endif
1374 )
1375{
1376 struct wined3d_resource_desc desc;
1377 DWORD surface_flags = 0;
1378 HRESULT hr;
1379
1380 texture->IDirect3DBaseTexture9_iface.lpVtbl = (/*const*/ IDirect3DBaseTexture9Vtbl *)&d3d9_texture_cube_vtbl;
1381 texture->refcount = 1;
1382
1383 desc.resource_type = WINED3D_RTYPE_CUBE_TEXTURE;
1384 desc.format = wined3dformat_from_d3dformat(format);
1385 desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1386 desc.multisample_quality = 0;
1387 desc.usage = usage & WINED3DUSAGE_MASK;
1388 desc.pool = pool;
1389 desc.width = edge_length;
1390 desc.height = edge_length;
1391 desc.depth = 1;
1392 desc.size = 0;
1393
1394 if (pool != D3DPOOL_DEFAULT || (usage & D3DUSAGE_DYNAMIC))
1395 surface_flags |= WINED3D_SURFACE_MAPPABLE;
1396
1397 wined3d_mutex_lock();
1398 hr = wined3d_texture_create_cube(device->wined3d_device, &desc, levels, surface_flags,
1399 texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture
1400#ifdef VBOX_WITH_WDDM
1401 , shared_handle
1402 , pavClientMem
1403#endif
1404 );
1405 wined3d_mutex_unlock();
1406 if (FAILED(hr))
1407 {
1408 WARN("Failed to create wined3d cube texture, hr %#x.\n", hr);
1409 return hr;
1410 }
1411
1412 texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1413 IDirect3DDevice9Ex_AddRef(texture->parent_device);
1414
1415 return D3D_OK;
1416}
1417
1418HRESULT volumetexture_init(struct d3d9_texture *texture, struct d3d9_device *device,
1419 UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool
1420#ifdef VBOX_WITH_WDDM
1421 , HANDLE *shared_handle
1422 , void **pavClientMem
1423#endif
1424 )
1425{
1426 struct wined3d_resource_desc desc;
1427 HRESULT hr;
1428
1429 texture->IDirect3DBaseTexture9_iface.lpVtbl = (/*const*/ IDirect3DBaseTexture9Vtbl *)&d3d9_texture_3d_vtbl;
1430 texture->refcount = 1;
1431
1432 desc.resource_type = WINED3D_RTYPE_VOLUME_TEXTURE;
1433 desc.format = wined3dformat_from_d3dformat(format);
1434 desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
1435 desc.multisample_quality = 0;
1436 desc.usage = usage & WINED3DUSAGE_MASK;
1437 desc.pool = pool;
1438 desc.width = width;
1439 desc.height = height;
1440 desc.depth = depth;
1441 desc.size = 0;
1442
1443 wined3d_mutex_lock();
1444 hr = wined3d_texture_create_3d(device->wined3d_device, &desc, levels,
1445 texture, &d3d9_texture_wined3d_parent_ops, &texture->wined3d_texture
1446#ifdef VBOX_WITH_WDDM
1447 , shared_handle
1448 , pavClientMem
1449#endif
1450 );
1451 wined3d_mutex_unlock();
1452 if (FAILED(hr))
1453 {
1454 WARN("Failed to create wined3d volume texture, hr %#x.\n", hr);
1455 return hr;
1456 }
1457
1458 texture->parent_device = &device->IDirect3DDevice9Ex_iface;
1459 IDirect3DDevice9Ex_AddRef(texture->parent_device);
1460
1461 return D3D_OK;
1462}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette