d3dcompiler: Add a stub parser.
[wine] / dlls / d3d8 / volume.c
1 /*
2  * IDirect3DVolume8 implementation
3  *
4  * Copyright 2005 Oliver Stieber
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "d3d8_private.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
25
26 static inline IDirect3DVolume8Impl *impl_from_IDirect3DVolume8(IDirect3DVolume8 *iface)
27 {
28     return CONTAINING_RECORD(iface, IDirect3DVolume8Impl, IDirect3DVolume8_iface);
29 }
30
31 static HRESULT WINAPI IDirect3DVolume8Impl_QueryInterface(IDirect3DVolume8 *iface, REFIID riid,
32         void **ppobj)
33 {
34     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), ppobj);
35
36     if (IsEqualGUID(riid, &IID_IDirect3DVolume8)
37             || IsEqualGUID(riid, &IID_IUnknown))
38     {
39         IUnknown_AddRef(iface);
40         *ppobj = iface;
41         return S_OK;
42     }
43
44     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
45
46     *ppobj = NULL;
47     return E_NOINTERFACE;
48 }
49
50 static ULONG WINAPI IDirect3DVolume8Impl_AddRef(IDirect3DVolume8 *iface)
51 {
52     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
53
54     TRACE("iface %p.\n", iface);
55
56     if (This->forwardReference) {
57         /* Forward to the containerParent */
58         TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
59         return IUnknown_AddRef(This->forwardReference);
60     } else {
61         /* No container, handle our own refcounting */
62         ULONG ref = InterlockedIncrement(&This->ref);
63
64         TRACE("%p increasing refcount to %u.\n", iface, ref);
65
66         if (ref == 1)
67         {
68             wined3d_mutex_lock();
69             wined3d_volume_incref(This->wined3d_volume);
70             wined3d_mutex_unlock();
71         }
72
73         return ref;
74     }
75 }
76
77 static ULONG WINAPI IDirect3DVolume8Impl_Release(IDirect3DVolume8 *iface)
78 {
79     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
80
81     TRACE("iface %p.\n", iface);
82
83     if (This->forwardReference) {
84         /* Forward to the containerParent */
85         TRACE("(%p) : Forwarding to %p\n", This, This->forwardReference);
86         return IUnknown_Release(This->forwardReference);
87     }
88     else {
89         /* No container, handle our own refcounting */
90         ULONG ref = InterlockedDecrement(&This->ref);
91
92         TRACE("%p decreasing refcount to %u.\n", iface, ref);
93
94         if (ref == 0) {
95             wined3d_mutex_lock();
96             wined3d_volume_decref(This->wined3d_volume);
97             wined3d_mutex_unlock();
98         }
99
100         return ref;
101     }
102 }
103
104 static HRESULT WINAPI IDirect3DVolume8Impl_GetDevice(IDirect3DVolume8 *iface,
105         IDirect3DDevice8 **device)
106 {
107     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
108     IDirect3DResource8 *resource;
109     HRESULT hr;
110
111     TRACE("iface %p, device %p.\n", iface, device);
112
113     hr = IUnknown_QueryInterface(This->forwardReference, &IID_IDirect3DResource8, (void **)&resource);
114     if (SUCCEEDED(hr))
115     {
116         hr = IDirect3DResource8_GetDevice(resource, device);
117         IDirect3DResource8_Release(resource);
118
119         TRACE("Returning device %p.\n", *device);
120     }
121
122     return hr;
123 }
124
125 static HRESULT WINAPI IDirect3DVolume8Impl_SetPrivateData(IDirect3DVolume8 *iface, REFGUID refguid,
126         const void *pData, DWORD SizeOfData, DWORD Flags)
127 {
128     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
129     struct wined3d_resource *resource;
130     HRESULT hr;
131
132     TRACE("iface %p, guid %s, data %p, data_size %u, flags %#x.\n",
133             iface, debugstr_guid(refguid), pData, SizeOfData, Flags);
134
135     wined3d_mutex_lock();
136     resource = wined3d_volume_get_resource(This->wined3d_volume);
137     hr = wined3d_resource_set_private_data(resource, refguid, pData, SizeOfData, Flags);
138     wined3d_mutex_unlock();
139
140     return hr;
141 }
142
143 static HRESULT WINAPI IDirect3DVolume8Impl_GetPrivateData(IDirect3DVolume8 *iface, REFGUID  refguid,
144         void *pData, DWORD *pSizeOfData)
145 {
146     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
147     struct wined3d_resource *resource;
148     HRESULT hr;
149
150     TRACE("iface %p, guid %s, data %p, data_size %p.\n",
151             iface, debugstr_guid(refguid), pData, pSizeOfData);
152
153     wined3d_mutex_lock();
154     resource = wined3d_volume_get_resource(This->wined3d_volume);
155     hr = wined3d_resource_get_private_data(resource, refguid, pData, pSizeOfData);
156     wined3d_mutex_unlock();
157
158     return hr;
159 }
160
161 static HRESULT WINAPI IDirect3DVolume8Impl_FreePrivateData(IDirect3DVolume8 *iface, REFGUID refguid)
162 {
163     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
164     struct wined3d_resource *resource;
165     HRESULT hr;
166
167     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(refguid));
168
169     wined3d_mutex_lock();
170     resource = wined3d_volume_get_resource(This->wined3d_volume);
171     hr = wined3d_resource_free_private_data(resource, refguid);
172     wined3d_mutex_unlock();
173
174     return hr;
175 }
176
177 static HRESULT WINAPI IDirect3DVolume8Impl_GetContainer(IDirect3DVolume8 *iface, REFIID riid,
178         void **ppContainer)
179 {
180     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
181     HRESULT res;
182
183     TRACE("iface %p, riid %s, container %p.\n",
184             iface, debugstr_guid(riid), ppContainer);
185
186     if (!This->container) return E_NOINTERFACE;
187
188     res = IUnknown_QueryInterface(This->container, riid, ppContainer);
189
190     TRACE("Returning ppContainer %p, *ppContainer %p\n", ppContainer, *ppContainer);
191
192     return res;
193 }
194
195 static HRESULT WINAPI IDirect3DVolume8Impl_GetDesc(IDirect3DVolume8 *iface, D3DVOLUME_DESC *desc)
196 {
197     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
198     struct wined3d_resource_desc wined3d_desc;
199     struct wined3d_resource *wined3d_resource;
200
201     TRACE("iface %p, desc %p.\n", iface, desc);
202
203     wined3d_mutex_lock();
204     wined3d_resource = wined3d_volume_get_resource(This->wined3d_volume);
205     wined3d_resource_get_desc(wined3d_resource, &wined3d_desc);
206     wined3d_mutex_unlock();
207
208     desc->Format = d3dformat_from_wined3dformat(wined3d_desc.format);
209     desc->Type = wined3d_desc.resource_type;
210     desc->Usage = wined3d_desc.usage & WINED3DUSAGE_MASK;
211     desc->Pool = wined3d_desc.pool;
212     desc->Size = wined3d_desc.size;
213     desc->Width = wined3d_desc.width;
214     desc->Height = wined3d_desc.height;
215     desc->Depth = wined3d_desc.depth;
216
217     return D3D_OK;
218 }
219
220 static HRESULT WINAPI IDirect3DVolume8Impl_LockBox(IDirect3DVolume8 *iface,
221         D3DLOCKED_BOX *locked_box, const D3DBOX *box, DWORD flags)
222 {
223     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
224     struct wined3d_map_desc map_desc;
225     HRESULT hr;
226
227     TRACE("iface %p, locked_box %p, box %p, flags %#x.\n",
228             iface, locked_box, box, flags);
229
230     wined3d_mutex_lock();
231     hr = wined3d_volume_map(This->wined3d_volume, &map_desc, (const struct wined3d_box *)box, flags);
232     wined3d_mutex_unlock();
233
234     locked_box->RowPitch = map_desc.row_pitch;
235     locked_box->SlicePitch = map_desc.slice_pitch;
236     locked_box->pBits = map_desc.data;
237
238     return hr;
239 }
240
241 static HRESULT WINAPI IDirect3DVolume8Impl_UnlockBox(IDirect3DVolume8 *iface)
242 {
243     IDirect3DVolume8Impl *This = impl_from_IDirect3DVolume8(iface);
244     HRESULT hr;
245
246     TRACE("iface %p.\n", iface);
247
248     wined3d_mutex_lock();
249     hr = wined3d_volume_unmap(This->wined3d_volume);
250     wined3d_mutex_unlock();
251
252     return hr;
253 }
254
255 static const IDirect3DVolume8Vtbl Direct3DVolume8_Vtbl =
256 {
257     /* IUnknown */
258     IDirect3DVolume8Impl_QueryInterface,
259     IDirect3DVolume8Impl_AddRef,
260     IDirect3DVolume8Impl_Release,
261     /* IDirect3DVolume8 */
262     IDirect3DVolume8Impl_GetDevice,
263     IDirect3DVolume8Impl_SetPrivateData,
264     IDirect3DVolume8Impl_GetPrivateData,
265     IDirect3DVolume8Impl_FreePrivateData,
266     IDirect3DVolume8Impl_GetContainer,
267     IDirect3DVolume8Impl_GetDesc,
268     IDirect3DVolume8Impl_LockBox,
269     IDirect3DVolume8Impl_UnlockBox
270 };
271
272 static void STDMETHODCALLTYPE volume_wined3d_object_destroyed(void *parent)
273 {
274     HeapFree(GetProcessHeap(), 0, parent);
275 }
276
277 static const struct wined3d_parent_ops d3d8_volume_wined3d_parent_ops =
278 {
279     volume_wined3d_object_destroyed,
280 };
281
282 HRESULT volume_init(IDirect3DVolume8Impl *volume, IDirect3DDevice8Impl *device, UINT width, UINT height,
283         UINT depth, DWORD usage, enum wined3d_format_id format, enum wined3d_pool pool)
284 {
285     HRESULT hr;
286
287     volume->IDirect3DVolume8_iface.lpVtbl = &Direct3DVolume8_Vtbl;
288     volume->ref = 1;
289
290     hr = wined3d_volume_create(device->wined3d_device, width, height, depth, usage,
291             format, pool, volume, &d3d8_volume_wined3d_parent_ops, &volume->wined3d_volume);
292     if (FAILED(hr))
293     {
294         WARN("Failed to create wined3d volume, hr %#x.\n", hr);
295         return hr;
296     }
297
298     return D3D_OK;
299 }