wined3d: Explicitly check the shader type in shader_glsl_texldl().
[wine] / dlls / wined3d / resource.c
1 /*
2  * Copyright 2002-2004 Jason Edmeades
3  * Copyright 2003-2004 Raphael Junqueira
4  * Copyright 2004 Christian Costa
5  * Copyright 2005 Oliver Stieber
6  * Copyright 2009-2010 Henri Verbeet for CodeWeavers
7  *
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.
12  *
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.
17  *
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
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25 #include "wined3d_private.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
28
29 struct private_data
30 {
31     struct list entry;
32
33     GUID tag;
34     DWORD flags; /* DDSPD_* */
35
36     union
37     {
38         void *data;
39         IUnknown *object;
40     } ptr;
41
42     DWORD size;
43 };
44
45 static DWORD resource_access_from_pool(enum wined3d_pool pool)
46 {
47     switch (pool)
48     {
49         case WINED3D_POOL_DEFAULT:
50             return WINED3D_RESOURCE_ACCESS_GPU;
51
52         case WINED3D_POOL_MANAGED:
53             return WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU;
54
55         case WINED3D_POOL_SYSTEM_MEM:
56             return WINED3D_RESOURCE_ACCESS_CPU;
57
58         case WINED3D_POOL_SCRATCH:
59             return WINED3D_RESOURCE_ACCESS_SCRATCH;
60
61         default:
62             FIXME("Unhandled pool %#x.\n", pool);
63             return 0;
64     }
65 }
66
67 static void resource_check_usage(DWORD usage)
68 {
69     static const DWORD handled = WINED3DUSAGE_RENDERTARGET
70             | WINED3DUSAGE_DEPTHSTENCIL
71             | WINED3DUSAGE_DYNAMIC
72             | WINED3DUSAGE_AUTOGENMIPMAP
73             | WINED3DUSAGE_STATICDECL
74             | WINED3DUSAGE_OVERLAY;
75
76     if (usage & ~handled)
77         FIXME("Unhandled usage flags %#x.\n", usage & ~handled);
78 }
79
80 HRESULT resource_init(struct wined3d_resource *resource, struct wined3d_device *device,
81         enum wined3d_resource_type type, const struct wined3d_format *format,
82         enum wined3d_multisample_type multisample_type, UINT multisample_quality,
83         DWORD usage, enum wined3d_pool pool, UINT width, UINT height, UINT depth, UINT size,
84         void *parent, const struct wined3d_parent_ops *parent_ops,
85         const struct wined3d_resource_ops *resource_ops)
86 {
87     resource->ref = 1;
88     resource->device = device;
89     resource->type = type;
90     resource->format = format;
91     resource->multisample_type = multisample_type;
92     resource->multisample_quality = multisample_quality;
93     resource->usage = usage;
94     resource->pool = pool;
95     resource->access_flags = resource_access_from_pool(pool);
96     if (usage & WINED3DUSAGE_DYNAMIC)
97         resource->access_flags |= WINED3D_RESOURCE_ACCESS_CPU;
98     resource->width = width;
99     resource->height = height;
100     resource->depth = depth;
101     resource->size = size;
102     resource->priority = 0;
103     resource->parent = parent;
104     resource->parent_ops = parent_ops;
105     resource->resource_ops = resource_ops;
106     list_init(&resource->privateData);
107
108     resource_check_usage(usage);
109
110     if (size)
111     {
112         resource->heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size + RESOURCE_ALIGNMENT);
113         if (!resource->heapMemory)
114         {
115             ERR("Out of memory!\n");
116             return WINED3DERR_OUTOFVIDEOMEMORY;
117         }
118     }
119     else
120     {
121         resource->heapMemory = NULL;
122     }
123     resource->allocatedMemory = (BYTE *)(((ULONG_PTR)resource->heapMemory
124             + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
125
126     /* Check that we have enough video ram left */
127     if (pool == WINED3D_POOL_DEFAULT)
128     {
129         if (size > wined3d_device_get_available_texture_mem(device))
130         {
131             ERR("Out of adapter memory\n");
132             HeapFree(GetProcessHeap(), 0, resource->heapMemory);
133             return WINED3DERR_OUTOFVIDEOMEMORY;
134         }
135         adapter_adjust_memory(device->adapter, size);
136     }
137
138     device_resource_add(device, resource);
139
140     return WINED3D_OK;
141 }
142
143 void resource_cleanup(struct wined3d_resource *resource)
144 {
145     struct private_data *data;
146     struct list *e1, *e2;
147     HRESULT hr;
148
149     TRACE("Cleaning up resource %p.\n", resource);
150
151     if (resource->pool == WINED3D_POOL_DEFAULT)
152     {
153         TRACE("Decrementing device memory pool by %u.\n", resource->size);
154         adapter_adjust_memory(resource->device->adapter, 0 - resource->size);
155     }
156
157     LIST_FOR_EACH_SAFE(e1, e2, &resource->privateData)
158     {
159         data = LIST_ENTRY(e1, struct private_data, entry);
160         hr = wined3d_resource_free_private_data(resource, &data->tag);
161         if (FAILED(hr))
162             ERR("Failed to free private data when destroying resource %p, hr = %#x.\n", resource, hr);
163     }
164
165     HeapFree(GetProcessHeap(), 0, resource->heapMemory);
166     resource->allocatedMemory = 0;
167     resource->heapMemory = 0;
168
169     if (resource->device)
170         device_resource_released(resource->device, resource);
171 }
172
173 void resource_unload(struct wined3d_resource *resource)
174 {
175     if (resource->map_count)
176         ERR("Resource %p is being unloaded while mapped.\n", resource);
177
178     context_resource_unloaded(resource->device,
179             resource, resource->type);
180 }
181
182 static struct private_data *resource_find_private_data(const struct wined3d_resource *resource, REFGUID tag)
183 {
184     struct private_data *data;
185     struct list *entry;
186
187     TRACE("Searching for private data %s\n", debugstr_guid(tag));
188     LIST_FOR_EACH(entry, &resource->privateData)
189     {
190         data = LIST_ENTRY(entry, struct private_data, entry);
191         if (IsEqualGUID(&data->tag, tag)) {
192             TRACE("Found %p\n", data);
193             return data;
194         }
195     }
196     TRACE("Not found\n");
197     return NULL;
198 }
199
200 HRESULT CDECL wined3d_resource_set_private_data(struct wined3d_resource *resource, REFGUID guid,
201         const void *data, DWORD data_size, DWORD flags)
202 {
203     struct private_data *d;
204
205     TRACE("resource %p, riid %s, data %p, data_size %u, flags %#x.\n",
206             resource, debugstr_guid(guid), data, data_size, flags);
207
208     wined3d_resource_free_private_data(resource, guid);
209
210     d = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*d));
211     if (!d) return E_OUTOFMEMORY;
212
213     d->tag = *guid;
214     d->flags = flags;
215
216     if (flags & WINED3DSPD_IUNKNOWN)
217     {
218         if (data_size != sizeof(IUnknown *))
219         {
220             WARN("IUnknown data with size %u, returning WINED3DERR_INVALIDCALL.\n", data_size);
221             HeapFree(GetProcessHeap(), 0, d);
222             return WINED3DERR_INVALIDCALL;
223         }
224         d->ptr.object = (IUnknown *)data;
225         d->size = sizeof(IUnknown *);
226         IUnknown_AddRef(d->ptr.object);
227     }
228     else
229     {
230         d->ptr.data = HeapAlloc(GetProcessHeap(), 0, data_size);
231         if (!d->ptr.data)
232         {
233             HeapFree(GetProcessHeap(), 0, d);
234             return E_OUTOFMEMORY;
235         }
236         d->size = data_size;
237         memcpy(d->ptr.data, data, data_size);
238     }
239     list_add_tail(&resource->privateData, &d->entry);
240
241     return WINED3D_OK;
242 }
243
244 HRESULT CDECL wined3d_resource_get_private_data(const struct wined3d_resource *resource, REFGUID guid,
245         void *data, DWORD *data_size)
246 {
247     const struct private_data *d;
248
249     TRACE("resource %p, guid %s, data %p, data_size %p.\n",
250             resource, debugstr_guid(guid), data, data_size);
251
252     d = resource_find_private_data(resource, guid);
253     if (!d) return WINED3DERR_NOTFOUND;
254
255     if (*data_size < d->size)
256     {
257         *data_size = d->size;
258         return WINED3DERR_MOREDATA;
259     }
260
261     if (d->flags & WINED3DSPD_IUNKNOWN)
262     {
263         *(IUnknown **)data = d->ptr.object;
264         if (resource->device->wined3d->dxVersion != 7)
265         {
266             /* D3D8 and D3D9 addref the private data, DDraw does not. This
267              * can't be handled in ddraw because it doesn't know if the
268              * pointer returned is an IUnknown * or just a blob. */
269             IUnknown_AddRef(d->ptr.object);
270         }
271     }
272     else
273     {
274         memcpy(data, d->ptr.data, d->size);
275     }
276
277     return WINED3D_OK;
278 }
279 HRESULT CDECL wined3d_resource_free_private_data(struct wined3d_resource *resource, REFGUID guid)
280 {
281     struct private_data *data;
282
283     TRACE("resource %p, guid %s.\n", resource, debugstr_guid(guid));
284
285     data = resource_find_private_data(resource, guid);
286     if (!data) return WINED3DERR_NOTFOUND;
287
288     if (data->flags & WINED3DSPD_IUNKNOWN)
289     {
290         if (data->ptr.object)
291             IUnknown_Release(data->ptr.object);
292     }
293     else
294     {
295         HeapFree(GetProcessHeap(), 0, data->ptr.data);
296     }
297     list_remove(&data->entry);
298
299     HeapFree(GetProcessHeap(), 0, data);
300
301     return WINED3D_OK;
302 }
303
304 DWORD resource_set_priority(struct wined3d_resource *resource, DWORD priority)
305 {
306     DWORD prev = resource->priority;
307     resource->priority = priority;
308     TRACE("resource %p, new priority %u, returning old priority %u.\n", resource, priority, prev);
309     return prev;
310 }
311
312 DWORD resource_get_priority(const struct wined3d_resource *resource)
313 {
314     TRACE("resource %p, returning %u.\n", resource, resource->priority);
315     return resource->priority;
316 }
317
318 void * CDECL wined3d_resource_get_parent(const struct wined3d_resource *resource)
319 {
320     return resource->parent;
321 }
322
323 void CDECL wined3d_resource_get_desc(const struct wined3d_resource *resource, struct wined3d_resource_desc *desc)
324 {
325     desc->resource_type = resource->type;
326     desc->format = resource->format->id;
327     desc->multisample_type = resource->multisample_type;
328     desc->multisample_quality = resource->multisample_quality;
329     desc->usage = resource->usage;
330     desc->pool = resource->pool;
331     desc->width = resource->width;
332     desc->height = resource->height;
333     desc->depth = resource->depth;
334     desc->size = resource->size;
335 }