VirtualBox

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

Last change on this file since 46521 was 46521, checked in by vboxsync, 12 years ago

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

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