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 /* Do not call while under the GL lock. */
127 static ULONG WINAPI
IWineD3DVolumeImpl_Release(IWineD3DVolume
*iface
) {
128 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
130 TRACE("(%p) : Releasing from %d\n", This
, This
->resource
.ref
);
131 ref
= InterlockedDecrement(&This
->resource
.ref
);
135 resource_cleanup((IWineD3DResource
*)iface
);
136 This
->resource
.parent_ops
->wined3d_object_destroyed(This
->resource
.parent
);
137 HeapFree(GetProcessHeap(), 0, This
);
142 /* ****************************************************
143 IWineD3DVolume IWineD3DResource parts follow
144 **************************************************** */
145 static void * WINAPI
IWineD3DVolumeImpl_GetParent(IWineD3DVolume
*iface
)
147 TRACE("iface %p.\n", iface
);
149 return ((IWineD3DVolumeImpl
*)iface
)->resource
.parent
;
152 static HRESULT WINAPI
IWineD3DVolumeImpl_SetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
153 return resource_set_private_data((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
156 static HRESULT WINAPI
IWineD3DVolumeImpl_GetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
157 return resource_get_private_data((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
160 static HRESULT WINAPI
IWineD3DVolumeImpl_FreePrivateData(IWineD3DVolume
*iface
, REFGUID refguid
) {
161 return resource_free_private_data((IWineD3DResource
*)iface
, refguid
);
164 static DWORD WINAPI
IWineD3DVolumeImpl_SetPriority(IWineD3DVolume
*iface
, DWORD PriorityNew
) {
165 return resource_set_priority((IWineD3DResource
*)iface
, PriorityNew
);
168 static DWORD WINAPI
IWineD3DVolumeImpl_GetPriority(IWineD3DVolume
*iface
) {
169 return resource_get_priority((IWineD3DResource
*)iface
);
172 /* Do not call while under the GL lock. */
173 static void WINAPI
IWineD3DVolumeImpl_PreLoad(IWineD3DVolume
*iface
) {
174 FIXME("iface %p stub!\n", iface
);
177 /* Do not call while under the GL lock. */
178 static void WINAPI
IWineD3DVolumeImpl_UnLoad(IWineD3DVolume
*iface
)
180 TRACE("iface %p.\n", iface
);
182 /* The whole content is shadowed on This->resource.allocatedMemory, and
183 * the texture name is managed by the VolumeTexture container. */
185 resource_unload((IWineD3DResourceImpl
*)iface
);
188 static WINED3DRESOURCETYPE WINAPI
IWineD3DVolumeImpl_GetType(IWineD3DVolume
*iface
) {
189 return resource_get_type((IWineD3DResource
*)iface
);
192 static void WINAPI
IWineD3DVolumeImpl_GetDesc(IWineD3DVolume
*iface
, WINED3DVOLUME_DESC
*desc
)
194 IWineD3DVolumeImpl
*volume
= (IWineD3DVolumeImpl
*)iface
;
196 TRACE("iface %p, desc %p.\n", iface
, desc
);
198 desc
->Format
= volume
->resource
.format
->id
;
199 desc
->Type
= volume
->resource
.resourceType
;
200 desc
->Usage
= volume
->resource
.usage
;
201 desc
->Pool
= volume
->resource
.pool
;
202 desc
->Size
= volume
->resource
.size
; /* dx8 only */
203 desc
->Width
= volume
->currentDesc
.Width
;
204 desc
->Height
= volume
->currentDesc
.Height
;
205 desc
->Depth
= volume
->currentDesc
.Depth
;
208 static HRESULT WINAPI
IWineD3DVolumeImpl_LockBox(IWineD3DVolume
*iface
, WINED3DLOCKED_BOX
* pLockedVolume
, CONST WINED3DBOX
* pBox
, DWORD Flags
) {
209 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
210 FIXME("(%p) : pBox=%p stub\n", This
, pBox
);
212 if(!This
->resource
.allocatedMemory
) {
213 This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->resource
.size
);
216 /* fixme: should we really lock as such? */
217 TRACE("(%p) : box=%p, output pbox=%p, allMem=%p\n", This
, pBox
, pLockedVolume
, This
->resource
.allocatedMemory
);
219 pLockedVolume
->RowPitch
= This
->resource
.format
->byte_count
* This
->currentDesc
.Width
; /* Bytes / row */
220 pLockedVolume
->SlicePitch
= This
->resource
.format
->byte_count
221 * This
->currentDesc
.Width
* This
->currentDesc
.Height
; /* Bytes / slice */
223 TRACE("No box supplied - all is ok\n");
224 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
;
225 This
->lockedBox
.Left
= 0;
226 This
->lockedBox
.Top
= 0;
227 This
->lockedBox
.Front
= 0;
228 This
->lockedBox
.Right
= This
->currentDesc
.Width
;
229 This
->lockedBox
.Bottom
= This
->currentDesc
.Height
;
230 This
->lockedBox
.Back
= This
->currentDesc
.Depth
;
232 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
);
233 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
234 + (pLockedVolume
->SlicePitch
* pBox
->Front
) /* FIXME: is front < back or vica versa? */
235 + (pLockedVolume
->RowPitch
* pBox
->Top
)
236 + (pBox
->Left
* This
->resource
.format
->byte_count
);
237 This
->lockedBox
.Left
= pBox
->Left
;
238 This
->lockedBox
.Top
= pBox
->Top
;
239 This
->lockedBox
.Front
= pBox
->Front
;
240 This
->lockedBox
.Right
= pBox
->Right
;
241 This
->lockedBox
.Bottom
= pBox
->Bottom
;
242 This
->lockedBox
.Back
= pBox
->Back
;
245 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
250 volume_add_dirty_box(iface
, &This
->lockedBox
);
251 This
->container
->baseTexture
.texture_rgb
.dirty
= TRUE
;
252 This
->container
->baseTexture
.texture_srgb
.dirty
= TRUE
;
256 TRACE("returning memory@%p rpitch(%d) spitch(%d)\n", pLockedVolume
->pBits
, pLockedVolume
->RowPitch
, pLockedVolume
->SlicePitch
);
260 static HRESULT WINAPI
IWineD3DVolumeImpl_UnlockBox(IWineD3DVolume
*iface
) {
261 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
264 WARN("Trying to unlock unlocked volume %p.\n", iface
);
265 return WINED3DERR_INVALIDCALL
;
267 TRACE("(%p) : unlocking volume\n", This
);
268 This
->locked
= FALSE
;
269 memset(&This
->lockedBox
, 0, sizeof(RECT
));
273 /* Internal use functions follow : */
275 /* Context activation is done by the caller. */
276 static HRESULT WINAPI
IWineD3DVolumeImpl_LoadTexture(IWineD3DVolume
*iface
, int gl_level
, BOOL srgb_mode
)
278 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
279 const struct wined3d_gl_info
*gl_info
= &This
->resource
.device
->adapter
->gl_info
;
280 const struct wined3d_format
*format
= This
->resource
.format
;
282 TRACE("iface %p, level %u, srgb %#x, format %s (%#x).\n",
283 iface
, gl_level
, srgb_mode
, debug_d3dformat(format
->id
), format
->id
);
285 volume_bind_and_dirtify(iface
);
287 TRACE("Calling glTexImage3D %x level=%d, intfmt=%x, w=%d, h=%d,d=%d, 0=%d, glFmt=%x, glType=%x, Mem=%p\n",
288 GL_TEXTURE_3D
, gl_level
, format
->glInternal
, This
->currentDesc
.Width
, This
->currentDesc
.Height
,
289 This
->currentDesc
.Depth
, 0, format
->glFormat
, format
->glType
, This
->resource
.allocatedMemory
);
292 GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D
, gl_level
, format
->glInternal
,
293 This
->currentDesc
.Width
, This
->currentDesc
.Height
, This
->currentDesc
.Depth
,
294 0, format
->glFormat
, format
->glType
, This
->resource
.allocatedMemory
));
295 checkGLcall("glTexImage3D");
298 /* When adding code releasing This->resource.allocatedMemory to save data keep in mind that
299 * GL_UNPACK_CLIENT_STORAGE_APPLE is enabled by default if supported(GL_APPLE_client_storage).
300 * Thus do not release This->resource.allocatedMemory if GL_APPLE_client_storage is supported.
306 static const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl
=
309 IWineD3DVolumeImpl_QueryInterface
,
310 IWineD3DVolumeImpl_AddRef
,
311 IWineD3DVolumeImpl_Release
,
312 /* IWineD3DResource */
313 IWineD3DVolumeImpl_GetParent
,
314 IWineD3DVolumeImpl_SetPrivateData
,
315 IWineD3DVolumeImpl_GetPrivateData
,
316 IWineD3DVolumeImpl_FreePrivateData
,
317 IWineD3DVolumeImpl_SetPriority
,
318 IWineD3DVolumeImpl_GetPriority
,
319 IWineD3DVolumeImpl_PreLoad
,
320 IWineD3DVolumeImpl_UnLoad
,
321 IWineD3DVolumeImpl_GetType
,
323 IWineD3DVolumeImpl_GetDesc
,
324 IWineD3DVolumeImpl_LockBox
,
325 IWineD3DVolumeImpl_UnlockBox
,
326 /* Internal interface */
327 IWineD3DVolumeImpl_LoadTexture
,
330 HRESULT
volume_init(IWineD3DVolumeImpl
*volume
, IWineD3DDeviceImpl
*device
, UINT width
,
331 UINT height
, UINT depth
, DWORD usage
, enum wined3d_format_id format_id
, WINED3DPOOL pool
,
332 void *parent
, const struct wined3d_parent_ops
*parent_ops
)
334 const struct wined3d_gl_info
*gl_info
= &device
->adapter
->gl_info
;
335 const struct wined3d_format
*format
= wined3d_get_format(gl_info
, format_id
);
338 if (!gl_info
->supported
[EXT_TEXTURE3D
])
340 WARN("Volume cannot be created - no volume texture support.\n");
341 return WINED3DERR_INVALIDCALL
;
344 volume
->lpVtbl
= &IWineD3DVolume_Vtbl
;
346 hr
= resource_init((IWineD3DResource
*)volume
, WINED3DRTYPE_VOLUME
, device
,
347 width
* height
* depth
* format
->byte_count
, usage
, format
, pool
, parent
, parent_ops
);
350 WARN("Failed to initialize resource, returning %#x.\n", hr
);
354 volume
->currentDesc
.Width
= width
;
355 volume
->currentDesc
.Height
= height
;
356 volume
->currentDesc
.Depth
= depth
;
357 volume
->lockable
= TRUE
;
358 volume
->locked
= FALSE
;
359 memset(&volume
->lockedBox
, 0, sizeof(volume
->lockedBox
));
360 volume
->dirty
= TRUE
;
362 volume_add_dirty_box((IWineD3DVolume
*)volume
, NULL
);