2 * IWineD3DResource Implementation
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2003-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
8 * Copyright 2009 Henri Verbeet for CodeWeavers
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wined3d_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
30 HRESULT
resource_init(IWineD3DResource
*iface
, WINED3DRESOURCETYPE resource_type
,
31 IWineD3DDeviceImpl
*device
, UINT size
, DWORD usage
, const struct GlPixelFormatDesc
*format_desc
,
32 WINED3DPOOL pool
, IUnknown
*parent
, const struct wined3d_parent_ops
*parent_ops
)
34 struct IWineD3DResourceClass
*resource
= &((IWineD3DResourceImpl
*)iface
)->resource
;
36 resource
->wineD3DDevice
= device
;
37 resource
->parent
= parent
;
38 resource
->resourceType
= resource_type
;
40 resource
->pool
= pool
;
41 resource
->format_desc
= format_desc
;
42 resource
->usage
= usage
;
43 resource
->size
= size
;
44 resource
->priority
= 0;
45 resource
->parent_ops
= parent_ops
;
46 list_init(&resource
->privateData
);
50 resource
->heapMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
+ RESOURCE_ALIGNMENT
);
51 if (!resource
->heapMemory
)
53 ERR("Out of memory!\n");
54 return WINED3DERR_OUTOFVIDEOMEMORY
;
59 resource
->heapMemory
= NULL
;
61 resource
->allocatedMemory
= (BYTE
*)(((ULONG_PTR
)resource
->heapMemory
+ (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
63 /* Check that we have enough video ram left */
64 if (pool
== WINED3DPOOL_DEFAULT
)
66 if (size
> IWineD3DDevice_GetAvailableTextureMem((IWineD3DDevice
*)device
))
68 ERR("Out of adapter memory\n");
69 HeapFree(GetProcessHeap(), 0, resource
->heapMemory
);
70 return WINED3DERR_OUTOFVIDEOMEMORY
;
72 WineD3DAdapterChangeGLRam(device
, size
);
75 device_resource_add(device
, iface
);
80 void resource_cleanup(IWineD3DResource
*iface
)
82 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
87 TRACE("(%p) Cleaning up resource\n", This
);
88 if (This
->resource
.pool
== WINED3DPOOL_DEFAULT
) {
89 TRACE("Decrementing device memory pool by %u\n", This
->resource
.size
);
90 WineD3DAdapterChangeGLRam(This
->resource
.wineD3DDevice
, -This
->resource
.size
);
93 LIST_FOR_EACH_SAFE(e1
, e2
, &This
->resource
.privateData
) {
94 data
= LIST_ENTRY(e1
, PrivateData
, entry
);
95 hr
= resource_free_private_data(iface
, &data
->tag
);
96 if(hr
!= WINED3D_OK
) {
97 ERR("Failed to free private data when destroying resource %p, hr = %08x\n", This
, hr
);
101 HeapFree(GetProcessHeap(), 0, This
->resource
.heapMemory
);
102 This
->resource
.allocatedMemory
= 0;
103 This
->resource
.heapMemory
= 0;
105 if (This
->resource
.wineD3DDevice
) device_resource_released(This
->resource
.wineD3DDevice
, iface
);
108 HRESULT
resource_get_device(IWineD3DResource
*iface
, IWineD3DDevice
** ppDevice
)
110 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
111 TRACE("(%p) : returning %p\n", This
, This
->resource
.wineD3DDevice
);
112 *ppDevice
= (IWineD3DDevice
*) This
->resource
.wineD3DDevice
;
113 IWineD3DDevice_AddRef(*ppDevice
);
117 static PrivateData
* resource_find_private_data(IWineD3DResourceImpl
*This
, REFGUID tag
)
122 TRACE("Searching for private data %s\n", debugstr_guid(tag
));
123 LIST_FOR_EACH(entry
, &This
->resource
.privateData
)
125 data
= LIST_ENTRY(entry
, PrivateData
, entry
);
126 if (IsEqualGUID(&data
->tag
, tag
)) {
127 TRACE("Found %p\n", data
);
131 TRACE("Not found\n");
135 HRESULT
resource_set_private_data(IWineD3DResource
*iface
, REFGUID refguid
,
136 const void *pData
, DWORD SizeOfData
, DWORD Flags
)
138 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
141 TRACE("(%p) : %s %p %d %d\n", This
, debugstr_guid(refguid
), pData
, SizeOfData
, Flags
);
142 resource_free_private_data(iface
, refguid
);
144 data
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*data
));
145 if (NULL
== data
) return E_OUTOFMEMORY
;
147 data
->tag
= *refguid
;
150 if (Flags
& WINED3DSPD_IUNKNOWN
) {
151 if(SizeOfData
!= sizeof(IUnknown
*)) {
152 WARN("IUnknown data with size %d, returning WINED3DERR_INVALIDCALL\n", SizeOfData
);
153 HeapFree(GetProcessHeap(), 0, data
);
154 return WINED3DERR_INVALIDCALL
;
156 data
->ptr
.object
= (LPUNKNOWN
)pData
;
157 data
->size
= sizeof(LPUNKNOWN
);
158 IUnknown_AddRef(data
->ptr
.object
);
162 data
->ptr
.data
= HeapAlloc(GetProcessHeap(), 0, SizeOfData
);
163 if (NULL
== data
->ptr
.data
) {
164 HeapFree(GetProcessHeap(), 0, data
);
165 return E_OUTOFMEMORY
;
167 data
->size
= SizeOfData
;
168 memcpy(data
->ptr
.data
, pData
, SizeOfData
);
170 list_add_tail(&This
->resource
.privateData
, &data
->entry
);
175 HRESULT
resource_get_private_data(IWineD3DResource
*iface
, REFGUID refguid
, void *pData
, DWORD
*pSizeOfData
)
177 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
180 TRACE("(%p) : %p %p %p\n", This
, refguid
, pData
, pSizeOfData
);
181 data
= resource_find_private_data(This
, refguid
);
182 if (data
== NULL
) return WINED3DERR_NOTFOUND
;
184 if (*pSizeOfData
< data
->size
) {
185 *pSizeOfData
= data
->size
;
186 return WINED3DERR_MOREDATA
;
189 if (data
->flags
& WINED3DSPD_IUNKNOWN
) {
190 *(LPUNKNOWN
*)pData
= data
->ptr
.object
;
191 if(((IWineD3DImpl
*) This
->resource
.wineD3DDevice
->wineD3D
)->dxVersion
!= 7) {
192 /* D3D8 and D3D9 addref the private data, DDraw does not. This can't be handled in
193 * ddraw because it doesn't know if the pointer returned is an IUnknown * or just a
196 IUnknown_AddRef(data
->ptr
.object
);
200 memcpy(pData
, data
->ptr
.data
, data
->size
);
205 HRESULT
resource_free_private_data(IWineD3DResource
*iface
, REFGUID refguid
)
207 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
210 TRACE("(%p) : %s\n", This
, debugstr_guid(refguid
));
211 data
= resource_find_private_data(This
, refguid
);
212 if (data
== NULL
) return WINED3DERR_NOTFOUND
;
214 if (data
->flags
& WINED3DSPD_IUNKNOWN
)
216 if (data
->ptr
.object
!= NULL
)
217 IUnknown_Release(data
->ptr
.object
);
219 HeapFree(GetProcessHeap(), 0, data
->ptr
.data
);
221 list_remove(&data
->entry
);
223 HeapFree(GetProcessHeap(), 0, data
);
228 DWORD
resource_set_priority(IWineD3DResource
*iface
, DWORD PriorityNew
)
230 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
231 DWORD PriorityOld
= This
->resource
.priority
;
232 This
->resource
.priority
= PriorityNew
;
233 TRACE("(%p) : new priority %d, returning old priority %d\n", This
, PriorityNew
, PriorityOld
);
237 DWORD
resource_get_priority(IWineD3DResource
*iface
)
239 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
240 TRACE("(%p) : returning %d\n", This
, This
->resource
.priority
);
241 return This
->resource
.priority
;
244 WINED3DRESOURCETYPE
resource_get_type(IWineD3DResource
*iface
)
246 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
247 TRACE("(%p) : returning %d\n", This
, This
->resource
.resourceType
);
248 return This
->resource
.resourceType
;
251 HRESULT
resource_get_parent(IWineD3DResource
*iface
, IUnknown
**pParent
)
253 IWineD3DResourceImpl
*This
= (IWineD3DResourceImpl
*)iface
;
254 IUnknown_AddRef(This
->resource
.parent
);
255 *pParent
= This
->resource
.parent
;
259 void dumpResources(struct list
*list
) {
260 IWineD3DResourceImpl
*resource
;
262 LIST_FOR_EACH_ENTRY(resource
, list
, IWineD3DResourceImpl
, resource
.resource_list_entry
) {
263 FIXME("Leftover resource %p with type %d,%s\n", resource
, IWineD3DResource_GetType((IWineD3DResource
*) resource
), debug_d3dresourcetype(IWineD3DResource_GetType((IWineD3DResource
*) resource
)));