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-2010 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
);
35 DWORD flags
; /* DDSPD_* */
46 static DWORD
resource_access_from_pool(WINED3DPOOL pool
)
50 case WINED3DPOOL_DEFAULT
:
51 return WINED3D_RESOURCE_ACCESS_GPU
;
53 case WINED3DPOOL_MANAGED
:
54 return WINED3D_RESOURCE_ACCESS_GPU
| WINED3D_RESOURCE_ACCESS_CPU
;
56 case WINED3DPOOL_SYSTEMMEM
:
57 return WINED3D_RESOURCE_ACCESS_CPU
;
59 case WINED3DPOOL_SCRATCH
:
60 return WINED3D_RESOURCE_ACCESS_SCRATCH
;
63 FIXME("Unhandled pool %#x.\n", pool
);
68 HRESULT
resource_init(struct wined3d_resource
*resource
, IWineD3DDeviceImpl
*device
,
69 WINED3DRESOURCETYPE resource_type
, const struct wined3d_format
*format
,
70 WINED3DMULTISAMPLE_TYPE multisample_type
, UINT multisample_quality
,
71 DWORD usage
, WINED3DPOOL pool
, UINT width
, UINT height
, UINT depth
, UINT size
,
72 void *parent
, const struct wined3d_parent_ops
*parent_ops
,
73 const struct wined3d_resource_ops
*resource_ops
)
76 resource
->device
= device
;
77 resource
->resourceType
= resource_type
;
78 resource
->format
= format
;
79 resource
->multisample_type
= multisample_type
;
80 resource
->multisample_quality
= multisample_quality
;
81 resource
->usage
= usage
;
82 resource
->pool
= pool
;
83 resource
->access_flags
= resource_access_from_pool(pool
);
84 if (usage
& WINED3DUSAGE_DYNAMIC
)
85 resource
->access_flags
|= WINED3D_RESOURCE_ACCESS_CPU
;
86 resource
->width
= width
;
87 resource
->height
= height
;
88 resource
->depth
= depth
;
89 resource
->size
= size
;
90 resource
->priority
= 0;
91 resource
->parent
= parent
;
92 resource
->parent_ops
= parent_ops
;
93 resource
->resource_ops
= resource_ops
;
94 list_init(&resource
->privateData
);
98 resource
->heapMemory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
+ RESOURCE_ALIGNMENT
);
99 if (!resource
->heapMemory
)
101 ERR("Out of memory!\n");
102 return WINED3DERR_OUTOFVIDEOMEMORY
;
107 resource
->heapMemory
= NULL
;
109 resource
->allocatedMemory
= (BYTE
*)(((ULONG_PTR
)resource
->heapMemory
110 + (RESOURCE_ALIGNMENT
- 1)) & ~(RESOURCE_ALIGNMENT
- 1));
112 /* Check that we have enough video ram left */
113 if (pool
== WINED3DPOOL_DEFAULT
)
115 if (size
> IWineD3DDevice_GetAvailableTextureMem((IWineD3DDevice
*)device
))
117 ERR("Out of adapter memory\n");
118 HeapFree(GetProcessHeap(), 0, resource
->heapMemory
);
119 return WINED3DERR_OUTOFVIDEOMEMORY
;
121 WineD3DAdapterChangeGLRam(device
, size
);
124 device_resource_add(device
, resource
);
129 void resource_cleanup(struct wined3d_resource
*resource
)
131 struct private_data
*data
;
132 struct list
*e1
, *e2
;
135 TRACE("Cleaning up resource %p.\n", resource
);
137 if (resource
->pool
== WINED3DPOOL_DEFAULT
)
139 TRACE("Decrementing device memory pool by %u.\n", resource
->size
);
140 WineD3DAdapterChangeGLRam(resource
->device
, 0 - resource
->size
);
143 LIST_FOR_EACH_SAFE(e1
, e2
, &resource
->privateData
)
145 data
= LIST_ENTRY(e1
, struct private_data
, entry
);
146 hr
= resource_free_private_data(resource
, &data
->tag
);
148 ERR("Failed to free private data when destroying resource %p, hr = %#x.\n", resource
, hr
);
151 HeapFree(GetProcessHeap(), 0, resource
->heapMemory
);
152 resource
->allocatedMemory
= 0;
153 resource
->heapMemory
= 0;
155 if (resource
->device
)
156 device_resource_released(resource
->device
, resource
);
159 void resource_unload(struct wined3d_resource
*resource
)
161 context_resource_unloaded(resource
->device
,
162 resource
, resource
->resourceType
);
165 static struct private_data
*resource_find_private_data(const struct wined3d_resource
*resource
, REFGUID tag
)
167 struct private_data
*data
;
170 TRACE("Searching for private data %s\n", debugstr_guid(tag
));
171 LIST_FOR_EACH(entry
, &resource
->privateData
)
173 data
= LIST_ENTRY(entry
, struct private_data
, entry
);
174 if (IsEqualGUID(&data
->tag
, tag
)) {
175 TRACE("Found %p\n", data
);
179 TRACE("Not found\n");
183 HRESULT
resource_set_private_data(struct wined3d_resource
*resource
, REFGUID guid
,
184 const void *data
, DWORD data_size
, DWORD flags
)
186 struct private_data
*d
;
188 TRACE("resource %p, riid %s, data %p, data_size %u, flags %#x.\n",
189 resource
, debugstr_guid(guid
), data
, data_size
, flags
);
191 resource_free_private_data(resource
, guid
);
193 d
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*d
));
194 if (!d
) return E_OUTOFMEMORY
;
199 if (flags
& WINED3DSPD_IUNKNOWN
)
201 if (data_size
!= sizeof(IUnknown
*))
203 WARN("IUnknown data with size %u, returning WINED3DERR_INVALIDCALL.\n", data_size
);
204 HeapFree(GetProcessHeap(), 0, d
);
205 return WINED3DERR_INVALIDCALL
;
207 d
->ptr
.object
= (IUnknown
*)data
;
208 d
->size
= sizeof(IUnknown
*);
209 IUnknown_AddRef(d
->ptr
.object
);
213 d
->ptr
.data
= HeapAlloc(GetProcessHeap(), 0, data_size
);
216 HeapFree(GetProcessHeap(), 0, d
);
217 return E_OUTOFMEMORY
;
220 memcpy(d
->ptr
.data
, data
, data_size
);
222 list_add_tail(&resource
->privateData
, &d
->entry
);
227 HRESULT
resource_get_private_data(const struct wined3d_resource
*resource
, REFGUID guid
, void *data
, DWORD
*data_size
)
229 const struct private_data
*d
;
231 TRACE("resource %p, guid %s, data %p, data_size %p.\n",
232 resource
, debugstr_guid(guid
), data
, data_size
);
234 d
= resource_find_private_data(resource
, guid
);
235 if (!d
) return WINED3DERR_NOTFOUND
;
237 if (*data_size
< d
->size
)
239 *data_size
= d
->size
;
240 return WINED3DERR_MOREDATA
;
243 if (d
->flags
& WINED3DSPD_IUNKNOWN
)
245 *(IUnknown
**)data
= d
->ptr
.object
;
246 if (resource
->device
->wined3d
->dxVersion
!= 7)
248 /* D3D8 and D3D9 addref the private data, DDraw does not. This
249 * can't be handled in ddraw because it doesn't know if the
250 * pointer returned is an IUnknown * or just a blob. */
251 IUnknown_AddRef(d
->ptr
.object
);
256 memcpy(data
, d
->ptr
.data
, d
->size
);
261 HRESULT
resource_free_private_data(struct wined3d_resource
*resource
, REFGUID guid
)
263 struct private_data
*data
;
265 TRACE("resource %p, guid %s.\n", resource
, debugstr_guid(guid
));
267 data
= resource_find_private_data(resource
, guid
);
268 if (!data
) return WINED3DERR_NOTFOUND
;
270 if (data
->flags
& WINED3DSPD_IUNKNOWN
)
272 if (data
->ptr
.object
)
273 IUnknown_Release(data
->ptr
.object
);
277 HeapFree(GetProcessHeap(), 0, data
->ptr
.data
);
279 list_remove(&data
->entry
);
281 HeapFree(GetProcessHeap(), 0, data
);
286 DWORD
resource_set_priority(struct wined3d_resource
*resource
, DWORD priority
)
288 DWORD prev
= resource
->priority
;
289 resource
->priority
= priority
;
290 TRACE("resource %p, new priority %u, returning old priority %u.\n", resource
, priority
, prev
);
294 DWORD
resource_get_priority(const struct wined3d_resource
*resource
)
296 TRACE("resource %p, returning %u.\n", resource
, resource
->priority
);
297 return resource
->priority
;
300 void * CDECL
wined3d_resource_get_parent(const struct wined3d_resource
*resource
)
302 return resource
->parent
;
305 void CDECL
wined3d_resource_get_desc(const struct wined3d_resource
*resource
, struct wined3d_resource_desc
*desc
)
307 desc
->resource_type
= resource
->resourceType
;
308 desc
->format
= resource
->format
->id
;
309 desc
->multisample_type
= resource
->multisample_type
;
310 desc
->multisample_quality
= resource
->multisample_quality
;
311 desc
->usage
= resource
->usage
;
312 desc
->pool
= resource
->pool
;
313 desc
->width
= resource
->width
;
314 desc
->height
= resource
->height
;
315 desc
->depth
= resource
->depth
;
316 desc
->size
= resource
->size
;