2 * IWineD3DVolume implementation
4 * Copyright 2002-2005 Jason Edmeades
5 * Copyright 2002-2005 Raphael Junqueira
6 * Copyright 2005 Oliver Stieber
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wined3d_private.h"
26 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface
);
27 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
29 static void volume_bind_and_dirtify(IWineD3DVolume
*iface
) {
30 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
31 IWineD3DVolumeTexture
*texture
;
34 /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
35 * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
36 * gl states. The current texture unit should always be a valid one.
38 * To be more specific, this is tricky because we can implicitly be called
39 * from sampler() in state.c. This means we can't touch anything other than
40 * whatever happens to be the currently active texture, or we would risk
41 * marking already applied sampler states dirty again.
43 * TODO: Track the current active texture per GL context instead of using glGet
45 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
48 glGetIntegerv(GL_ACTIVE_TEXTURE
, &active_texture
);
50 active_sampler
= This
->resource
.wineD3DDevice
->rev_tex_unit_map
[active_texture
- GL_TEXTURE0_ARB
];
55 if (active_sampler
!= -1) {
56 IWineD3DDeviceImpl_MarkStateDirty(This
->resource
.wineD3DDevice
, STATE_SAMPLER(active_sampler
));
59 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface
, &IID_IWineD3DVolumeTexture
, (void **)&texture
))) {
60 IWineD3DVolumeTexture_BindTexture(texture
, FALSE
);
61 IWineD3DVolumeTexture_Release(texture
);
63 ERR("Volume should be part of a volume texture\n");
67 void volume_add_dirty_box(IWineD3DVolume
*iface
, const WINED3DBOX
*dirty_box
)
69 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
74 This
->lockedBox
.Left
= min(This
->lockedBox
.Left
, dirty_box
->Left
);
75 This
->lockedBox
.Top
= min(This
->lockedBox
.Top
, dirty_box
->Top
);
76 This
->lockedBox
.Front
= min(This
->lockedBox
.Front
, dirty_box
->Front
);
77 This
->lockedBox
.Right
= max(This
->lockedBox
.Right
, dirty_box
->Right
);
78 This
->lockedBox
.Bottom
= max(This
->lockedBox
.Bottom
, dirty_box
->Bottom
);
79 This
->lockedBox
.Back
= max(This
->lockedBox
.Back
, dirty_box
->Back
);
83 This
->lockedBox
.Left
= 0;
84 This
->lockedBox
.Top
= 0;
85 This
->lockedBox
.Front
= 0;
86 This
->lockedBox
.Right
= This
->currentDesc
.Width
;
87 This
->lockedBox
.Bottom
= This
->currentDesc
.Height
;
88 This
->lockedBox
.Back
= This
->currentDesc
.Depth
;
92 /* *******************************************
93 IWineD3DVolume IUnknown parts follow
94 ******************************************* */
95 static HRESULT WINAPI
IWineD3DVolumeImpl_QueryInterface(IWineD3DVolume
*iface
, REFIID riid
, LPVOID
*ppobj
)
97 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
98 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
99 if (IsEqualGUID(riid
, &IID_IUnknown
)
100 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
101 || IsEqualGUID(riid
, &IID_IWineD3DVolume
)){
102 IUnknown_AddRef(iface
);
107 return E_NOINTERFACE
;
110 static ULONG WINAPI
IWineD3DVolumeImpl_AddRef(IWineD3DVolume
*iface
) {
111 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
112 TRACE("(%p) : AddRef increasing from %d\n", This
, This
->resource
.ref
);
113 return InterlockedIncrement(&This
->resource
.ref
);
116 static ULONG WINAPI
IWineD3DVolumeImpl_Release(IWineD3DVolume
*iface
) {
117 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
119 TRACE("(%p) : Releasing from %d\n", This
, This
->resource
.ref
);
120 ref
= InterlockedDecrement(&This
->resource
.ref
);
122 resource_cleanup((IWineD3DResource
*)iface
);
123 HeapFree(GetProcessHeap(), 0, This
);
128 /* ****************************************************
129 IWineD3DVolume IWineD3DResource parts follow
130 **************************************************** */
131 static HRESULT WINAPI
IWineD3DVolumeImpl_GetParent(IWineD3DVolume
*iface
, IUnknown
**pParent
) {
132 return resource_get_parent((IWineD3DResource
*)iface
, pParent
);
135 static HRESULT WINAPI
IWineD3DVolumeImpl_GetDevice(IWineD3DVolume
*iface
, IWineD3DDevice
** ppDevice
) {
136 return resource_get_device((IWineD3DResource
*)iface
, ppDevice
);
139 static HRESULT WINAPI
IWineD3DVolumeImpl_SetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, CONST
void* pData
, DWORD SizeOfData
, DWORD Flags
) {
140 return resource_set_private_data((IWineD3DResource
*)iface
, refguid
, pData
, SizeOfData
, Flags
);
143 static HRESULT WINAPI
IWineD3DVolumeImpl_GetPrivateData(IWineD3DVolume
*iface
, REFGUID refguid
, void* pData
, DWORD
* pSizeOfData
) {
144 return resource_get_private_data((IWineD3DResource
*)iface
, refguid
, pData
, pSizeOfData
);
147 static HRESULT WINAPI
IWineD3DVolumeImpl_FreePrivateData(IWineD3DVolume
*iface
, REFGUID refguid
) {
148 return resource_free_private_data((IWineD3DResource
*)iface
, refguid
);
151 static DWORD WINAPI
IWineD3DVolumeImpl_SetPriority(IWineD3DVolume
*iface
, DWORD PriorityNew
) {
152 return resource_set_priority((IWineD3DResource
*)iface
, PriorityNew
);
155 static DWORD WINAPI
IWineD3DVolumeImpl_GetPriority(IWineD3DVolume
*iface
) {
156 return resource_get_priority((IWineD3DResource
*)iface
);
159 static void WINAPI
IWineD3DVolumeImpl_PreLoad(IWineD3DVolume
*iface
) {
160 FIXME("iface %p stub!\n", iface
);
163 static void WINAPI
IWineD3DVolumeImpl_UnLoad(IWineD3DVolume
*iface
) {
164 /* The whole content is shadowed on This->resource.allocatedMemory, and the
165 * texture name is managed by the VolumeTexture container
167 TRACE("(%p): Nothing to do\n", iface
);
170 static WINED3DRESOURCETYPE WINAPI
IWineD3DVolumeImpl_GetType(IWineD3DVolume
*iface
) {
171 return resource_get_type((IWineD3DResource
*)iface
);
174 /* *******************************************
175 IWineD3DVolume parts follow
176 ******************************************* */
177 static HRESULT WINAPI
IWineD3DVolumeImpl_GetContainer(IWineD3DVolume
*iface
, REFIID riid
, void** ppContainer
) {
178 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
180 TRACE("(This %p, riid %s, ppContainer %p)\n", This
, debugstr_guid(riid
), ppContainer
);
183 ERR("Called without a valid ppContainer.\n");
186 /* Although surfaces can be standalone, volumes can't */
187 if (!This
->container
) {
188 ERR("Volume without an container. Should not happen.\n");
191 TRACE("Relaying to QueryInterface\n");
192 return IUnknown_QueryInterface(This
->container
, riid
, ppContainer
);
195 static HRESULT WINAPI
IWineD3DVolumeImpl_GetDesc(IWineD3DVolume
*iface
, WINED3DVOLUME_DESC
* pDesc
) {
196 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
197 TRACE("(%p) : copying into %p\n", This
, pDesc
);
199 pDesc
->Format
= This
->resource
.format_desc
->format
;
200 pDesc
->Type
= This
->resource
.resourceType
;
201 pDesc
->Usage
= This
->resource
.usage
;
202 pDesc
->Pool
= This
->resource
.pool
;
203 pDesc
->Size
= This
->resource
.size
; /* dx8 only */
204 pDesc
->Width
= This
->currentDesc
.Width
;
205 pDesc
->Height
= This
->currentDesc
.Height
;
206 pDesc
->Depth
= This
->currentDesc
.Depth
;
211 static HRESULT WINAPI
IWineD3DVolumeImpl_LockBox(IWineD3DVolume
*iface
, WINED3DLOCKED_BOX
* pLockedVolume
, CONST WINED3DBOX
* pBox
, DWORD Flags
) {
212 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
213 FIXME("(%p) : pBox=%p stub\n", This
, pBox
);
215 if(!This
->resource
.allocatedMemory
) {
216 This
->resource
.allocatedMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, This
->resource
.size
);
219 /* fixme: should we really lock as such? */
220 TRACE("(%p) : box=%p, output pbox=%p, allMem=%p\n", This
, pBox
, pLockedVolume
, This
->resource
.allocatedMemory
);
222 pLockedVolume
->RowPitch
= This
->resource
.format_desc
->byte_count
* This
->currentDesc
.Width
; /* Bytes / row */
223 pLockedVolume
->SlicePitch
= This
->resource
.format_desc
->byte_count
224 * This
->currentDesc
.Width
* This
->currentDesc
.Height
; /* Bytes / slice */
226 TRACE("No box supplied - all is ok\n");
227 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
;
228 This
->lockedBox
.Left
= 0;
229 This
->lockedBox
.Top
= 0;
230 This
->lockedBox
.Front
= 0;
231 This
->lockedBox
.Right
= This
->currentDesc
.Width
;
232 This
->lockedBox
.Bottom
= This
->currentDesc
.Height
;
233 This
->lockedBox
.Back
= This
->currentDesc
.Depth
;
235 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
);
236 pLockedVolume
->pBits
= This
->resource
.allocatedMemory
237 + (pLockedVolume
->SlicePitch
* pBox
->Front
) /* FIXME: is front < back or vica versa? */
238 + (pLockedVolume
->RowPitch
* pBox
->Top
)
239 + (pBox
->Left
* This
->resource
.format_desc
->byte_count
);
240 This
->lockedBox
.Left
= pBox
->Left
;
241 This
->lockedBox
.Top
= pBox
->Top
;
242 This
->lockedBox
.Front
= pBox
->Front
;
243 This
->lockedBox
.Right
= pBox
->Right
;
244 This
->lockedBox
.Bottom
= pBox
->Bottom
;
245 This
->lockedBox
.Back
= pBox
->Back
;
248 if (Flags
& (WINED3DLOCK_NO_DIRTY_UPDATE
| WINED3DLOCK_READONLY
)) {
253 * as seen in msdn docs
255 volume_add_dirty_box(iface
, &This
->lockedBox
);
257 /** Dirtify Container if needed */
258 if (NULL
!= This
->container
) {
260 IWineD3DVolumeTexture
*cont
= (IWineD3DVolumeTexture
*) This
->container
;
261 WINED3DRESOURCETYPE containerType
= IWineD3DBaseTexture_GetType((IWineD3DBaseTexture
*) cont
);
263 if (containerType
== WINED3DRTYPE_VOLUMETEXTURE
) {
264 IWineD3DBaseTextureImpl
* pTexture
= (IWineD3DBaseTextureImpl
*) cont
;
265 pTexture
->baseTexture
.dirty
= TRUE
;
267 FIXME("Set dirty on container type %d\n", containerType
);
273 TRACE("returning memory@%p rpitch(%d) spitch(%d)\n", pLockedVolume
->pBits
, pLockedVolume
->RowPitch
, pLockedVolume
->SlicePitch
);
277 static HRESULT WINAPI
IWineD3DVolumeImpl_UnlockBox(IWineD3DVolume
*iface
) {
278 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
280 ERR("trying to lock unlocked volume@%p\n", This
);
281 return WINED3DERR_INVALIDCALL
;
283 TRACE("(%p) : unlocking volume\n", This
);
284 This
->locked
= FALSE
;
285 memset(&This
->lockedBox
, 0, sizeof(RECT
));
289 /* Internal use functions follow : */
291 static HRESULT WINAPI
IWineD3DVolumeImpl_SetContainer(IWineD3DVolume
*iface
, IWineD3DBase
* container
) {
292 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
294 TRACE("This %p, container %p\n", This
, container
);
296 /* We can't keep a reference to the container, since the container already keeps a reference to us. */
298 TRACE("Setting container to %p from %p\n", container
, This
->container
);
299 This
->container
= container
;
304 static HRESULT WINAPI
IWineD3DVolumeImpl_LoadTexture(IWineD3DVolume
*iface
, int gl_level
, BOOL srgb_mode
) {
305 IWineD3DVolumeImpl
*This
= (IWineD3DVolumeImpl
*)iface
;
306 const struct GlPixelFormatDesc
*glDesc
= This
->resource
.format_desc
;
308 TRACE("(%p) : level %u, format %s (0x%08x)\n", This
, gl_level
, debug_d3dformat(glDesc
->format
), glDesc
->format
);
310 volume_bind_and_dirtify(iface
);
312 TRACE("Calling glTexImage3D %x level=%d, intfmt=%x, w=%d, h=%d,d=%d, 0=%d, glFmt=%x, glType=%x, Mem=%p\n",
316 This
->currentDesc
.Width
,
317 This
->currentDesc
.Height
,
318 This
->currentDesc
.Depth
,
322 This
->resource
.allocatedMemory
);
325 GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D
,
328 This
->currentDesc
.Width
,
329 This
->currentDesc
.Height
,
330 This
->currentDesc
.Depth
,
334 This
->resource
.allocatedMemory
));
335 checkGLcall("glTexImage3D");
338 /* When adding code releasing This->resource.allocatedMemory to save data keep in mind that
339 * GL_UNPACK_CLIENT_STORAGE_APPLE is enabled by default if supported(GL_APPLE_client_storage).
340 * Thus do not release This->resource.allocatedMemory if GL_APPLE_client_storage is supported.
346 const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl
=
349 IWineD3DVolumeImpl_QueryInterface
,
350 IWineD3DVolumeImpl_AddRef
,
351 IWineD3DVolumeImpl_Release
,
352 /* IWineD3DResource */
353 IWineD3DVolumeImpl_GetParent
,
354 IWineD3DVolumeImpl_GetDevice
,
355 IWineD3DVolumeImpl_SetPrivateData
,
356 IWineD3DVolumeImpl_GetPrivateData
,
357 IWineD3DVolumeImpl_FreePrivateData
,
358 IWineD3DVolumeImpl_SetPriority
,
359 IWineD3DVolumeImpl_GetPriority
,
360 IWineD3DVolumeImpl_PreLoad
,
361 IWineD3DVolumeImpl_UnLoad
,
362 IWineD3DVolumeImpl_GetType
,
364 IWineD3DVolumeImpl_GetContainer
,
365 IWineD3DVolumeImpl_GetDesc
,
366 IWineD3DVolumeImpl_LockBox
,
367 IWineD3DVolumeImpl_UnlockBox
,
368 /* Internal interface */
369 IWineD3DVolumeImpl_LoadTexture
,
370 IWineD3DVolumeImpl_SetContainer