2 * IWineD3DVolume implementation
4 * Copyright 2002-2005 Jason Edmeades
5 * Copyright 2002-2005 Raphael Junqueira
6 * Copyright 2005 Oliver Stieber
7 * Copyright 2009 Henri Verbeet for CodeWeavers
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wined3d_private.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
28 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
30 /* Context activation is done by the caller. */
31 static void volume_bind_and_dirtify(IWineD3DVolume
*iface
) {
32 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
33 const struct wined3d_gl_info
*gl_info
= &This
->resource
.wineD3DDevice
->adapter
->gl_info
;
34 IWineD3DVolumeTexture
*texture
;
37 /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
38 * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
39 * gl states. The current texture unit should always be a valid one.
41 * To be more specific, this is tricky because we can implicitly be called
42 * from sampler() in state.c. This means we can't touch anything other than
43 * whatever happens to be the currently active texture, or we would risk
44 * marking already applied sampler states dirty again.
46 * TODO: Track the current active texture per GL context instead of using glGet
48 if (gl_info
->supported
[ARB_MULTITEXTURE
])
52 glGetIntegerv(GL_ACTIVE_TEXTURE
, &active_texture
);
54 active_sampler
= This
->resource
.wineD3DDevice
->rev_tex_unit_map
[active_texture
- GL_TEXTURE0_ARB
];
59 if (active_sampler
!= WINED3D_UNMAPPED_STAGE
)
61 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(active_sampler
));
64 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DVolumeTexture
, (void **)&texture
))) {
65 IWineD3DVolumeTexture_BindTexture(texture
, FALSE
);
66 IWineD3DVolumeTexture_Release(texture
);
68 ERR("Volume should be part of a volume texture\n");
72 void volume_add_dirty_box(IWineD3DVolume
*iface
, const WINED3DBOX
*dirty_box
)
74 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
79 This
->lockedBox
.Left
= min(This
->lockedBox
.Left
, dirty_box
->Left
);
80 This
->lockedBox
.Top
= min(This
->lockedBox
.Top
, dirty_box
->Top
);
81 This
->lockedBox
.Front
= min(This
->lockedBox
.Front
, dirty_box
->Front
);
82 This
->lockedBox
.Right
= max(This
->lockedBox
.Right
, dirty_box
->Right
);
83 This
->lockedBox
.Bottom
= max(This
->lockedBox
.Bottom
, dirty_box
->Bottom
);
84 This
->lockedBox
.Back
= max(This
->lockedBox
.Back
, dirty_box
->Back
);
88 This
->lockedBox
.Left
= 0;
89 This
->lockedBox
.Top
= 0;
90 This
->lockedBox
.Front
= 0;
91 This
->lockedBox
.Right
= This
->currentDesc
.Width
;
92 This
->lockedBox
.Bottom
= This
->currentDesc
.Height
;
93 This
->lockedBox
.Back
= This
->currentDesc
.Depth
;
97 /* *******************************************
98 IWineD3DVolume IUnknown parts follow
99 ******************************************* */
100 static HRESULT WINAPI
IWineD3DVolumeImpl_QueryInterface(IWineD3DVolume
*iface
, REFIID riid
, LPVOID
*ppobj
)
102 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
103 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
104 if (IsEqualGUID(riid
, &IID_IUnknown
)
105 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
106 || IsEqualGUID(riid
, &IID_IWineD3DVolume
)){
107 IUnknown_AddRef(iface
);
112 return E_NOINTERFACE
;
115 static ULONG WINAPI
IWineD3DVolumeImpl_AddRef(IWineD3DVolume
*iface
) {
116 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
117 TRACE("(%p) : AddRef increasing from %d\n", This
, This
->resource
.ref
);
118 return InterlockedIncrement(&This
->resource
.ref
);
121 static ULONG WINAPI
IWineD3DVolumeImpl_Release(IWineD3DVolume
*iface
) {
122 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
124 TRACE("(%p) : Releasing from %d\n", This
, This
->resource
.ref
);
125 ref
= InterlockedDecrement(&This
->resource
.ref
);
127 resource_cleanup((IWineD3DResource
*)iface
);
128 This
->resource
.parent_ops
->wined3d_object_destroyed(This
->resource
.parent
);
129 HeapFree(GetProcessHeap(), 0, This
);
134 /* ****************************************************
135 IWineD3DVolume IWineD3DResource parts follow
136 **************************************************** */
137 static HRESULT WINAPI
IWineD3DVolumeImpl_GetParent(IWineD3DVolume
*iface
, IUnknown
**pParent
) {
138 return resource_get_parent((IWineD3DResource
*)iface
, pParent
);
141 static HRESULT WINAPI
IWineD3DVolumeImpl_GetDevice(IWineD3DVolume
*iface
, IWineD3DDevice
** ppDevice
) {
142 return resource_get_device((IWineD3DResource
*)iface
, ppDevice
);
145 static HRESULT WINAPI
IWineD3DVolumeImpl_SetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
146 return resource_set_private_data((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
149 static HRESULT WINAPI
IWineD3DVolumeImpl_GetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
150 return resource_get_private_data((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
153 static HRESULT WINAPI
IWineD3DVolumeImpl_FreePrivateData(IWineD3DVolume
*iface
, REFGUID refguid
) {
154 return resource_free_private_data((IWineD3DResource
*)iface
, refguid
);
157 static DWORD WINAPI
IWineD3DVolumeImpl_SetPriority(IWineD3DVolume
*iface
, DWORD PriorityNew
) {
158 return resource_set_priority((IWineD3DResource
*)iface
, PriorityNew
);
161 static DWORD WINAPI
IWineD3DVolumeImpl_GetPriority(IWineD3DVolume
*iface
) {
162 return resource_get_priority((IWineD3DResource
*)iface
);
165 static void WINAPI
IWineD3DVolumeImpl_PreLoad(IWineD3DVolume
*iface
) {
166 FIXME("iface %p stub!\n", iface
);
169 static void WINAPI
IWineD3DVolumeImpl_UnLoad(IWineD3DVolume
*iface
) {
170 /* The whole content is shadowed on This->resource.allocatedMemory, and the
171 * texture name is managed by the VolumeTexture container
173 TRACE("(%p): Nothing to do\n", iface
);
176 static WINED3DRESOURCETYPE WINAPI
IWineD3DVolumeImpl_GetType(IWineD3DVolume
*iface
) {
177 return resource_get_type((IWineD3DResource
*)iface
);
180 /* *******************************************
181 IWineD3DVolume parts follow
182 ******************************************* */
183 static HRESULT WINAPI
IWineD3DVolumeImpl_GetContainer(IWineD3DVolume
*iface
, REFIID riid
, void** ppContainer
) {
184 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
186 TRACE("(This %p, riid %s, ppContainer %p)\n", This
, debugstr_guid(riid
), ppContainer
);
189 ERR("Called without a valid ppContainer.\n");
192 /* Although surfaces can be standalone, volumes can't */
193 if (!This
->container
) {
194 ERR("Volume without an container. Should not happen.\n");
197 TRACE("Relaying to QueryInterface\n");
198 return IUnknown_QueryInterface(This
->container
, riid
, ppContainer
);
201 static HRESULT WINAPI
IWineD3DVolumeImpl_GetDesc(IWineD3DVolume
*iface
, WINED3DVOLUME_DESC
* pDesc
) {
202 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
203 TRACE("(%p) : copying into %p\n", This
, pDesc
);
205 pDesc
->Format
= This
->resource
.format_desc
->format
;
206 pDesc
->Type
= This
->resource
.resourceType
;
207 pDesc
->Usage
= This
->resource
.usage
;
208 pDesc
->Pool
= This
->resource
.pool
;
209 pDesc
->Size
= This
->resource
.size
; /* dx8 only */
210 pDesc
->Width
= This
->currentDesc
.Width
;
211 pDesc
->Height
= This
->currentDesc
.Height
;
212 pDesc
->Depth
= This
->currentDesc
.Depth
;
217 static HRESULT WINAPI
IWineD3DVolumeImpl_LockBox(IWineD3DVolume
*iface
, WINED3DLOCKED_BOX
* pLockedVolume
, CONST WINED3DBOX
* pBox
, DWORD Flags
) {
218 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
219 FIXME("(%p) : pBox=%p stub\n", This
, pBox
);
221 if(!This
->resource
.allocatedMemory
) {
222 This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->resource
.size
);
225 /* fixme: should we really lock as such? */
226 TRACE("(%p) : box=%p, output pbox=%p, allMem=%p\n", This
, pBox
, pLockedVolume
, This
->resource
.allocatedMemory
);
228 pLockedVolume
->RowPitch
= This
->resource
.format_desc
->byte_count
* This
->currentDesc
.Width
; /* Bytes / row */
229 pLockedVolume
->SlicePitch
= This
->resource
.format_desc
->byte_count
230 * This
->currentDesc
.Width
* This
->currentDesc
.Height
; /* Bytes / slice */
232 TRACE("No box supplied - all is ok\n");
233 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
;
234 This
->lockedBox
.Left
= 0;
235 This
->lockedBox
.Top
= 0;
236 This
->lockedBox
.Front
= 0;
237 This
->lockedBox
.Right
= This
->currentDesc
.Width
;
238 This
->lockedBox
.Bottom
= This
->currentDesc
.Height
;
239 This
->lockedBox
.Back
= This
->currentDesc
.Depth
;
241 TRACE("Lock Box (%p) = l %d, t %d, r %d, b %d, fr %d, ba %d\n", pBox
, pBox
->Left
, pBox
->Top
, pBox
->Right
, pBox
->Bottom
, pBox
->Front
, pBox
->Back
);
242 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
243 + (pLockedVolume
->SlicePitch
* pBox
->Front
) /* FIXME: is front < back or vica versa? */
244 + (pLockedVolume
->RowPitch
* pBox
->Top
)
245 + (pBox
->Left
* This
->resource
.format_desc
->byte_count
);
246 This
->lockedBox
.Left
= pBox
->Left
;
247 This
->lockedBox
.Top
= pBox
->Top
;
248 This
->lockedBox
.Front
= pBox
->Front
;
249 This
->lockedBox
.Right
= pBox
->Right
;
250 This
->lockedBox
.Bottom
= pBox
->Bottom
;
251 This
->lockedBox
.Back
= pBox
->Back
;
254 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
259 * as seen in msdn docs
261 volume_add_dirty_box(iface
, &This
->lockedBox
);
263 /** Dirtify Container if needed */
264 if (NULL
!= This
->container
) {
266 IWineD3DVolumeTexture
*cont
= (IWineD3DVolumeTexture
*) This
->container
;
267 WINED3DRESOURCETYPE containerType
= IWineD3DBaseTexture_GetType((IWineD3DBaseTexture
*) cont
);
269 if (containerType
== WINED3DRTYPE_VOLUMETEXTURE
) {
270 IWineD3DBaseTextureImpl
* pTexture
= (IWineD3DBaseTextureImpl
*) cont
;
271 pTexture
->baseTexture
.texture_rgb
.dirty
= TRUE
;
272 pTexture
->baseTexture
.texture_srgb
.dirty
= TRUE
;
274 FIXME("Set dirty on container type %d\n", containerType
);
280 TRACE("returning memory@%p rpitch(%d) spitch(%d)\n", pLockedVolume
->pBits
, pLockedVolume
->RowPitch
, pLockedVolume
->SlicePitch
);
284 static HRESULT WINAPI
IWineD3DVolumeImpl_UnlockBox(IWineD3DVolume
*iface
) {
285 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
287 ERR("trying to lock unlocked volume@%p\n", This
);
288 return WINED3DERR_INVALIDCALL
;
290 TRACE("(%p) : unlocking volume\n", This
);
291 This
->locked
= FALSE
;
292 memset(&This
->lockedBox
, 0, sizeof(RECT
));
296 /* Internal use functions follow : */
298 static HRESULT WINAPI
IWineD3DVolumeImpl_SetContainer(IWineD3DVolume
*iface
, IWineD3DBase
* container
) {
299 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
301 TRACE("This %p, container %p\n", This
, container
);
303 /* We can't keep a reference to the container, since the container already keeps a reference to us. */
305 TRACE("Setting container to %p from %p\n", container
, This
->container
);
306 This
->container
= container
;
311 /* Context activation is done by the caller. */
312 static HRESULT WINAPI
IWineD3DVolumeImpl_LoadTexture(IWineD3DVolume
*iface
, int gl_level
, BOOL srgb_mode
) {
313 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
314 const struct GlPixelFormatDesc
*glDesc
= This
->resource
.format_desc
;
316 TRACE("(%p) : level %u, format %s (0x%08x)\n", This
, gl_level
, debug_d3dformat(glDesc
->format
), glDesc
->format
);
318 volume_bind_and_dirtify(iface
);
320 TRACE("Calling glTexImage3D %x level=%d, intfmt=%x, w=%d, h=%d,d=%d, 0=%d, glFmt=%x, glType=%x, Mem=%p\n",
324 This
->currentDesc
.Width
,
325 This
->currentDesc
.Height
,
326 This
->currentDesc
.Depth
,
330 This
->resource
.allocatedMemory
);
333 GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D
,
336 This
->currentDesc
.Width
,
337 This
->currentDesc
.Height
,
338 This
->currentDesc
.Depth
,
342 This
->resource
.allocatedMemory
));
343 checkGLcall("glTexImage3D");
346 /* When adding code releasing This->resource.allocatedMemory to save data keep in mind that
347 * GL_UNPACK_CLIENT_STORAGE_APPLE is enabled by default if supported(GL_APPLE_client_storage).
348 * Thus do not release This->resource.allocatedMemory if GL_APPLE_client_storage is supported.
354 static const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl
=
357 IWineD3DVolumeImpl_QueryInterface
,
358 IWineD3DVolumeImpl_AddRef
,
359 IWineD3DVolumeImpl_Release
,
360 /* IWineD3DResource */
361 IWineD3DVolumeImpl_GetParent
,
362 IWineD3DVolumeImpl_GetDevice
,
363 IWineD3DVolumeImpl_SetPrivateData
,
364 IWineD3DVolumeImpl_GetPrivateData
,
365 IWineD3DVolumeImpl_FreePrivateData
,
366 IWineD3DVolumeImpl_SetPriority
,
367 IWineD3DVolumeImpl_GetPriority
,
368 IWineD3DVolumeImpl_PreLoad
,
369 IWineD3DVolumeImpl_UnLoad
,
370 IWineD3DVolumeImpl_GetType
,
372 IWineD3DVolumeImpl_GetContainer
,
373 IWineD3DVolumeImpl_GetDesc
,
374 IWineD3DVolumeImpl_LockBox
,
375 IWineD3DVolumeImpl_UnlockBox
,
376 /* Internal interface */
377 IWineD3DVolumeImpl_LoadTexture
,
378 IWineD3DVolumeImpl_SetContainer
381 HRESULT
volume_init(IWineD3DVolumeImpl
*volume
, IWineD3DDeviceImpl
*device
, UINT width
,
382 UINT height
, UINT depth
, DWORD usage
, WINED3DFORMAT format
, WINED3DPOOL pool
,
383 IUnknown
*parent
, const struct wined3d_parent_ops
*parent_ops
)
385 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
386 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(format
, gl_info
);
389 if (!gl_info
->supported
[EXT_TEXTURE3D
])
391 WARN("Volume cannot be created - no volume texture support.\n");
392 return WINED3DERR_INVALIDCALL
;
395 volume
->lpVtbl
= &IWineD3DVolume_Vtbl
;
397 hr
= resource_init((IWineD3DResource
*)volume
, WINED3DRTYPE_VOLUME
, device
,
398 width
* height
* depth
* format_desc
->byte_count
, usage
, format_desc
, pool
, parent
, parent_ops
);
401 WARN("Failed to initialize resource, returning %#x.\n", hr
);
405 volume
->currentDesc
.Width
= width
;
406 volume
->currentDesc
.Height
= height
;
407 volume
->currentDesc
.Depth
= depth
;
408 volume
->lockable
= TRUE
;
409 volume
->locked
= FALSE
;
410 memset(&volume
->lockedBox
, 0, sizeof(volume
->lockedBox
));
411 volume
->dirty
= TRUE
;
413 volume_add_dirty_box((IWineD3DVolume
*)volume
, NULL
);