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 "d3d9_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
  23
  24 static inline struct d3d9_vertexshader *impl_from_IDirect3DVertexShader9(IDirect3DVertexShader9 *iface)
  25 {
  26     return CONTAINING_RECORD(iface, struct d3d9_vertexshader, IDirect3DVertexShader9_iface);
  27 }
  28
  29 static HRESULT WINAPI d3d9_vertexshader_QueryInterface(IDirect3DVertexShader9 *iface, REFIID riid, void **out)
  30 {
  31     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  32
  33     if (IsEqualGUID(riid, &IID_IDirect3DVertexShader9)
  34             || IsEqualGUID(riid, &IID_IUnknown))
  35     {
  36         IDirect3DVertexShader9_AddRef(iface);
  37         *out = iface;
  38         return S_OK;
  39     }
  40
  41     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  42
  43     *out = NULL;
  44     return E_NOINTERFACE;
  45 }
  46
  47 static ULONG WINAPI d3d9_vertexshader_AddRef(IDirect3DVertexShader9 *iface)
  48 {
  49     struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface);
  50     ULONG refcount = InterlockedIncrement(&shader->refcount);
  51
  52     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  53
  54     if (refcount == 1)
  55     {
  56         IDirect3DDevice9Ex_AddRef(shader->parent_device);
  57         wined3d_mutex_lock();
  58         wined3d_shader_incref(shader->wined3d_shader);
  59         wined3d_mutex_unlock();
  60     }
  61
  62     return refcount;
  63 }
  64
  65 static ULONG WINAPI d3d9_vertexshader_Release(IDirect3DVertexShader9 *iface)
  66 {
  67     struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface);
  68     ULONG refcount = InterlockedDecrement(&shader->refcount);
  69
  70     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  71
  72     if (!refcount)
  73     {
  74         IDirect3DDevice9Ex *device = shader->parent_device;
  75
  76         wined3d_mutex_lock();
  77         wined3d_shader_decref(shader->wined3d_shader);
  78         wined3d_mutex_unlock();
  79
  80         /* Release the device last, as it may cause the device to be destroyed. */
  81         IDirect3DDevice9Ex_Release(device);
  82     }
  83
  84     return refcount;
  85 }
  86
  87 static HRESULT WINAPI d3d9_vertexshader_GetDevice(IDirect3DVertexShader9 *iface, IDirect3DDevice9 **device)
  88 {
  89     struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface);
  90
  91     TRACE("iface %p, device %p.\n", iface, device);
  92
  93     *device = (IDirect3DDevice9 *)shader->parent_device;
  94     IDirect3DDevice9_AddRef(*device);
  95
  96     TRACE("Returning device %p.\n", *device);
  97
  98     return D3D_OK;
  99 }
 100
 101 static HRESULT WINAPI d3d9_vertexshader_GetFunction(IDirect3DVertexShader9 *iface, void *data, UINT *data_size)
 102 {
 103     struct d3d9_vertexshader *shader = impl_from_IDirect3DVertexShader9(iface);
 104     HRESULT hr;
 105
 106     TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size);
 107
 108     wined3d_mutex_lock();
 109     hr = wined3d_shader_get_byte_code(shader->wined3d_shader, data, data_size);
 110     wined3d_mutex_unlock();
 111
 112     return hr;
 113 }
 114
 115 static const IDirect3DVertexShader9Vtbl d3d9_vertexshader_vtbl =
 116 {
 117     /* IUnknown */
 118     d3d9_vertexshader_QueryInterface,
 119     d3d9_vertexshader_AddRef,
 120     d3d9_vertexshader_Release,
 121     /* IDirect3DVertexShader9 */
 122     d3d9_vertexshader_GetDevice,
 123     d3d9_vertexshader_GetFunction,
 124 };
 125
 126 static void STDMETHODCALLTYPE d3d9_vertexshader_wined3d_object_destroyed(void *parent)
 127 {
 128     heap_free(parent);
 129 }
 130
 131 static const struct wined3d_parent_ops d3d9_vertexshader_wined3d_parent_ops =
 132 {
 133     d3d9_vertexshader_wined3d_object_destroyed,
 134 };
 135
 136 HRESULT vertexshader_init(struct d3d9_vertexshader *shader, struct d3d9_device *device, const DWORD *byte_code)
 137 {
 138     struct wined3d_shader_desc desc;
 139     HRESULT hr;
 140
 141     shader->refcount = 1;
 142     shader->IDirect3DVertexShader9_iface.lpVtbl = &d3d9_vertexshader_vtbl;
 143
 144     desc.byte_code = byte_code;
 145     desc.byte_code_size = ~(size_t)0;
 146
 147     wined3d_mutex_lock();
 148     hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
 149             &d3d9_vertexshader_wined3d_parent_ops, &shader->wined3d_shader);
 150     wined3d_mutex_unlock();
 151     if (FAILED(hr))
 152     {
 153         WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
 154         return hr;
 155     }
 156
 157     shader->parent_device = &device->IDirect3DDevice9Ex_iface;
 158     IDirect3DDevice9Ex_AddRef(shader->parent_device);
 159
 160     return D3D_OK;
 161 }
 162
 163 struct d3d9_vertexshader *unsafe_impl_from_IDirect3DVertexShader9(IDirect3DVertexShader9 *iface)
 164 {
 165     if (!iface)
 166         return NULL;
 167     if (iface->lpVtbl != &d3d9_vertexshader_vtbl)
 168         WARN("Vertex shader %p with the wrong vtbl %p\n", iface, iface->lpVtbl);
 169
 170     return impl_from_IDirect3DVertexShader9(iface);
 171 }
 172
 173 static inline struct d3d9_pixelshader *impl_from_IDirect3DPixelShader9(IDirect3DPixelShader9 *iface)
 174 {
 175     return CONTAINING_RECORD(iface, struct d3d9_pixelshader, IDirect3DPixelShader9_iface);
 176 }
 177
 178 static HRESULT WINAPI d3d9_pixelshader_QueryInterface(IDirect3DPixelShader9 *iface, REFIID riid, void **out)
 179 {
 180     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 181
 182     if (IsEqualGUID(riid, &IID_IDirect3DPixelShader9)
 183             || IsEqualGUID(riid, &IID_IUnknown))
 184     {
 185         IDirect3DPixelShader9_AddRef(iface);
 186         *out = iface;
 187         return S_OK;
 188     }
 189
 190     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 191
 192     *out = NULL;
 193     return E_NOINTERFACE;
 194 }
 195
 196 static ULONG WINAPI d3d9_pixelshader_AddRef(IDirect3DPixelShader9 *iface)
 197 {
 198     struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface);
 199     ULONG refcount = InterlockedIncrement(&shader->refcount);
 200
 201     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 202
 203     if (refcount == 1)
 204     {
 205         IDirect3DDevice9Ex_AddRef(shader->parent_device);
 206         wined3d_mutex_lock();
 207         wined3d_shader_incref(shader->wined3d_shader);
 208         wined3d_mutex_unlock();
 209     }
 210
 211     return refcount;
 212 }
 213
 214 static ULONG WINAPI d3d9_pixelshader_Release(IDirect3DPixelShader9 *iface)
 215 {
 216     struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface);
 217     ULONG refcount = InterlockedDecrement(&shader->refcount);
 218
 219     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 220
 221     if (!refcount)
 222     {
 223         IDirect3DDevice9Ex *device = shader->parent_device;
 224
 225         wined3d_mutex_lock();
 226         wined3d_shader_decref(shader->wined3d_shader);
 227         wined3d_mutex_unlock();
 228
 229         /* Release the device last, as it may cause the device to be destroyed. */
 230         IDirect3DDevice9Ex_Release(device);
 231     }
 232
 233     return refcount;
 234 }
 235
 236 static HRESULT WINAPI d3d9_pixelshader_GetDevice(IDirect3DPixelShader9 *iface, IDirect3DDevice9 **device)
 237 {
 238     struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface);
 239
 240     TRACE("iface %p, device %p.\n", iface, device);
 241
 242     *device = (IDirect3DDevice9 *)shader->parent_device;
 243     IDirect3DDevice9_AddRef(*device);
 244
 245     TRACE("Returning device %p.\n", *device);
 246
 247     return D3D_OK;
 248 }
 249
 250 static HRESULT WINAPI d3d9_pixelshader_GetFunction(IDirect3DPixelShader9 *iface, void *data, UINT *data_size)
 251 {
 252     struct d3d9_pixelshader *shader = impl_from_IDirect3DPixelShader9(iface);
 253     HRESULT hr;
 254
 255     TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size);
 256
 257     wined3d_mutex_lock();
 258     hr = wined3d_shader_get_byte_code(shader->wined3d_shader, data, data_size);
 259     wined3d_mutex_unlock();
 260
 261     return hr;
 262 }
 263
 264 static const IDirect3DPixelShader9Vtbl d3d9_pixelshader_vtbl =
 265 {
 266     /* IUnknown */
 267     d3d9_pixelshader_QueryInterface,
 268     d3d9_pixelshader_AddRef,
 269     d3d9_pixelshader_Release,
 270     /* IDirect3DPixelShader9 */
 271     d3d9_pixelshader_GetDevice,
 272     d3d9_pixelshader_GetFunction,
 273 };
 274
 275 static void STDMETHODCALLTYPE d3d9_pixelshader_wined3d_object_destroyed(void *parent)
 276 {
 277     heap_free(parent);
 278 }
 279
 280 static const struct wined3d_parent_ops d3d9_pixelshader_wined3d_parent_ops =
 281 {
 282     d3d9_pixelshader_wined3d_object_destroyed,
 283 };
 284
 285 HRESULT pixelshader_init(struct d3d9_pixelshader *shader, struct d3d9_device *device, const DWORD *byte_code)
 286 {
 287     struct wined3d_shader_desc desc;
 288     HRESULT hr;
 289
 290     shader->refcount = 1;
 291     shader->IDirect3DPixelShader9_iface.lpVtbl = &d3d9_pixelshader_vtbl;
 292
 293     desc.byte_code = byte_code;
 294     desc.byte_code_size = ~(size_t)0;
 295
 296     wined3d_mutex_lock();
 297     hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader,
 298             &d3d9_pixelshader_wined3d_parent_ops, &shader->wined3d_shader);
 299     wined3d_mutex_unlock();
 300     if (FAILED(hr))
 301     {
 302         WARN("Failed to created wined3d pixel shader, hr %#x.\n", hr);
 303         return hr;
 304     }
 305
 306     shader->parent_device = &device->IDirect3DDevice9Ex_iface;
 307     IDirect3DDevice9Ex_AddRef(shader->parent_device);
 308
 309     return D3D_OK;
 310 }
 311
 312 struct d3d9_pixelshader *unsafe_impl_from_IDirect3DPixelShader9(IDirect3DPixelShader9 *iface)
 313 {
 314     if (!iface)
 315         return NULL;
 316     if (iface->lpVtbl != &d3d9_pixelshader_vtbl)
 317         WARN("Pixel shader %p with the wrong vtbl %p\n", iface, iface->lpVtbl);
 318
 319     return impl_from_IDirect3DPixelShader9(iface);
 320 }