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
);
29 /* Context activation is done by the caller. */
30 static void volume_bind_and_dirtify(IWineD3DVolume
*iface
) {
31 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
32 const struct wined3d_gl_info
*gl_info
= &This
->resource
.device
->adapter
->gl_info
;
35 /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
36 * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
37 * gl states. The current texture unit should always be a valid one.
39 * To be more specific, this is tricky because we can implicitly be called
40 * from sampler() in state.c. This means we can't touch anything other than
41 * whatever happens to be the currently active texture, or we would risk
42 * marking already applied sampler states dirty again.
44 * TODO: Track the current active texture per GL context instead of using glGet
46 if (gl_info
->supported
[ARB_MULTITEXTURE
])
50 glGetIntegerv(GL_ACTIVE_TEXTURE
, &active_texture
);
52 active_sampler
= This
->resource
.device
->rev_tex_unit_map
[active_texture
- GL_TEXTURE0_ARB
];
57 if (active_sampler
!= WINED3D_UNMAPPED_STAGE
)
59 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.device
, STATE_SAMPLER(active_sampler
));
62 IWineD3DVolumeTexture_BindTexture((IWineD3DVolumeTexture
*)This
->container
, FALSE
);
65 void volume_add_dirty_box(IWineD3DVolume
*iface
, const WINED3DBOX
*dirty_box
)
67 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
72 This
->lockedBox
.Left
= min(This
->lockedBox
.Left
, dirty_box
->Left
);
73 This
->lockedBox
.Top
= min(This
->lockedBox
.Top
, dirty_box
->Top
);
74 This
->lockedBox
.Front
= min(This
->lockedBox
.Front
, dirty_box
->Front
);
75 This
->lockedBox
.Right
= max(This
->lockedBox
.Right
, dirty_box
->Right
);
76 This
->lockedBox
.Bottom
= max(This
->lockedBox
.Bottom
, dirty_box
->Bottom
);
77 This
->lockedBox
.Back
= max(This
->lockedBox
.Back
, dirty_box
->Back
);
81 This
->lockedBox
.Left
= 0;
82 This
->lockedBox
.Top
= 0;
83 This
->lockedBox
.Front
= 0;
84 This
->lockedBox
.Right
= This
->currentDesc
.Width
;
85 This
->lockedBox
.Bottom
= This
->currentDesc
.Height
;
86 This
->lockedBox
.Back
= This
->currentDesc
.Depth
;
90 void volume_set_container(IWineD3DVolumeImpl
*volume
, struct IWineD3DVolumeTextureImpl
*container
)
92 TRACE("volume %p, container %p.\n", volume
, container
);
94 volume
->container
= container
;
97 /* *******************************************
98 IWineD3DVolume IUnknown parts follow
99 ******************************************* */
100 static HRESULT WINAPI
IWineD3DVolumeImpl_QueryInterface(IWineD3DVolume
*iface
, REFIID riid
, void **object
)
102 TRACE("iface %p, riid %s, object %p.\n", iface
, debugstr_guid(riid
), object
);
104 if (IsEqualGUID(riid
, &IID_IWineD3DVolume
)
105 || IsEqualGUID(riid
, &IID_IWineD3DResource
)
106 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
107 || IsEqualGUID(riid
, &IID_IUnknown
))
109 IUnknown_AddRef(iface
);
114 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid
));
117 return E_NOINTERFACE
;
120 static ULONG WINAPI
IWineD3DVolumeImpl_AddRef(IWineD3DVolume
*iface
) {
121 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
122 TRACE("(%p) : AddRef increasing from %d\n", This
, This
->resource
.ref
);
123 return InterlockedIncrement(&This
->resource
.ref
);
126 static ULONG WINAPI
IWineD3DVolumeImpl_Release(IWineD3DVolume
*iface
) {
127 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
129 TRACE("(%p) : Releasing from %d\n", This
, This
->resource
.ref
);
130 ref
= InterlockedDecrement(&This
->resource
.ref
);
132 resource_cleanup((IWineD3DResource
*)iface
);
133 This
->resource
.parent_ops
->wined3d_object_destroyed(This
->resource
.parent
);
134 HeapFree(GetProcessHeap(), 0, This
);
139 /* ****************************************************
140 IWineD3DVolume IWineD3DResource parts follow
141 **************************************************** */
142 static HRESULT WINAPI
IWineD3DVolumeImpl_GetParent(IWineD3DVolume
*iface
, IUnknown
**pParent
) {
143 return resource_get_parent((IWineD3DResource
*)iface
, pParent
);
146 static HRESULT WINAPI
IWineD3DVolumeImpl_SetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
147 return resource_set_private_data((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
150 static HRESULT WINAPI
IWineD3DVolumeImpl_GetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
151 return resource_get_private_data((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
154 static HRESULT WINAPI
IWineD3DVolumeImpl_FreePrivateData(IWineD3DVolume
*iface
, REFGUID refguid
) {
155 return resource_free_private_data((IWineD3DResource
*)iface
, refguid
);
158 static DWORD WINAPI
IWineD3DVolumeImpl_SetPriority(IWineD3DVolume
*iface
, DWORD PriorityNew
) {
159 return resource_set_priority((IWineD3DResource
*)iface
, PriorityNew
);
162 static DWORD WINAPI
IWineD3DVolumeImpl_GetPriority(IWineD3DVolume
*iface
) {
163 return resource_get_priority((IWineD3DResource
*)iface
);
166 static void WINAPI
IWineD3DVolumeImpl_PreLoad(IWineD3DVolume
*iface
) {
167 FIXME("iface %p stub!\n", iface
);
170 static void WINAPI
IWineD3DVolumeImpl_UnLoad(IWineD3DVolume
*iface
)
172 TRACE("iface %p.\n", iface
);
174 /* The whole content is shadowed on This->resource.allocatedMemory, and
175 * the texture name is managed by the VolumeTexture container. */
177 resource_unload((IWineD3DResourceImpl
*)iface
);
180 static WINED3DRESOURCETYPE WINAPI
IWineD3DVolumeImpl_GetType(IWineD3DVolume
*iface
) {
181 return resource_get_type((IWineD3DResource
*)iface
);
184 /* *******************************************
185 IWineD3DVolume parts follow
186 ******************************************* */
187 static HRESULT WINAPI
IWineD3DVolumeImpl_GetDesc(IWineD3DVolume
*iface
, WINED3DVOLUME_DESC
*pDesc
)
189 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
190 TRACE("(%p) : copying into %p\n", This
, pDesc
);
192 pDesc
->Format
= This
->resource
.format_desc
->id
;
193 pDesc
->Type
= This
->resource
.resourceType
;
194 pDesc
->Usage
= This
->resource
.usage
;
195 pDesc
->Pool
= This
->resource
.pool
;
196 pDesc
->Size
= This
->resource
.size
; /* dx8 only */
197 pDesc
->Width
= This
->currentDesc
.Width
;
198 pDesc
->Height
= This
->currentDesc
.Height
;
199 pDesc
->Depth
= This
->currentDesc
.Depth
;
204 static HRESULT WINAPI
IWineD3DVolumeImpl_LockBox(IWineD3DVolume
*iface
, WINED3DLOCKED_BOX
* pLockedVolume
, CONST WINED3DBOX
* pBox
, DWORD Flags
) {
205 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
206 FIXME("(%p) : pBox=%p stub\n", This
, pBox
);
208 if(!This
->resource
.allocatedMemory
) {
209 This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->resource
.size
);
212 /* fixme: should we really lock as such? */
213 TRACE("(%p) : box=%p, output pbox=%p, allMem=%p\n", This
, pBox
, pLockedVolume
, This
->resource
.allocatedMemory
);
215 pLockedVolume
->RowPitch
= This
->resource
.format_desc
->byte_count
* This
->currentDesc
.Width
; /* Bytes / row */
216 pLockedVolume
->SlicePitch
= This
->resource
.format_desc
->byte_count
217 * This
->currentDesc
.Width
* This
->currentDesc
.Height
; /* Bytes / slice */
219 TRACE("No box supplied - all is ok\n");
220 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
;
221 This
->lockedBox
.Left
= 0;
222 This
->lockedBox
.Top
= 0;
223 This
->lockedBox
.Front
= 0;
224 This
->lockedBox
.Right
= This
->currentDesc
.Width
;
225 This
->lockedBox
.Bottom
= This
->currentDesc
.Height
;
226 This
->lockedBox
.Back
= This
->currentDesc
.Depth
;
228 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
);
229 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
230 + (pLockedVolume
->SlicePitch
* pBox
->Front
) /* FIXME: is front < back or vica versa? */
231 + (pLockedVolume
->RowPitch
* pBox
->Top
)
232 + (pBox
->Left
* This
->resource
.format_desc
->byte_count
);
233 This
->lockedBox
.Left
= pBox
->Left
;
234 This
->lockedBox
.Top
= pBox
->Top
;
235 This
->lockedBox
.Front
= pBox
->Front
;
236 This
->lockedBox
.Right
= pBox
->Right
;
237 This
->lockedBox
.Bottom
= pBox
->Bottom
;
238 This
->lockedBox
.Back
= pBox
->Back
;
241 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
246 volume_add_dirty_box(iface
, &This
->lockedBox
);
247 This
->container
->baseTexture
.texture_rgb
.dirty
= TRUE
;
248 This
->container
->baseTexture
.texture_srgb
.dirty
= TRUE
;
252 TRACE("returning memory@%p rpitch(%d) spitch(%d)\n", pLockedVolume
->pBits
, pLockedVolume
->RowPitch
, pLockedVolume
->SlicePitch
);
256 static HRESULT WINAPI
IWineD3DVolumeImpl_UnlockBox(IWineD3DVolume
*iface
) {
257 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
260 WARN("Trying to unlock unlocked volume %p.\n", iface
);
261 return WINED3DERR_INVALIDCALL
;
263 TRACE("(%p) : unlocking volume\n", This
);
264 This
->locked
= FALSE
;
265 memset(&This
->lockedBox
, 0, sizeof(RECT
));
269 /* Internal use functions follow : */
271 /* Context activation is done by the caller. */
272 static HRESULT WINAPI
IWineD3DVolumeImpl_LoadTexture(IWineD3DVolume
*iface
, int gl_level
, BOOL srgb_mode
)
274 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
275 const struct wined3d_gl_info
*gl_info
= &This
->resource
.device
->adapter
->gl_info
;
276 const struct wined3d_format_desc
*glDesc
= This
->resource
.format_desc
;
278 TRACE("iface %p, level %u, srgb %#x, format %s (%#x).\n",
279 iface
, gl_level
, srgb_mode
, debug_d3dformat(glDesc
->id
), glDesc
->id
);
281 volume_bind_and_dirtify(iface
);
283 TRACE("Calling glTexImage3D %x level=%d, intfmt=%x, w=%d, h=%d,d=%d, 0=%d, glFmt=%x, glType=%x, Mem=%p\n",
287 This
->currentDesc
.Width
,
288 This
->currentDesc
.Height
,
289 This
->currentDesc
.Depth
,
293 This
->resource
.allocatedMemory
);
296 GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D
,
299 This
->currentDesc
.Width
,
300 This
->currentDesc
.Height
,
301 This
->currentDesc
.Depth
,
305 This
->resource
.allocatedMemory
));
306 checkGLcall("glTexImage3D");
309 /* When adding code releasing This->resource.allocatedMemory to save data keep in mind that
310 * GL_UNPACK_CLIENT_STORAGE_APPLE is enabled by default if supported(GL_APPLE_client_storage).
311 * Thus do not release This->resource.allocatedMemory if GL_APPLE_client_storage is supported.
317 static const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl
=
320 IWineD3DVolumeImpl_QueryInterface
,
321 IWineD3DVolumeImpl_AddRef
,
322 IWineD3DVolumeImpl_Release
,
323 /* IWineD3DResource */
324 IWineD3DVolumeImpl_GetParent
,
325 IWineD3DVolumeImpl_SetPrivateData
,
326 IWineD3DVolumeImpl_GetPrivateData
,
327 IWineD3DVolumeImpl_FreePrivateData
,
328 IWineD3DVolumeImpl_SetPriority
,
329 IWineD3DVolumeImpl_GetPriority
,
330 IWineD3DVolumeImpl_PreLoad
,
331 IWineD3DVolumeImpl_UnLoad
,
332 IWineD3DVolumeImpl_GetType
,
334 IWineD3DVolumeImpl_GetDesc
,
335 IWineD3DVolumeImpl_LockBox
,
336 IWineD3DVolumeImpl_UnlockBox
,
337 /* Internal interface */
338 IWineD3DVolumeImpl_LoadTexture
,
341 HRESULT
volume_init(IWineD3DVolumeImpl
*volume
, IWineD3DDeviceImpl
*device
, UINT width
,
342 UINT height
, UINT depth
, DWORD usage
, enum wined3d_format_id format_id
, WINED3DPOOL pool
,
343 IUnknown
*parent
, const struct wined3d_parent_ops
*parent_ops
)
345 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
346 const struct wined3d_format_desc
*format_desc
= getFormatDescEntry(format_id
, gl_info
);
349 if (!gl_info
->supported
[EXT_TEXTURE3D
])
351 WARN("Volume cannot be created - no volume texture support.\n");
352 return WINED3DERR_INVALIDCALL
;
355 volume
->lpVtbl
= &IWineD3DVolume_Vtbl
;
357 hr
= resource_init((IWineD3DResource
*)volume
, WINED3DRTYPE_VOLUME
, device
,
358 width
* height
* depth
* format_desc
->byte_count
, usage
, format_desc
, pool
, parent
, parent_ops
);
361 WARN("Failed to initialize resource, returning %#x.\n", hr
);
365 volume
->currentDesc
.Width
= width
;
366 volume
->currentDesc
.Height
= height
;
367 volume
->currentDesc
.Depth
= depth
;
368 volume
->lockable
= TRUE
;
369 volume
->locked
= FALSE
;
370 memset(&volume
->lockedBox
, 0, sizeof(volume
->lockedBox
));
371 volume
->dirty
= TRUE
;
373 volume_add_dirty_box((IWineD3DVolume
*)volume
, NULL
);