wined3d: Remove COM from the shader implementation.

dlls/d3d10core/d3d10core_private.h

@@ -169,7 +169,7 @@ struct d3d10_vertex_shader
     const struct ID3D10VertexShaderVtbl *vtbl;
     LONG refcount;
 
-    IWineD3DBaseShader *wined3d_shader;
+    struct wined3d_shader *wined3d_shader;
     struct wined3d_shader_signature output_signature;
 };
 
@@ -182,7 +182,7 @@ struct d3d10_geometry_shader
     const struct ID3D10GeometryShaderVtbl *vtbl;
     LONG refcount;
 
-    IWineD3DBaseShader *wined3d_shader;
+    struct wined3d_shader *wined3d_shader;
     struct wined3d_shader_signature output_signature;
 };
 
@@ -195,7 +195,7 @@ struct d3d10_pixel_shader
     const struct ID3D10PixelShaderVtbl *vtbl;
     LONG refcount;
 
-    IWineD3DBaseShader *wined3d_shader;
+    struct wined3d_shader *wined3d_shader;
     struct wined3d_shader_signature output_signature;
 };
 

dlls/d3d10core/shader.c

@@ -162,7 +162,7 @@ static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_AddRef(ID3D10VertexShader *if
     TRACE("%p increasing refcount to %u\n", This, refcount);
 
     if (refcount == 1)
-        IWineD3DBaseShader_AddRef(This->wined3d_shader);
+        wined3d_shader_incref(This->wined3d_shader);
 
     return refcount;
 }
@@ -175,7 +175,7 @@ static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_Release(ID3D10VertexShader *i
     TRACE("%p decreasing refcount to %u\n", This, refcount);
 
     if (!refcount)
-        IWineD3DBaseShader_Release(This->wined3d_shader);
+        wined3d_shader_decref(This->wined3d_shader);
 
     return refcount;
 }
@@ -307,7 +307,7 @@ static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_Release(ID3D10GeometryShade
     TRACE("%p decreasing refcount to %u\n", This, refcount);
 
     if (!refcount)
-        IWineD3DBaseShader_Release(This->wined3d_shader);
+        wined3d_shader_decref(This->wined3d_shader);
 
     return refcount;
 }
@@ -429,7 +429,7 @@ static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_AddRef(ID3D10PixelShader *ifac
     TRACE("%p increasing refcount to %u\n", This, refcount);
 
     if (refcount == 1)
-        IWineD3DBaseShader_AddRef(This->wined3d_shader);
+        wined3d_shader_incref(This->wined3d_shader);
 
     return refcount;
 }
@@ -442,7 +442,7 @@ static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_Release(ID3D10PixelShader *ifa
     TRACE("%p decreasing refcount to %u\n", This, refcount);
 
     if (!refcount)
-        IWineD3DBaseShader_Release(This->wined3d_shader);
+        wined3d_shader_decref(This->wined3d_shader);
 
     return refcount;
 }

dlls/d3d8/d3d8_private.h

