git.oblomov.eu Git - wine/blob - dlls/d3d9/shader.c

   1 /*
   2  * Copyright 2002-2003 Jason Edmeades
   3  *                     Raphael Junqueira
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include "d3d9_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
  24
  25 static HRESULT WINAPI d3d9_vertexshader_QueryInterface(IDirect3DVertexShader9 *iface, REFIID riid, void **object)
  26 {
  27     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
  28
  29     if (IsEqualGUID(riid, &IID_IDirect3DVertexShader9)
  30             || IsEqualGUID(riid, &IID_IUnknown))
  31     {
  32         IDirect3DVertexShader9_AddRef(iface);
  33         *object = iface;
  34         return S_OK;
  35     }
  36
  37     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  38
  39     *object = NULL;
  40     return E_NOINTERFACE;
  41 }
  42
  43 static ULONG WINAPI d3d9_vertexshader_AddRef(IDirect3DVertexShader9 *iface)
  44 {
  45     IDirect3DVertexShader9Impl *shader = (IDirect3DVertexShader9Impl *)iface;
  46     ULONG refcount = InterlockedIncrement(&shader->ref);
  47
  48     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  49
  50     if (refcount == 1)
  51     {
  52         IDirect3DDevice9Ex_AddRef(shader->parentDevice);
  53         wined3d_mutex_lock();
  54         IWineD3DVertexShader_AddRef(shader->wineD3DVertexShader);
  55         wined3d_mutex_unlock();
  56     }
  57
  58     return refcount;
  59 }
  60
  61 static ULONG WINAPI d3d9_vertexshader_Release(IDirect3DVertexShader9 *iface)
  62 {
  63     IDirect3DVertexShader9Impl *shader = (IDirect3DVertexShader9Impl *)iface;
  64     ULONG refcount = InterlockedDecrement(&shader->ref);
  65
  66     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  67
  68     if (!refcount)
  69     {
  70         IDirect3DDevice9Ex *device = shader->parentDevice;
  71
  72         wined3d_mutex_lock();
  73         IWineD3DVertexShader_Release(shader->wineD3DVertexShader);
  74         wined3d_mutex_unlock();
  75
  76         /* Release the device last, as it may cause the device to be destroyed. */
  77         IDirect3DDevice9Ex_Release(device);
  78     }
  79
  80     return refcount;
  81 }
  82
  83 static HRESULT WINAPI d3d9_vertexshader_GetDevice(IDirect3DVertexShader9 *iface, IDirect3DDevice9 **device)
  84 {
  85     TRACE("iface %p, device %p.\n", iface, device);
  86
  87     *device = (IDirect3DDevice9 *)((IDirect3DVertexShader9Impl *)iface)->parentDevice;
  88     IDirect3DDevice9_AddRef(*device);
  89
  90     TRACE("Returning device %p.\n", *device);
  91
  92     return D3D_OK;
  93 }
  94
  95 static HRESULT WINAPI d3d9_vertexshader_GetFunction(IDirect3DVertexShader9 *iface,
  96         void *data, UINT *data_size)
  97 {
  98     HRESULT hr;
  99
 100     TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size);
 101
 102     wined3d_mutex_lock();
 103     hr = IWineD3DVertexShader_GetFunction(((IDirect3DVertexShader9Impl *)iface)->wineD3DVertexShader, data, data_size);
 104     wined3d_mutex_unlock();
 105
 106     return hr;
 107 }
 108
 109 static const IDirect3DVertexShader9Vtbl d3d9_vertexshader_vtbl =
 110 {
 111     /* IUnknown */
 112     d3d9_vertexshader_QueryInterface,
 113     d3d9_vertexshader_AddRef,
 114     d3d9_vertexshader_Release,
 115     /* IDirect3DVertexShader9 */
 116     d3d9_vertexshader_GetDevice,
 117     d3d9_vertexshader_GetFunction,
 118 };
 119
 120 static void STDMETHODCALLTYPE d3d9_vertexshader_wined3d_object_destroyed(void *parent)
 121 {
 122     HeapFree(GetProcessHeap(), 0, parent);
 123 }
 124
 125 static const struct wined3d_parent_ops d3d9_vertexshader_wined3d_parent_ops =
 126 {
 127     d3d9_vertexshader_wined3d_object_destroyed,
 128 };
 129
 130 HRESULT vertexshader_init(IDirect3DVertexShader9Impl *shader, IDirect3DDevice9Impl *device, const DWORD *byte_code)
 131 {
 132     HRESULT hr;
 133
 134     shader->ref = 1;
 135     shader->lpVtbl = &d3d9_vertexshader_vtbl;
 136
 137     wined3d_mutex_lock();
 138     hr = IWineD3DDevice_CreateVertexShader(device->WineD3DDevice, byte_code, NULL,
 139             shader, &d3d9_vertexshader_wined3d_parent_ops, &shader->wineD3DVertexShader);
 140     wined3d_mutex_unlock();
 141     if (FAILED(hr))
 142     {
 143         WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
 144         return hr;
 145     }
 146
 147     shader->parentDevice = (IDirect3DDevice9Ex *)device;
 148     IDirect3DDevice9Ex_AddRef(shader->parentDevice);
 149
 150     return D3D_OK;
 151 }
 152
 153 static HRESULT WINAPI d3d9_pixelshader_QueryInterface(IDirect3DPixelShader9 *iface, REFIID riid, void **object)
 154 {
 155     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 156
 157     if (IsEqualGUID(riid, &IID_IDirect3DPixelShader9)
 158             || IsEqualGUID(riid, &IID_IUnknown))
 159     {
 160         IDirect3DPixelShader9_AddRef(iface);
 161         *object = iface;
 162         return S_OK;
 163     }
 164
 165     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 166
 167     *object = NULL;
 168     return E_NOINTERFACE;
 169 }
 170
 171 static ULONG WINAPI d3d9_pixelshader_AddRef(IDirect3DPixelShader9 *iface)
 172 {
 173     IDirect3DPixelShader9Impl *shader = (IDirect3DPixelShader9Impl *)iface;
 174     ULONG refcount = InterlockedIncrement(&shader->ref);
 175
 176     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 177
 178     if (refcount == 1)
 179     {
 180         IDirect3DDevice9Ex_AddRef(shader->parentDevice);
 181         wined3d_mutex_lock();
 182         IWineD3DPixelShader_AddRef(shader->wineD3DPixelShader);
 183         wined3d_mutex_unlock();
 184     }
 185
 186     return refcount;
 187 }
 188
 189 static ULONG WINAPI d3d9_pixelshader_Release(IDirect3DPixelShader9 *iface)
 190 {
 191     IDirect3DPixelShader9Impl *shader = (IDirect3DPixelShader9Impl *)iface;
 192     ULONG refcount = InterlockedDecrement(&shader->ref);
 193
 194     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 195
 196     if (!refcount)
 197     {
 198         IDirect3DDevice9Ex *device = shader->parentDevice;
 199
 200         wined3d_mutex_lock();
 201         IWineD3DPixelShader_Release(shader->wineD3DPixelShader);
 202         wined3d_mutex_unlock();
 203
 204         /* Release the device last, as it may cause the device to be destroyed. */
 205         IDirect3DDevice9Ex_Release(device);
 206     }
 207
 208     return refcount;
 209 }
 210
 211 static HRESULT WINAPI d3d9_pixelshader_GetDevice(IDirect3DPixelShader9 *iface, IDirect3DDevice9 **device)
 212 {
 213     TRACE("iface %p, device %p.\n", iface, device);
 214
 215     *device = (IDirect3DDevice9 *)((IDirect3DPixelShader9Impl *)iface)->parentDevice;
 216     IDirect3DDevice9_AddRef(*device);
 217
 218     TRACE("Returning device %p.\n", *device);
 219
 220     return D3D_OK;
 221 }
 222
 223 static HRESULT WINAPI d3d9_pixelshader_GetFunction(IDirect3DPixelShader9 *iface, void *data, UINT *data_size)
 224 {
 225     HRESULT hr;
 226
 227     TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size);
 228
 229     wined3d_mutex_lock();
 230     hr = IWineD3DPixelShader_GetFunction(((IDirect3DPixelShader9Impl *)iface)->wineD3DPixelShader, data, data_size);
 231     wined3d_mutex_unlock();
 232
 233     return hr;
 234 }
 235
 236 static const IDirect3DPixelShader9Vtbl d3d9_pixelshader_vtbl =
 237 {
 238     /* IUnknown */
 239     d3d9_pixelshader_QueryInterface,
 240     d3d9_pixelshader_AddRef,
 241     d3d9_pixelshader_Release,
 242     /* IDirect3DPixelShader9 */
 243     d3d9_pixelshader_GetDevice,
 244     d3d9_pixelshader_GetFunction,
 245 };
 246
 247 static void STDMETHODCALLTYPE d3d9_pixelshader_wined3d_object_destroyed(void *parent)
 248 {
 249     HeapFree(GetProcessHeap(), 0, parent);
 250 }
 251
 252 static const struct wined3d_parent_ops d3d9_pixelshader_wined3d_parent_ops =
 253 {
 254     d3d9_pixelshader_wined3d_object_destroyed,
 255 };
 256
 257 HRESULT pixelshader_init(IDirect3DPixelShader9Impl *shader, IDirect3DDevice9Impl *device, const DWORD *byte_code)
 258 {
 259     HRESULT hr;
 260
 261     shader->ref = 1;
 262     shader->lpVtbl = &d3d9_pixelshader_vtbl;
 263
 264     wined3d_mutex_lock();
 265     hr = IWineD3DDevice_CreatePixelShader(device->WineD3DDevice, byte_code, NULL, shader,
 266             &d3d9_pixelshader_wined3d_parent_ops, &shader->wineD3DPixelShader);
 267     wined3d_mutex_unlock();
 268     if (FAILED(hr))
 269     {
 270         WARN("Failed to created wined3d pixel shader, hr %#x.\n", hr);
 271         return hr;
 272     }
 273
 274     shader->parentDevice = (IDirect3DDevice9Ex *)device;
 275     IDirect3DDevice9Ex_AddRef(shader->parentDevice);
 276
 277     return D3D_OK;
 278 }