@@ -472,7 +472,7 @@ struct IDirect3DVertexShader8Impl {
   IDirect3DVertexShader8            IDirect3DVertexShader8_iface;
   LONG                              ref;
   IDirect3DVertexDeclaration8 *vertex_declaration;
-  IWineD3DBaseShader *wined3d_shader;
+  struct wined3d_shader *wined3d_shader;
 };
 
 HRESULT vertexshader_init(IDirect3DVertexShader8Impl *shader, IDirect3DDevice8Impl *device,
@@ -487,7 +487,7 @@ typedef struct IDirect3DPixelShader8Impl {
     IDirect3DPixelShader8            IDirect3DPixelShader8_iface;
     LONG                             ref;
     DWORD handle;
-    IWineD3DBaseShader *wined3d_shader;
+    struct wined3d_shader *wined3d_shader;
 } IDirect3DPixelShader8Impl;
 
 HRESULT pixelshader_init(IDirect3DPixelShader8Impl *shader, IDirect3DDevice8Impl *device,
@@ -495,7 +495,7 @@ HRESULT pixelshader_init(IDirect3DPixelShader8Impl *shader, IDirect3DDevice8Impl
 
 D3DFORMAT d3dformat_from_wined3dformat(enum wined3d_format_id format) DECLSPEC_HIDDEN;
 enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) DECLSPEC_HIDDEN;
-void load_local_constants(const DWORD *d3d8_elements, IWineD3DBaseShader *wined3d_vertex_shader) DECLSPEC_HIDDEN;
+void load_local_constants(const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader) DECLSPEC_HIDDEN;
 size_t parse_token(const DWORD *pToken) DECLSPEC_HIDDEN;
 
 #endif /* __WINE_D3DX8_PRIVATE_H */

dlls/d3d8/device.c

@@ -2121,12 +2121,11 @@ static HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(IDirect3DDevice8 *ifa
     return hr;
 }
 
-static HRESULT  WINAPI  IDirect3DDevice8Impl_DeleteVertexShader(IDirect3DDevice8 *iface,
-        DWORD pShader)
+static HRESULT WINAPI IDirect3DDevice8Impl_DeleteVertexShader(IDirect3DDevice8 *iface, DWORD pShader)
 {
     IDirect3DDevice8Impl *This = impl_from_IDirect3DDevice8(iface);
     IDirect3DVertexShader8Impl *shader;
-    IWineD3DBaseShader *cur;
+    struct wined3d_shader *cur;
 
     TRACE("iface %p, shader %#x.\n", iface, pShader);
 
@@ -2145,7 +2144,7 @@ static HRESULT  WINAPI  IDirect3DDevice8Impl_DeleteVertexShader(IDirect3DDevice8
     {
         if (cur == shader->wined3d_shader)
             IDirect3DDevice8_SetVertexShader(iface, 0);
-        IWineD3DBaseShader_Release(cur);
+        wined3d_shader_decref(cur);
     }
 
     wined3d_mutex_unlock();
@@ -2268,7 +2267,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderFunction(IDirect3DDevi
         return D3D_OK;
     }
 
-    hr = IWineD3DBaseShader_GetFunction(shader->wined3d_shader, pData, pSizeOfData);
+    hr = wined3d_shader_get_byte_code(shader->wined3d_shader, pData, pSizeOfData);
     wined3d_mutex_unlock();
 
     return hr;
@@ -2419,7 +2418,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(IDirect3DDevice8 *ifac
 static HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(IDirect3DDevice8 *iface, DWORD *ppShader)
 {
     IDirect3DDevice8Impl *This = impl_from_IDirect3DDevice8(iface);
-    IWineD3DBaseShader *object;
+    struct wined3d_shader *object;
 
     TRACE("iface %p, shader %p.\n", iface, ppShader);
 
@@ -2433,8 +2432,8 @@ static HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(IDirect3DDevice8 *ifac
     if (object)
     {
         IDirect3DPixelShader8Impl *d3d8_shader;
-        d3d8_shader = IWineD3DBaseShader_GetParent(object);
-        IWineD3DBaseShader_Release(object);
+        d3d8_shader = wined3d_shader_get_parent(object);
+        wined3d_shader_decref(object);
         *ppShader = d3d8_shader->handle;
     }
     else
@@ -2452,7 +2451,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(IDirect3DDevice8 *i
 {
     IDirect3DDevice8Impl *This = impl_from_IDirect3DDevice8(iface);
     IDirect3DPixelShader8Impl *shader;
-    IWineD3DBaseShader *cur;
+    struct wined3d_shader *cur;
 
     TRACE("iface %p, shader %#x.\n", iface, pShader);
 
@@ -2471,7 +2470,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(IDirect3DDevice8 *i
     {
         if (cur == shader->wined3d_shader)
             IDirect3DDevice8_SetPixelShader(iface, 0);
-        IWineD3DBaseShader_Release(cur);
+        wined3d_shader_decref(cur);
     }
 
     wined3d_mutex_unlock();
@@ -2536,7 +2535,7 @@ static HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(IDirect3DDevic
         return D3DERR_INVALIDCALL;
     }
 
-    hr = IWineD3DBaseShader_GetFunction(shader->wined3d_shader, pData, pSizeOfData);
+    hr = wined3d_shader_get_byte_code(shader->wined3d_shader, pData, pSizeOfData);
     wined3d_mutex_unlock();
 
     return hr;

dlls/d3d8/shader.c

@@ -55,7 +55,7 @@ static ULONG WINAPI d3d8_vertexshader_AddRef(IDirect3DVertexShader8 *iface)
     if (refcount == 1 && shader->wined3d_shader)
     {
         wined3d_mutex_lock();
-        IWineD3DBaseShader_AddRef(shader->wined3d_shader);
+        wined3d_shader_incref(shader->wined3d_shader);
         wined3d_mutex_unlock();
     }
 
@@ -81,7 +81,7 @@ static ULONG WINAPI d3d8_vertexshader_Release(IDirect3DVertexShader8 *iface)
         if (shader->wined3d_shader)
         {
             wined3d_mutex_lock();
-            IWineD3DBaseShader_Release(shader->wined3d_shader);
+            wined3d_shader_decref(shader->wined3d_shader);
             wined3d_mutex_unlock();
         }
         else
@@ -225,7 +225,7 @@ static ULONG WINAPI d3d8_pixelshader_AddRef(IDirect3DPixelShader8 *iface)
     if (refcount == 1)
     {
         wined3d_mutex_lock();
-        IWineD3DBaseShader_AddRef(shader->wined3d_shader);
+        wined3d_shader_incref(shader->wined3d_shader);
         wined3d_mutex_unlock();
     }
 
@@ -242,7 +242,7 @@ static ULONG WINAPI d3d8_pixelshader_Release(IDirect3DPixelShader8 *iface)
     if (!refcount)
     {
         wined3d_mutex_lock();
-        IWineD3DBaseShader_Release(shader->wined3d_shader);
+        wined3d_shader_decref(shader->wined3d_shader);
         wined3d_mutex_unlock();
     }
 

dlls/d3d8/vertexdeclaration.c

@@ -199,7 +199,7 @@ size_t parse_token(const DWORD* pToken)
     return tokenlen;
 }
 
-void load_local_constants(const DWORD *d3d8_elements, IWineD3DBaseShader *wined3d_vertex_shader)
+void load_local_constants(const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader)
 {
     const DWORD *token = d3d8_elements;
 
@@ -224,7 +224,7 @@ void load_local_constants(const DWORD *d3d8_elements, IWineD3DBaseShader *wined3
                             *(const float *)(token + i * 4 + 4));
                 }
             }
-            hr = IWineD3DBaseShader_SetLocalConstantsF(wined3d_vertex_shader,
+            hr = wined3d_shader_set_local_constants_float(wined3d_vertex_shader,
                     constant_idx, (const float *)token + 1, count);
             if (FAILED(hr)) ERR("Failed setting shader constants\n");
         }

dlls/d3d9/d3d9_private.h

@@ -432,7 +432,7 @@ typedef struct IDirect3DVertexShader9Impl {
   /* IUnknown fields */
   const IDirect3DVertexShader9Vtbl *lpVtbl;
   LONG ref;
-  IWineD3DBaseShader *wined3d_shader;
+  struct wined3d_shader *wined3d_shader;
   IDirect3DDevice9Ex *parentDevice;
 } IDirect3DVertexShader9Impl;
 
@@ -453,7 +453,7 @@ typedef struct IDirect3DPixelShader9Impl {
   /* IUnknown fields */
     const IDirect3DPixelShader9Vtbl *lpVtbl;
     LONG                    ref;
-    IWineD3DBaseShader *wined3d_shader;
+    struct wined3d_shader *wined3d_shader;
     IDirect3DDevice9Ex *parentDevice;
 } IDirect3DPixelShader9Impl;
 

dlls/d3d9/device.c

@@ -2242,7 +2242,7 @@ static HRESULT WINAPI IDirect3DDevice9Impl_SetVertexShader(IDirect3DDevice9Ex *i
 static HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShader(IDirect3DDevice9Ex *iface,
         IDirect3DVertexShader9 **shader)
 {
-    IWineD3DBaseShader *wined3d_shader;
+    struct wined3d_shader *wined3d_shader;
 
     TRACE("iface %p, shader %p.\n", iface, shader);
 
@@ -2250,9 +2250,9 @@ static HRESULT WINAPI IDirect3DDevice9Impl_GetVertexShader(IDirect3DDevice9Ex *i
     wined3d_shader = IWineD3DDevice_GetVertexShader(((IDirect3DDevice9Impl *)iface)->WineD3DDevice);
     if (wined3d_shader)
     {
-        *shader = IWineD3DBaseShader_GetParent(wined3d_shader);
+        *shader = wined3d_shader_get_parent(wined3d_shader);
         IDirect3DVertexShader9_AddRef(*shader);
-        IWineD3DBaseShader_Release(wined3d_shader);
+        wined3d_shader_decref(wined3d_shader);
     }
     else
     {
@@ -2536,7 +2536,7 @@ static HRESULT WINAPI IDirect3DDevice9Impl_SetPixelShader(IDirect3DDevice9Ex *if
 static HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShader(IDirect3DDevice9Ex *iface,
         IDirect3DPixelShader9 **shader)
 {
-    IWineD3DBaseShader *wined3d_shader;
+    struct wined3d_shader *wined3d_shader;
 
     TRACE("iface %p, shader %p.\n", iface, shader);
 
@@ -2546,9 +2546,9 @@ static HRESULT WINAPI IDirect3DDevice9Impl_GetPixelShader(IDirect3DDevice9Ex *if
     wined3d_shader = IWineD3DDevice_GetPixelShader(((IDirect3DDevice9Impl *)iface)->WineD3DDevice);
     if (wined3d_shader)
     {
-        *shader = IWineD3DBaseShader_GetParent(wined3d_shader);
+        *shader = wined3d_shader_get_parent(wined3d_shader);
         IDirect3DPixelShader9_AddRef(*shader);
-        IWineD3DBaseShader_Release(wined3d_shader);
+        wined3d_shader_decref(wined3d_shader);
     }
     else
     {

dlls/d3d9/shader.c

@@ -51,7 +51,7 @@ static ULONG WINAPI d3d9_vertexshader_AddRef(IDirect3DVertexShader9 *iface)
     {
         IDirect3DDevice9Ex_AddRef(shader->parentDevice);
         wined3d_mutex_lock();
-        IWineD3DBaseShader_AddRef(shader->wined3d_shader);
+        wined3d_shader_incref(shader->wined3d_shader);
         wined3d_mutex_unlock();
     }
 
@@ -70,7 +70,7 @@ static ULONG WINAPI d3d9_vertexshader_Release(IDirect3DVertexShader9 *iface)
         IDirect3DDevice9Ex *device = shader->parentDevice;
 
         wined3d_mutex_lock();
-        IWineD3DBaseShader_Release(shader->wined3d_shader);
+        wined3d_shader_decref(shader->wined3d_shader);
         wined3d_mutex_unlock();
 
         /* Release the device last, as it may cause the device to be destroyed. */
@@ -100,7 +100,7 @@ static HRESULT WINAPI d3d9_vertexshader_GetFunction(IDirect3DVertexShader9 *ifac
     TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size);
 
     wined3d_mutex_lock();
-    hr = IWineD3DBaseShader_GetFunction(((IDirect3DVertexShader9Impl *)iface)->wined3d_shader, data, data_size);
+    hr = wined3d_shader_get_byte_code(((IDirect3DVertexShader9Impl *)iface)->wined3d_shader, data, data_size);
     wined3d_mutex_unlock();
 
     return hr;
@@ -179,7 +179,7 @@ static ULONG WINAPI d3d9_pixelshader_AddRef(IDirect3DPixelShader9 *iface)
     {
         IDirect3DDevice9Ex_AddRef(shader->parentDevice);
         wined3d_mutex_lock();
-        IWineD3DBaseShader_AddRef(shader->wined3d_shader);
+        wined3d_shader_incref(shader->wined3d_shader);
         wined3d_mutex_unlock();
     }
 
@@ -198,7 +198,7 @@ static ULONG WINAPI d3d9_pixelshader_Release(IDirect3DPixelShader9 *iface)
         IDirect3DDevice9Ex *device = shader->parentDevice;
 
         wined3d_mutex_lock();
-        IWineD3DBaseShader_Release(shader->wined3d_shader);
+        wined3d_shader_decref(shader->wined3d_shader);
         wined3d_mutex_unlock();
 
         /* Release the device last, as it may cause the device to be destroyed. */
@@ -227,7 +227,7 @@ static HRESULT WINAPI d3d9_pixelshader_GetFunction(IDirect3DPixelShader9 *iface,
     TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size);
 
     wined3d_mutex_lock();
-    hr = IWineD3DBaseShader_GetFunction(((IDirect3DPixelShader9Impl *)iface)->wined3d_shader, data, data_size);
+    hr = wined3d_shader_get_byte_code(((IDirect3DPixelShader9Impl *)iface)->wined3d_shader, data, data_size);
     wined3d_mutex_unlock();
 
     return hr;

dlls/wined3d/arb_program_shader.c

@@ -944,7 +944,7 @@ static void shader_arb_get_register_name(const struct wined3d_shader_instruction
 {
     /* oPos, oFog and oPts in D3D */
     static const char * const rastout_reg_names[] = {"TMP_OUT", "result.fogcoord", "result.pointsize"};
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
     BOOL pshader = shader_is_pshader_version(reg_maps->shader_version.type);
     struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
@@ -1340,7 +1340,7 @@ static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD
     const struct wined3d_texture *texture;
     const char *tex_type;
     BOOL np2_fixup = FALSE;
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     IWineD3DDeviceImpl *device = shader->device;
     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
     const char *mod;
@@ -1756,7 +1756,7 @@ static void shader_hw_nop(const struct wined3d_shader_instruction *ins)
 
 static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
 {
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
     BOOL pshader = shader_is_pshader_version(reg_maps->shader_version.type);
     struct shader_arb_ctx_priv *ctx = ins->ctx->backend_data;
@@ -3206,7 +3206,7 @@ static void shader_hw_ret(const struct wined3d_shader_instruction *ins)
 {
     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
 
     if(priv->target_version == ARB) return;
@@ -5257,7 +5257,7 @@ static void free_recorded_instruction(struct list *list)
 static void shader_arb_handle_instruction(const struct wined3d_shader_instruction *ins) {
     SHADER_HANDLER hw_fct;
     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     struct control_frame *control_frame;
     struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
     BOOL bool_const;

dlls/wined3d/device.c

@@ -9,7 +9,7 @@
  * Copyright 2006-2008 Stefan Dösinger for CodeWeavers
  * Copyright 2006-2008 Henri Verbeet
  * Copyright 2007 Andrew Riedi
- * Copyright 2009-2010 Henri Verbeet for CodeWeavers
+ * Copyright 2009-2011 Henri Verbeet for CodeWeavers
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -3350,9 +3350,9 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShader(IWineD3DDevice *iface,
     if (device->isRecordingState)
     {
         if (shader)
-            IWineD3DBaseShader_AddRef(shader);
+            wined3d_shader_incref(shader);
         if (prev)
-            IWineD3DBaseShader_Release(prev);
+            wined3d_shader_decref(prev);
         TRACE("Recording... not performing anything.\n");
         return WINED3D_OK;
     }
@@ -3365,9 +3365,9 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShader(IWineD3DDevice *iface,
 
     TRACE("(%p) : setting shader(%p)\n", device, shader);
     if (shader)
-        IWineD3DBaseShader_AddRef(shader);
+        wined3d_shader_incref(shader);
     if (prev)
-        IWineD3DBaseShader_Release(prev);
+        wined3d_shader_decref(prev);
 
     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_VSHADER);
 
@@ -3383,7 +3383,7 @@ static IWineD3DBaseShader * WINAPI IWineD3DDeviceImpl_GetVertexShader(IWineD3DDe
 
     shader = (IWineD3DBaseShader *)device->stateBlock->state.vertex_shader;
     if (shader)
-        IWineD3DBaseShader_AddRef(shader);
+        wined3d_shader_incref(shader);
 
     TRACE("Returning %p.\n", shader);
     return shader;
@@ -3759,9 +3759,9 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice *iface, I
     {
         TRACE("Recording... not performing anything.\n");
         if (shader)
-            IWineD3DBaseShader_AddRef(shader);
+            wined3d_shader_incref(shader);
         if (prev)
-            IWineD3DBaseShader_Release(prev);
+            wined3d_shader_decref(prev);
         return WINED3D_OK;
     }
 
@@ -3772,9 +3772,9 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice *iface, I
     }
 
     if (shader)
-        IWineD3DBaseShader_AddRef(shader);
+        wined3d_shader_incref(shader);
     if (prev)
-        IWineD3DBaseShader_Release(prev);
+        wined3d_shader_decref(prev);
 
     TRACE("Setting shader %p.\n", shader);
     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_PIXELSHADER);
@@ -3789,9 +3789,9 @@ static IWineD3DBaseShader * WINAPI IWineD3DDeviceImpl_GetPixelShader(IWineD3DDev
 
     TRACE("iface %p.\n", iface);
 
-    shader = (IWineD3DBaseShader *)device->stateBlock->state.pixel_shader;
+    shader = device->stateBlock->state.pixel_shader;
     if (shader)
-        IWineD3DBaseShader_AddRef(shader);
+        wined3d_shader_incref(shader);
 
     TRACE("Returning %p.\n", shader);
     return shader;

dlls/wined3d/glsl_shader.c

@@ -1317,7 +1317,7 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
     /* oPos, oFog and oPts in D3D */
     static const char * const hwrastout_reg_names[] = {"OUT[10]", "OUT[11].x", "OUT[11].y"};
 
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
     const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
     char pshader = shader_is_pshader_version(reg_maps->shader_version.type);
@@ -2842,7 +2842,7 @@ static void shader_glsl_loop(const struct wined3d_shader_instruction *ins)
 {
     struct wined3d_shader_loop_state *loop_state = ins->ctx->loop_state;
     glsl_src_param_t src1_param;
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     const DWORD *control_values = NULL;
     const local_constant *constant;
 
@@ -2925,7 +2925,7 @@ static void shader_glsl_end(const struct wined3d_shader_instruction *ins)
 
 static void shader_glsl_rep(const struct wined3d_shader_instruction *ins)
 {
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     struct wined3d_shader_loop_state *loop_state = ins->ctx->loop_state;
     glsl_src_param_t src0_param;
     const DWORD *control_values = NULL;
@@ -3035,7 +3035,7 @@ static void shader_glsl_ret(const struct wined3d_shader_instruction *ins)
  ********************************************/
 static void shader_glsl_tex(const struct wined3d_shader_instruction *ins)
 {
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     IWineD3DDeviceImpl *device = shader->device;
     DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
             ins->ctx->reg_maps->shader_version.minor);
@@ -3125,7 +3125,7 @@ static void shader_glsl_tex(const struct wined3d_shader_instruction *ins)
 
 static void shader_glsl_texldd(const struct wined3d_shader_instruction *ins)
 {
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     IWineD3DDeviceImpl *device = shader->device;
     const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
     glsl_sample_function_t sample_function;
@@ -3158,7 +3158,7 @@ static void shader_glsl_texldd(const struct wined3d_shader_instruction *ins)
 
 static void shader_glsl_texldl(const struct wined3d_shader_instruction *ins)
 {
-    struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
+    struct wined3d_shader *shader = ins->ctx->shader;
     IWineD3DDeviceImpl *device = shader->device;
     const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
     glsl_sample_function_t sample_function;

dlls/wined3d/shader.c

@@ -1546,54 +1546,6 @@ const shader_backend_t none_shader_backend = {
     shader_none_color_fixup_supported,
 };
 
-static HRESULT shader_get_function(IWineD3DBaseShaderImpl *shader, void *data, UINT *data_size)
-{
-    if (!data)
-    {
-        *data_size = shader->functionLength;
-        return WINED3D_OK;
-    }
-
-    if (*data_size < shader->functionLength)
-    {
-        /* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
-         * than the required size we should write the required size and
-         * return D3DERR_MOREDATA. That's not actually true. */
-        return WINED3DERR_INVALIDCALL;
-    }
-
-    memcpy(data, shader->function, shader->functionLength);
-
-    return WINED3D_OK;
-}
-
-/* Set local constants for d3d8 shaders. */
-static HRESULT shader_set_local_constants_float(IWineD3DBaseShaderImpl *shader,
-        UINT start_idx, const float *src_data, UINT count)
-{
-    UINT end_idx = start_idx + count;
-    UINT i;
-
-    if (end_idx > shader->limits.constant_float)
-    {
-        WARN("end_idx %u > float constants limit %u.\n",
-                end_idx, shader->limits.constant_float);
-        end_idx = shader->limits.constant_float;
-    }
-
-    for (i = start_idx; i < end_idx; ++i)
-    {
-        local_constant* lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
-        if (!lconst) return E_OUTOFMEMORY;
-
-        lconst->idx = i;
-        memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
-        list_add_head(&shader->constantsF, &lconst->entry);
-    }
-
-    return WINED3D_OK;
-}
-
 static HRESULT shader_set_function(IWineD3DBaseShaderImpl *shader, const DWORD *byte_code,
         const struct wined3d_shader_signature *output_signature, DWORD float_const_count)
 {
@@ -1641,29 +1593,8 @@ static HRESULT shader_set_function(IWineD3DBaseShaderImpl *shader, const DWORD *
     return WINED3D_OK;
 }
 
-static HRESULT STDMETHODCALLTYPE wined3d_shader_QueryInterface(IWineD3DBaseShader *iface,
-        REFIID riid, void **object)
+ULONG CDECL wined3d_shader_incref(struct wined3d_shader *shader)
 {
-    TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
-
-    if (IsEqualGUID(riid, &IID_IWineD3DBaseShader)
-            || IsEqualGUID(riid, &IID_IWineD3DBase)
-            || IsEqualGUID(riid, &IID_IUnknown))
-    {
-        IUnknown_AddRef(iface);
-        *object = iface;
-        return S_OK;
-    }
-
-    WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
-
-    *object = NULL;
-    return E_NOINTERFACE;
-}
-
-static ULONG STDMETHODCALLTYPE wined3d_shader_AddRef(IWineD3DBaseShader *iface)
-{
-    IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)iface;
     ULONG refcount = InterlockedIncrement(&shader->ref);
 
     TRACE("%p increasing refcount to %u.\n", shader, refcount);
@@ -1672,9 +1603,8 @@ static ULONG STDMETHODCALLTYPE wined3d_shader_AddRef(IWineD3DBaseShader *iface)
 }
 
 /* Do not call while under the GL lock. */
-static ULONG STDMETHODCALLTYPE wined3d_shader_Release(IWineD3DBaseShader *iface)
+ULONG CDECL wined3d_shader_decref(struct wined3d_shader *shader)
 {
-    IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)iface;
     ULONG refcount = InterlockedDecrement(&shader->ref);
 
     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
@@ -1689,38 +1619,66 @@ static ULONG STDMETHODCALLTYPE wined3d_shader_Release(IWineD3DBaseShader *iface)
     return refcount;
 }
 
-static void * STDMETHODCALLTYPE wined3d_shader_GetParent(IWineD3DBaseShader *iface)
+void * CDECL wined3d_shader_get_parent(const struct wined3d_shader *shader)
 {
-    TRACE("iface %p.\n", iface);
+    TRACE("shader %p.\n", shader);
 
-    return ((IWineD3DBaseShaderImpl *)iface)->parent;
+    return shader->parent;
 }
 
-static HRESULT STDMETHODCALLTYPE wined3d_shader_GetFunction(IWineD3DBaseShader *iface, void *data, UINT *data_size)
+HRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader,
+        void *byte_code, UINT *byte_code_size)
 {
-    TRACE("iface %p, data %p, data_size %p.\n", iface, data, data_size);
+    TRACE("shader %p, byte_code %p, byte_code_size %p.\n", shader, byte_code, byte_code_size);
 
-    return shader_get_function((IWineD3DBaseShaderImpl *)iface, data, data_size);
+    if (!byte_code)
+    {
+        *byte_code_size = shader->functionLength;
+        return WINED3D_OK;
+    }
+
+    if (*byte_code_size < shader->functionLength)
+    {
+        /* MSDN claims (for d3d8 at least) that if *byte_code_size is smaller
+         * than the required size we should write the required size and
+         * return D3DERR_MOREDATA. That's not actually true. */
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    memcpy(byte_code, shader->function, shader->functionLength);
+
+    return WINED3D_OK;
 }
 
-static HRESULT STDMETHODCALLTYPE wined3d_shader_SetLocalConstantsF(IWineD3DBaseShader *iface,
+/* Set local constants for d3d8 shaders. */
+HRESULT CDECL wined3d_shader_set_local_constants_float(struct wined3d_shader *shader,
         UINT start_idx, const float *src_data, UINT count)
 {
-    TRACE("iface %p, start_idx %u, src_data %p, count %u.\n", iface, start_idx, src_data, count);
+    UINT end_idx = start_idx + count;
+    UINT i;
 
-    return shader_set_local_constants_float((IWineD3DBaseShaderImpl *)iface,
-            start_idx, src_data, count);
-}
+    TRACE("shader %p, start_idx %u, src_data %p, count %u.\n", shader, start_idx, src_data, count);
 
-static const IWineD3DBaseShaderVtbl wined3d_shader_vtbl =
-{
-    wined3d_shader_QueryInterface,
-    wined3d_shader_AddRef,
-    wined3d_shader_Release,
-    wined3d_shader_GetParent,
-    wined3d_shader_GetFunction,
-    wined3d_shader_SetLocalConstantsF,
-};
+    if (end_idx > shader->limits.constant_float)
+    {
+        WARN("end_idx %u > float constants limit %u.\n",
+                end_idx, shader->limits.constant_float);
+        end_idx = shader->limits.constant_float;
+    }
+
+    for (i = start_idx; i < end_idx; ++i)
+    {
+        struct local_constant *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(local_constant));
+        if (!lconst)
+            return E_OUTOFMEMORY;
+
+        lconst->idx = i;
+        memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
+        list_add_head(&shader->constantsF, &lconst->entry);
+    }
+
+    return WINED3D_OK;
+}
 
 void find_vs_compile_args(const struct wined3d_state *state,
         IWineD3DBaseShaderImpl *shader, struct vs_compile_args *args)
@@ -1742,7 +1700,7 @@ static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_id
     return FALSE;
 }
 
-BOOL vshader_get_input(struct IWineD3DBaseShaderImpl *shader,
+BOOL vshader_get_input(struct wined3d_shader *shader,
         BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum)
 {
     WORD map = shader->reg_maps.input_registers;
@@ -1847,9 +1805,7 @@ HRESULT vertexshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *de
 
     if (!byte_code) return WINED3DERR_INVALIDCALL;
 
-    shader->lpVtbl = &wined3d_shader_vtbl;
     shader_init(shader, device, parent, parent_ops);
-
     hr = shader_set_function(shader, byte_code, output_signature, device->d3d_vshader_constantF);
     if (FAILED(hr))
     {
@@ -1893,9 +1849,7 @@ HRESULT geometryshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *
 {
     HRESULT hr;
 
-    shader->lpVtbl = &wined3d_shader_vtbl;
     shader_init(shader, device, parent, parent_ops);
-
     hr = shader_set_function(shader, byte_code, output_signature, 0);
     if (FAILED(hr))
     {
@@ -2105,9 +2059,7 @@ HRESULT pixelshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *dev
 
     if (!byte_code) return WINED3DERR_INVALIDCALL;
 
-    shader->lpVtbl = &wined3d_shader_vtbl;
     shader_init(shader, device, parent, parent_ops);
-
     hr = shader_set_function(shader, byte_code, output_signature, device->d3d_pshader_constantF);
     if (FAILED(hr))
     {

dlls/wined3d/stateblock.c

@@ -499,9 +499,9 @@ ULONG CDECL wined3d_stateblock_decref(struct wined3d_stateblock *stateblock)
         if (stateblock->state.index_buffer)
             wined3d_buffer_decref(stateblock->state.index_buffer);
         if (stateblock->state.vertex_shader)
-            IWineD3DBaseShader_Release((IWineD3DBaseShader *)stateblock->state.vertex_shader);
+            wined3d_shader_decref(stateblock->state.vertex_shader);
         if (stateblock->state.pixel_shader)
-            IWineD3DBaseShader_Release((IWineD3DBaseShader *)stateblock->state.pixel_shader);
+            wined3d_shader_decref(stateblock->state.pixel_shader);
 
         for (counter = 0; counter < LIGHTMAP_SIZE; ++counter)
         {
@@ -599,9 +599,9 @@ HRESULT CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock)
                 stateblock->state.vertex_shader, src_state->vertex_shader);
 
         if (src_state->vertex_shader)
-            IWineD3DBaseShader_AddRef((IWineD3DBaseShader *)src_state->vertex_shader);
+            wined3d_shader_incref(src_state->vertex_shader);
         if (stateblock->state.vertex_shader)
-            IWineD3DBaseShader_Release((IWineD3DBaseShader *)stateblock->state.vertex_shader);
+            wined3d_shader_decref(stateblock->state.vertex_shader);
         stateblock->state.vertex_shader = src_state->vertex_shader;
     }
 
@@ -860,9 +860,9 @@ HRESULT CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock)
     if (stateblock->changed.pixelShader && stateblock->state.pixel_shader != src_state->pixel_shader)
     {
         if (src_state->pixel_shader)
-            IWineD3DBaseShader_AddRef((IWineD3DBaseShader *)src_state->pixel_shader);
+            wined3d_shader_incref(src_state->pixel_shader);
         if (stateblock->state.pixel_shader)
-            IWineD3DBaseShader_Release((IWineD3DBaseShader *)stateblock->state.pixel_shader);
+            wined3d_shader_decref(stateblock->state.pixel_shader);
         stateblock->state.pixel_shader = src_state->pixel_shader;
     }
 

dlls/wined3d/wined3d.spec

@@ -61,6 +61,12 @@
 @ cdecl wined3d_resource_get_desc(ptr ptr)
 @ cdecl wined3d_resource_get_parent(ptr)
 
+@ cdecl wined3d_shader_decref(ptr)
+@ cdecl wined3d_shader_get_byte_code(ptr ptr ptr)
+@ cdecl wined3d_shader_get_parent(ptr)
+@ cdecl wined3d_shader_incref(ptr)
+@ cdecl wined3d_shader_set_local_constants_float(ptr long ptr long)
+
 @ cdecl wined3d_stateblock_apply(ptr)
 @ cdecl wined3d_stateblock_capture(ptr)
 @ cdecl wined3d_stateblock_decref(ptr)

dlls/wined3d/wined3d_private.h

@@ -55,7 +55,8 @@
 typedef struct IWineD3DSurfaceImpl    IWineD3DSurfaceImpl;
 typedef struct IWineD3DDeviceImpl     IWineD3DDeviceImpl;
 typedef struct IWineD3DSwapChainImpl  IWineD3DSwapChainImpl;
-struct IWineD3DBaseShaderImpl;
+typedef struct wined3d_shader IWineD3DBaseShaderImpl;
+typedef struct wined3d_shader IWineD3DBaseShader;
 
 /* Texture format fixups */
 
@@ -586,7 +587,7 @@ struct wined3d_shader_loop_state
 
 struct wined3d_shader_context
 {
-    struct IWineD3DBaseShaderImpl *shader;
+    struct wined3d_shader *shader;
     const struct wined3d_gl_info *gl_info;
     const struct wined3d_shader_reg_maps *reg_maps;
     struct wined3d_shader_buffer *buffer;
@@ -757,7 +758,7 @@ typedef struct {
     void (*shader_load_constants)(const struct wined3d_context *context, char usePS, char useVS);
     void (*shader_load_np2fixup_constants)(void *shader_priv, const struct wined3d_gl_info *gl_info,
             const struct wined3d_state *state);
-    void (*shader_destroy)(struct IWineD3DBaseShaderImpl *shader);
+    void (*shader_destroy)(struct wined3d_shader *shader);
     HRESULT (*shader_alloc_private)(IWineD3DDeviceImpl *device);
     void (*shader_free_private)(IWineD3DDeviceImpl *device);
     BOOL (*shader_dirtifyable_constants)(void);
@@ -2336,12 +2337,12 @@ struct wined3d_state
     INT load_base_vertex_index; /* Non-indexed drawing needs 0 here, indexed needs base_vertex_index. */
     GLenum gl_primitive_type;
 
-    struct IWineD3DBaseShaderImpl *vertex_shader;
+    struct wined3d_shader *vertex_shader;
     BOOL vs_consts_b[MAX_CONST_B];
     INT vs_consts_i[MAX_CONST_I * 4];
     float *vs_consts_f;
 
-    struct IWineD3DBaseShaderImpl *pixel_shader;
+    struct wined3d_shader *pixel_shader;
     BOOL ps_consts_b[MAX_CONST_B];
     INT ps_consts_i[MAX_CONST_I * 4];
     float *ps_consts_f;
@@ -2682,7 +2683,7 @@ int shader_addline(struct wined3d_shader_buffer *buffer, const char *fmt, ...) P
 int shader_vaddline(struct wined3d_shader_buffer *buffer, const char *fmt, va_list args) DECLSPEC_HIDDEN;
 
 /* Vertex shader utility functions */
-extern BOOL vshader_get_input(struct IWineD3DBaseShaderImpl *shader,
+extern BOOL vshader_get_input(struct wined3d_shader *shader,
         BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum) DECLSPEC_HIDDEN;
 
 struct wined3d_vertex_shader
@@ -2703,10 +2704,8 @@ struct wined3d_pixel_shader
     DWORD color0_reg;
 };
 
-typedef struct IWineD3DBaseShaderImpl {
-    /* IUnknown */
-    const IWineD3DBaseShaderVtbl    *lpVtbl;
-
+struct wined3d_shader
+{
     LONG ref;
     SHADER_LIMITS limits;
     DWORD *function;
@@ -2740,7 +2739,7 @@ typedef struct IWineD3DBaseShaderImpl {
         struct wined3d_vertex_shader vs;
         struct wined3d_pixel_shader ps;
     } u;
-} IWineD3DBaseShaderImpl;
+};
 
 HRESULT geometryshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *device,
         const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,

include/wine/wined3d.idl

@@ -2096,6 +2096,7 @@ struct wined3d_clipper;
 struct wined3d_palette;
 struct wined3d_query;
 struct wined3d_resource;
+struct wined3d_shader;
 struct wined3d_stateblock;
 struct wined3d_texture;
 struct wined3d_vertex_declaration;
@@ -2387,24 +2388,6 @@ interface IWineD3DSwapChain : IWineD3DBase
 [
     object,
     local,
-    uuid(eac93065-a4df-446f-86a1-9ef2bca40a3c)
-]
-interface IWineD3DBaseShader : IWineD3DBase
-{
-    HRESULT GetFunction(
-        [out] void *data,
-        [in, out] UINT *data_size
-    );
-    HRESULT SetLocalConstantsF(
-        [in] UINT start_idx,
-        [in] const float *src_data,
-        [in] UINT vector4f_count
-    );
-}
-
-[
-    object,
-    local,
     uuid(6d10a2ce-09d0-4a53-a427-11388f9f8ca5)
 ]
 interface IWineD3DDevice : IUnknown
@@ -2529,21 +2512,21 @@ interface IWineD3DDevice : IUnknown
         [in] const struct wined3d_shader_signature *output_signature,
         [in] void *parent,
         [in] const struct wined3d_parent_ops *parent_ops,
-        [out] IWineD3DBaseShader **shader
+        [out] struct wined3d_shader **shader
     );
     HRESULT CreateGeometryShader(
         [in] const DWORD *byte_code,
         [in] const struct wined3d_shader_signature *output_signature,
         [in] void *parent,
         [in] const struct wined3d_parent_ops *parent_ops,
-        [out] IWineD3DBaseShader **shader
+        [out] struct wined3d_shader **shader
     );
     HRESULT CreatePixelShader(
         [in] const DWORD *function,
         [in] const struct wined3d_shader_signature *output_signature,
         [in] void *parent,
         [in] const struct wined3d_parent_ops *parent_ops,
-        [out] IWineD3DBaseShader **shader
+        [out] struct wined3d_shader **shader
     );
     HRESULT CreatePalette(
         [in] DWORD flags,
@@ -2705,9 +2688,9 @@ interface IWineD3DDevice : IUnknown
         [out] PALETTEENTRY *entries
     );
     HRESULT SetPixelShader(
-        [in] IWineD3DBaseShader *shader
+        [in] struct wined3d_shader *shader
     );
-    IWineD3DBaseShader *GetPixelShader(
+    struct wined3d_shader *GetPixelShader(
     );
     HRESULT SetPixelShaderConstantB(
         [in] UINT start_register,
@@ -2830,9 +2813,9 @@ interface IWineD3DDevice : IUnknown
         [out] struct wined3d_vertex_declaration **declaration
     );
     HRESULT SetVertexShader(
-        [in] IWineD3DBaseShader *shader
+        [in] struct wined3d_shader *shader
     );
-    IWineD3DBaseShader *GetVertexShader(
+    struct wined3d_shader *GetVertexShader(
     );
     HRESULT SetVertexShaderConstantB(
         [in] UINT start_register,
@@ -3092,6 +3075,14 @@ void __cdecl wined3d_resource_get_desc(const struct wined3d_resource *resource,
         struct wined3d_resource_desc *desc);
 void * __cdecl wined3d_resource_get_parent(const struct wined3d_resource *resource);
 
+ULONG __cdecl wined3d_shader_decref(struct wined3d_shader *shader);
+HRESULT __cdecl wined3d_shader_get_byte_code(const struct wined3d_shader *shader,
+        void *byte_code, UINT *byte_code_size);
+void * __cdecl wined3d_shader_get_parent(const struct wined3d_shader *shader);
+ULONG __cdecl wined3d_shader_incref(struct wined3d_shader *shader);
+HRESULT __cdecl wined3d_shader_set_local_constants_float(struct wined3d_shader *shader,
+        UINT start_idx, const float *src_data, UINT vector4f_count);
+
 HRESULT __cdecl wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock);
 HRESULT __cdecl wined3d_stateblock_capture(struct wined3d_stateblock *stateblock);
 ULONG __cdecl wined3d_stateblock_decref(struct wined3d_stateblock *stateblock);