[WINED3D 5/5] Remove constant type field in stateblock.

Ivan Gyurdiev ivg2 at cornell.edu
Tue Jun 6 01:46:59 CDT 2006


It is wrong to maintain a mapping from a constant index to a type field, 
because different constant types do not share an index - boolean 
constant 0 is supposed to co-exist with floating point constant 0, not 
replace it. Drawprim and other code using the type array to decide 
whether to look up a constant in bools, floats, or ints is wrong - you 
can't make that decision based on the index.

To do this:
==========
- split .set and .changed stateblock arrays for constants into 
individual arrays for F, B, and I constants
- don't use shared SetConstant/GetConstant function in device.c, unroll 
that into its callers, and make them use separate .set and .changed 
arrays. Remove old SetConstant/GetConstant functions, not enough is 
shared to justify them. Remove SetConstantN, it's not used anymore.
- change stateblock to not use the type array
- change drawprim to use the .set array, instead of a type array to 
check if constants need to be loaded

-------------- next part --------------
---

 dlls/wined3d/device.c            |  397 +++++++++++++++++++-------------------
 dlls/wined3d/drawprim.c          |   15 +
 dlls/wined3d/stateblock.c        |  106 ++++++----
 dlls/wined3d/wined3d_private.h   |   17 +-
 include/wine/wined3d_interface.h |   12 -
 5 files changed, 274 insertions(+), 273 deletions(-)

1a77c5c5e93ccdfe18afc213a3b6d2e6576c5134
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 70ac58d..ed3f6bc 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -500,7 +500,9 @@ HRESULT WINAPI IWineD3DDeviceImpl_Create
 
         /* Pixel Shader Constants */
         for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
-            object->changed.pixelShaderConstants[i] = TRUE;
+            object->changed.pixelShaderConstantsF[i] = TRUE;
+            object->changed.pixelShaderConstantsB[i] = TRUE;
+            object->changed.pixelShaderConstantsI[i] = TRUE;
         }
         for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
             object->changed.renderState[SavedPixelStates_R[i]] = TRUE;
@@ -526,7 +528,9 @@ HRESULT WINAPI IWineD3DDeviceImpl_Create
 
         /* Vertex Shader Constants */
         for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
-            object->changed.vertexShaderConstants[i] = TRUE;
+            object->changed.vertexShaderConstantsF[i] = TRUE;
+            object->changed.vertexShaderConstantsB[i] = TRUE;
+            object->changed.vertexShaderConstantsI[i] = TRUE;
         }
         for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
             object->changed.renderState[SavedVertexStates_R[i]] = TRUE;
@@ -4353,140 +4357,136 @@ HRESULT WINAPI IWineD3DDeviceImpl_GetVer
     return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(
+    IWineD3DDevice *iface,
+    UINT start,
+    CONST BOOL *srcData,
+    UINT count) {
 
-    int i;
-    int cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    int i, cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
 
-    TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
-            iface, dstData, srcData, type, start, count, registersize);
+    TRACE("(iface %p, srcData %p, start %d, count %d)\n",
+            iface, srcData, start, count);
 
-    if (type != WINESHADERCNST_NONE) {
-        if (srcData == NULL || cnt < 0) {
-            return WINED3DERR_INVALIDCALL;
-        }
+    if (srcData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
 
-        CopyMemory((char *)dstData + (start * registersize), srcData, cnt * registersize);
-    }
+    memcpy(&This->updateStateBlock->vertexShaderConstantB[start], srcData, cnt);
 
     for (i = start; i < cnt + start; ++i) {
-        This->updateStateBlock->changed.vertexShaderConstants[i] = TRUE;
-        This->updateStateBlock->set.vertexShaderConstants[i]     = TRUE;
-        This->updateStateBlock->vertexShaderConstantT[i]         = type;
+        This->updateStateBlock->changed.vertexShaderConstantsB[i] = TRUE;
+        This->updateStateBlock->set.vertexShaderConstantsB[i]     = TRUE;
     }
 
     return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(
+    IWineD3DDevice *iface,
+    UINT start,
+    BOOL *dstData,
+    UINT count) {
 
-    int i;
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
     int cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
 
-    TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
-            iface, dstData, srcData, type, start, count, registersize);
-
-    /* Verify that the requested shader constant was populated with the correct type */
-    for (i = start; i < cnt + start; ++i) {
-        if (This->updateStateBlock->vertexShaderConstantT[i] != type) {
-            TRACE("(%p) : Caller requested 0x%x while type is 0x%x. Returning WINED3DERR_INVALIDCALL\n", 
-                    This, type, This->updateStateBlock->vertexShaderConstantT[i]);
-            return WINED3DERR_INVALIDCALL;
-        }
-    }
+    TRACE("(iface %p, dstData %p, start %d, count %d)\n",
+            iface, dstData, start, count);
 
-    if (dstData == NULL || cnt < 0) {
+    if (dstData == NULL || cnt < 0)
         return WINED3DERR_INVALIDCALL;
-    }
-
-    CopyMemory(dstData, (char *)srcData + (start * registersize), cnt * registersize);
 
+    memcpy(dstData, &This->updateStateBlock->vertexShaderConstantB[start], cnt);
     return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, CONST BOOL  *pConstantData, UINT BoolCount){
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    
-    return IWineD3DDeviceImpl_SetVertexShaderConstant(iface, 
-            This->updateStateBlock->vertexShaderConstantB, 
-            pConstantData, 
-            WINESHADERCNST_BOOL, 
-            StartRegister, 
-            BoolCount, 
-            sizeof(*pConstantData));
-}
+HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(
+    IWineD3DDevice *iface,
+    UINT start,
+    CONST int *srcData,
+    UINT count) {
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, BOOL *pConstantData, UINT BoolCount){
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    
-    return IWineD3DDeviceImpl_GetVertexShaderConstant(iface, 
-            pConstantData, 
-            This->updateStateBlock->vertexShaderConstantB, 
-            WINESHADERCNST_BOOL, 
-            StartRegister, 
-            BoolCount, 
-            sizeof(*pConstantData));
-}
+    int i, cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, CONST int *pConstantData, UINT Vector4iCount){
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    
-    return IWineD3DDeviceImpl_SetVertexShaderConstant(iface, 
-            This->updateStateBlock->vertexShaderConstantI, 
-            pConstantData, 
-            WINESHADERCNST_INTEGER, 
-            StartRegister, 
-            Vector4iCount, 
-            4 * sizeof(*pConstantData));
+    TRACE("(iface %p, srcData %p, start %d, count %d)\n",
+            iface, srcData, start, count);
+
+    if (srcData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(&This->updateStateBlock->vertexShaderConstantI[start * 4], srcData, cnt * 16);
+
+    for (i = start; i < cnt + start; ++i) {
+        This->updateStateBlock->changed.vertexShaderConstantsI[i] = TRUE;
+        This->updateStateBlock->set.vertexShaderConstantsI[i]     = TRUE;
+    }
+
+    return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, int         *pConstantData, UINT Vector4iCount){
+HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(
+    IWineD3DDevice *iface,
+    UINT start,
+    int *dstData,
+    UINT count) {
+
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    
-    return IWineD3DDeviceImpl_GetVertexShaderConstant(iface, 
-            pConstantData, 
-            This->updateStateBlock->vertexShaderConstantI, 
-            WINESHADERCNST_INTEGER, 
-            StartRegister, 
-            Vector4iCount, 
-            4 * sizeof(*pConstantData));
+    int cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
+
+    TRACE("(iface %p, dstData %p, start %d, count %d)\n",
+            iface, dstData, start, count);
+
+    if (dstData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(dstData, &This->updateStateBlock->vertexShaderConstantI[start * 4], cnt * 16);
+    return WINED3D_OK;
 }
 
+HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(
+    IWineD3DDevice *iface,
+    UINT start,
+    CONST float *srcData,
+    UINT count) {
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, CONST float *pConstantData, UINT Vector4fCount){
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    int i, cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
+
+    TRACE("(iface %p, srcData %p, start %d, count %d)\n",
+            iface, srcData, start, count);
 
-    return IWineD3DDeviceImpl_SetVertexShaderConstant(iface, 
-            This->updateStateBlock->vertexShaderConstantF, 
-            pConstantData, 
-            WINESHADERCNST_FLOAT, 
-            StartRegister, 
-            Vector4fCount, 
-            4 * sizeof(*pConstantData));
+    if (srcData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(&This->updateStateBlock->vertexShaderConstantF[start * 4], srcData, cnt * 16);
+
+    for (i = start; i < cnt + start; ++i) {
+        This->updateStateBlock->changed.vertexShaderConstantsF[i] = TRUE;
+        This->updateStateBlock->set.vertexShaderConstantsF[i]     = TRUE;
+    }
+
+    return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, float       *pConstantData, UINT Vector4fCount){
+HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(
+    IWineD3DDevice *iface,
+    UINT start,
+    float *dstData,
+    UINT count) {
+
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    int cnt = min(count, MAX_VSHADER_CONSTANTS - (start + 1));
 
-    return IWineD3DDeviceImpl_GetVertexShaderConstant(iface, 
-            pConstantData, 
-            This->updateStateBlock->vertexShaderConstantF, 
-            WINESHADERCNST_FLOAT, 
-            StartRegister, 
-            Vector4fCount, 
-            4 * sizeof(*pConstantData));
-}
+    TRACE("(iface %p, dstData %p, start %d, count %d)\n",
+            iface, dstData, start, count);
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantN(IWineD3DDevice *iface, UINT StartRegister, UINT VectorNCount){
-    return IWineD3DDeviceImpl_SetVertexShaderConstant(iface, 
-            NULL, 
-            NULL, 
-            WINESHADERCNST_NONE, 
-            StartRegister, 
-            VectorNCount, 
-            0);
+    if (dstData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(dstData, &This->updateStateBlock->vertexShaderConstantF[start * 4], cnt * 16);
+    return WINED3D_OK;
 }
 
 HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader *pShader) {
@@ -4531,139 +4531,136 @@ HRESULT WINAPI IWineD3DDeviceImpl_GetPix
     return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(
+    IWineD3DDevice *iface,
+    UINT start,
+    CONST BOOL *srcData,
+    UINT count) {
 
-    int i;
-    int cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    int i, cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
 
-    TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
-            iface, dstData, srcData, type, start, count, registersize);
+    TRACE("(iface %p, srcData %p, start %d, count %d)\n",
+            iface, srcData, start, count);
 
-    if (type != WINESHADERCNST_NONE) {
-        if (srcData == NULL || cnt < 0) {
-            return WINED3DERR_INVALIDCALL;
-        }
+    if (srcData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
 
-        CopyMemory((char *)dstData + (start * registersize), srcData, cnt * registersize);
-    }
+    memcpy(&This->updateStateBlock->pixelShaderConstantB[start], srcData, cnt);
 
     for (i = start; i < cnt + start; ++i) {
-        This->updateStateBlock->changed.pixelShaderConstants[i] = TRUE;
-        This->updateStateBlock->set.pixelShaderConstants[i]     = TRUE;
-        This->updateStateBlock->pixelShaderConstantT[i]         = type;
+        This->updateStateBlock->changed.pixelShaderConstantsB[i] = TRUE;
+        This->updateStateBlock->set.pixelShaderConstantsB[i]     = TRUE;
     }
 
     return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstant(IWineD3DDevice *iface, void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT registersize) {
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(
+    IWineD3DDevice *iface,
+    UINT start,
+    BOOL *dstData,
+    UINT count) {
 
-    int i;
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
     int cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
 
-    TRACE("(iface %p, dstData %p, srcData %p, type %d, start %d, count %d, registersize %d)\n",
-            iface, dstData, srcData, type, start, count, registersize);
+    TRACE("(iface %p, dstData %p, start %d, count %d)\n",
+            iface, dstData, start, count);
 
-    /* Verify that the requested shader constant was populated with the correct type */
-    for (i = start; i < cnt + start; ++i) {
-        if (This->updateStateBlock->pixelShaderConstantT[i] != type) {
-            TRACE("(%p) : Caller requested 0x%x while type is 0x%x. Returning WINED3DERR_INVALIDCALL\n", 
-                    This, type, This->updateStateBlock->pixelShaderConstantT[i]);
-            return WINED3DERR_INVALIDCALL;
-        }
-    }
-
-    if (dstData == NULL || cnt < 0) {
+    if (dstData == NULL || cnt < 0)
         return WINED3DERR_INVALIDCALL;
-    }
-
-    CopyMemory(dstData, (char *)srcData + (start * registersize), cnt * registersize);
 
+    memcpy(dstData, &This->updateStateBlock->pixelShaderConstantB[start], cnt);
     return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, CONST BOOL   *pConstantData, UINT BoolCount) {
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    
-    return IWineD3DDeviceImpl_SetPixelShaderConstant(iface, 
-            This->updateStateBlock->pixelShaderConstantB, 
-            pConstantData, 
-            WINESHADERCNST_BOOL, 
-            StartRegister, 
-            BoolCount, 
-            sizeof(*pConstantData));
-}
+HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(
+    IWineD3DDevice *iface,
+    UINT start,
+    CONST int *srcData,
+    UINT count) {
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(IWineD3DDevice *iface, UINT StartRegister, BOOL         *pConstantData, UINT BoolCount) {
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    int i, cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
 
-    return IWineD3DDeviceImpl_GetPixelShaderConstant(iface, 
-            pConstantData, 
-            This->updateStateBlock->pixelShaderConstantB, 
-            WINESHADERCNST_BOOL, 
-            StartRegister, 
-            BoolCount, 
-            sizeof(*pConstantData));
-}
+    TRACE("(iface %p, srcData %p, start %d, count %d)\n",
+            iface, srcData, start, count);
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, CONST int    *pConstantData, UINT Vector4iCount) {
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    if (srcData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(&This->updateStateBlock->pixelShaderConstantI[start * 4], srcData, cnt * 16);
+
+    for (i = start; i < cnt + start; ++i) {
+        This->updateStateBlock->changed.pixelShaderConstantsI[i] = TRUE;
+        This->updateStateBlock->set.pixelShaderConstantsI[i]     = TRUE;
+    }
 
-    return IWineD3DDeviceImpl_SetPixelShaderConstant(iface, 
-            This->updateStateBlock->pixelShaderConstantI, 
-            pConstantData, 
-            WINESHADERCNST_INTEGER, 
-            StartRegister, 
-            Vector4iCount, 
-            4 * sizeof(*pConstantData));
+    return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(IWineD3DDevice *iface, UINT StartRegister, int          *pConstantData, UINT Vector4iCount) {
+HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(
+    IWineD3DDevice *iface,
+    UINT start,
+    int *dstData,
+    UINT count) {
+
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    
-    return IWineD3DDeviceImpl_GetPixelShaderConstant(iface, 
-            pConstantData, 
-            This->updateStateBlock->pixelShaderConstantI, 
-            WINESHADERCNST_INTEGER, 
-            StartRegister, 
-            Vector4iCount, 
-            4 * sizeof(*pConstantData));
+    int cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
+
+    TRACE("(iface %p, dstData %p, start %d, count %d)\n",
+            iface, dstData, start, count);
+
+    if (dstData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(dstData, &This->updateStateBlock->pixelShaderConstantI[start * 4], cnt * 16);
+    return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, CONST float  *pConstantData, UINT Vector4fCount) {
+HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(
+    IWineD3DDevice *iface,
+    UINT start,
+    CONST float *srcData,
+    UINT count) {
+
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    
-    return IWineD3DDeviceImpl_SetPixelShaderConstant(iface, 
-            This->updateStateBlock->pixelShaderConstantF, 
-            pConstantData, 
-            WINESHADERCNST_FLOAT, 
-            StartRegister, 
-            Vector4fCount, 
-            4 * sizeof(*pConstantData));
+    int i, cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
+
+    TRACE("(iface %p, srcData %p, start %d, count %d)\n",
+            iface, srcData, start, count);
+
+    if (srcData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(&This->updateStateBlock->pixelShaderConstantF[start * 4], srcData, cnt * 16);
+
+    for (i = start; i < cnt + start; ++i) {
+        This->updateStateBlock->changed.pixelShaderConstantsF[i] = TRUE;
+        This->updateStateBlock->set.pixelShaderConstantsF[i]     = TRUE;
+    }
+
+    return WINED3D_OK;
 }
 
-HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(IWineD3DDevice *iface, UINT StartRegister, float        *pConstantData, UINT Vector4fCount) {
+HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(
+    IWineD3DDevice *iface,
+    UINT start,
+    float *dstData,
+    UINT count) {
+
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    int cnt = min(count, MAX_PSHADER_CONSTANTS - (start + 1));
 
-    return IWineD3DDeviceImpl_GetPixelShaderConstant(iface, 
-            pConstantData, 
-            This->updateStateBlock->pixelShaderConstantF, 
-            WINESHADERCNST_FLOAT, 
-            StartRegister, 
-            Vector4fCount, 
-            4 * sizeof(*pConstantData));
-}
+    TRACE("(iface %p, dstData %p, start %d, count %d)\n",
+            iface, dstData, start, count);
 
-HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantN(IWineD3DDevice *iface, UINT StartRegister, UINT VectorNCount){
-    return IWineD3DDeviceImpl_SetPixelShaderConstant(iface, 
-            NULL, 
-            NULL, 
-            WINESHADERCNST_NONE, 
-            StartRegister, 
-            VectorNCount, 
-            0);
+    if (dstData == NULL || cnt < 0)
+        return WINED3DERR_INVALIDCALL;
+
+    memcpy(dstData, &This->updateStateBlock->pixelShaderConstantF[start * 4], cnt * 16);
+    return WINED3D_OK;
 }
 
 #define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size)
@@ -7470,15 +7467,12 @@ const IWineD3DDeviceVtbl IWineD3DDevice_
     IWineD3DDeviceImpl_GetPaletteEntries,
     IWineD3DDeviceImpl_SetPixelShader,
     IWineD3DDeviceImpl_GetPixelShader,
-    IWineD3DDeviceImpl_SetPixelShaderConstant,
-    IWineD3DDeviceImpl_GetPixelShaderConstant,
     IWineD3DDeviceImpl_SetPixelShaderConstantB,
     IWineD3DDeviceImpl_GetPixelShaderConstantB,
     IWineD3DDeviceImpl_SetPixelShaderConstantI,
     IWineD3DDeviceImpl_GetPixelShaderConstantI,
     IWineD3DDeviceImpl_SetPixelShaderConstantF,
     IWineD3DDeviceImpl_GetPixelShaderConstantF,
-    IWineD3DDeviceImpl_SetPixelShaderConstantN,
     IWineD3DDeviceImpl_SetRenderState,
     IWineD3DDeviceImpl_GetRenderState,
     IWineD3DDeviceImpl_SetRenderTarget,
@@ -7504,15 +7498,12 @@ const IWineD3DDeviceVtbl IWineD3DDevice_
     IWineD3DDeviceImpl_GetVertexDeclaration,
     IWineD3DDeviceImpl_SetVertexShader,
     IWineD3DDeviceImpl_GetVertexShader,
-    IWineD3DDeviceImpl_SetVertexShaderConstant,
-    IWineD3DDeviceImpl_GetVertexShaderConstant,
     IWineD3DDeviceImpl_SetVertexShaderConstantB,
     IWineD3DDeviceImpl_GetVertexShaderConstantB,
     IWineD3DDeviceImpl_SetVertexShaderConstantI,
     IWineD3DDeviceImpl_GetVertexShaderConstantI,
     IWineD3DDeviceImpl_SetVertexShaderConstantF,
     IWineD3DDeviceImpl_GetVertexShaderConstantF,
-    IWineD3DDeviceImpl_SetVertexShaderConstantN,
     IWineD3DDeviceImpl_SetViewport,
     IWineD3DDeviceImpl_GetViewport,
     IWineD3DDeviceImpl_MultiplyTransform,
diff --git a/dlls/wined3d/drawprim.c b/dlls/wined3d/drawprim.c
index 003eac9..fc89d01 100644
--- a/dlls/wined3d/drawprim.c
+++ b/dlls/wined3d/drawprim.c
@@ -1824,9 +1824,8 @@ #endif
 
             /* Update the constants */
             for (i = 0; i < WINED3D_VSHADER_MAX_CONSTANTS; ++i) {
-                /* TODO: add support for Integer and Boolean constants */
-                if (WINESHADERCNST_FLOAT == This->stateBlock->vertexShaderConstantT[i]) {
 
+                if (This->stateBlock->set.vertexShaderConstantsF[i]) {
                     GL_EXTCALL(glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, i,
                         &This->stateBlock->vertexShaderConstantF[i * 4]));
 
@@ -1836,8 +1835,11 @@ #endif
                         This->stateBlock->vertexShaderConstantF[i * 4 + 2],
                         This->stateBlock->vertexShaderConstantF[i * 4 + 3]);
                         checkGLcall("glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB");
+
+                    checkGLcall("glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB");
                 }
             }
+
         }
 
         if (usePixelShaderFunction) {
@@ -1858,16 +1860,19 @@ #endif
 
              /* Update the constants */
              for (i = 0; i < WINED3D_PSHADER_MAX_CONSTANTS; ++i) {
-                 /* TODO: add support for Integer and Boolean constants */
-                 if (WINESHADERCNST_FLOAT == This->stateBlock->pixelShaderConstantT[i]) {
+
+                 if (This->stateBlock->set.pixelShaderConstantsF[i]) {
+
                      GL_EXTCALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, i,
                         &This->stateBlock->pixelShaderConstantF[i * 4]));
+
                      TRACE_(d3d_shader)("Loading constants %u = %f %f %f %f\n", i,
                         This->stateBlock->pixelShaderConstantF[i * 4],
                         This->stateBlock->pixelShaderConstantF[i * 4 + 1],
                         This->stateBlock->pixelShaderConstantF[i * 4 + 2],
                         This->stateBlock->pixelShaderConstantF[i * 4 + 3]);
-                     checkGLcall("glProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB");
+
+                     checkGLcall("glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB");
                  }
             }
         }
diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c
index af1a265..c694f44 100644
--- a/dlls/wined3d/stateblock.c
+++ b/dlls/wined3d/stateblock.c
@@ -168,18 +168,38 @@ HRESULT WINAPI IWineD3DStateBlockImpl_Ca
 
         /* Vertex Shader Constants */
         for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
-            if (This->set.vertexShaderConstants[i]) {
-                TRACE("Setting %p from %p %d to %f\n", This, targetStateBlock, i,  targetStateBlock->vertexShaderConstantF[i * 4 + 1]);
-                This->vertexShaderConstantB[i] = targetStateBlock->vertexShaderConstantB[i];
+
+            if (This->set.vertexShaderConstantsF[i]) {
+                TRACE("Setting %p from %p %d to { %f, %f, %f, %f }\n", This, targetStateBlock, i,
+                    targetStateBlock->vertexShaderConstantF[i * 4],
+                    targetStateBlock->vertexShaderConstantF[i * 4 + 1],
+                    targetStateBlock->vertexShaderConstantF[i * 4 + 2],
+                    targetStateBlock->vertexShaderConstantF[i * 4 + 3]);
+
                 This->vertexShaderConstantF[i * 4]      = targetStateBlock->vertexShaderConstantF[i * 4];
                 This->vertexShaderConstantF[i * 4 + 1]  = targetStateBlock->vertexShaderConstantF[i * 4 + 1];
                 This->vertexShaderConstantF[i * 4 + 2]  = targetStateBlock->vertexShaderConstantF[i * 4 + 2];
                 This->vertexShaderConstantF[i * 4 + 3]  = targetStateBlock->vertexShaderConstantF[i * 4 + 3];
+            }
+
+            if (This->set.vertexShaderConstantsI[i]) {
+                TRACE("Setting %p from %p %d to { %d, %d, %d, %d }\n", This, targetStateBlock, i,
+                    targetStateBlock->vertexShaderConstantI[i * 4],
+                    targetStateBlock->vertexShaderConstantI[i * 4 + 1],
+                    targetStateBlock->vertexShaderConstantI[i * 4 + 2],
+                    targetStateBlock->vertexShaderConstantI[i * 4 + 3]);
+
                 This->vertexShaderConstantI[i * 4]      = targetStateBlock->vertexShaderConstantI[i * 4];
                 This->vertexShaderConstantI[i * 4 + 1]  = targetStateBlock->vertexShaderConstantI[i * 4 + 1];
                 This->vertexShaderConstantI[i * 4 + 2]  = targetStateBlock->vertexShaderConstantI[i * 4 + 2];
                 This->vertexShaderConstantI[i * 4 + 3]  = targetStateBlock->vertexShaderConstantI[i * 4 + 3];
-                This->vertexShaderConstantT[i]          = targetStateBlock->vertexShaderConstantT[i];
+            }
+
+            if (This->set.vertexShaderConstantsB[i]) {
+                TRACE("Setting %p from %p %d to %s\n", This, targetStateBlock, i,
+                    targetStateBlock->vertexShaderConstantB[i]? "TRUE":"FALSE");
+
+                This->vertexShaderConstantB[i] =  targetStateBlock->vertexShaderConstantB[i];
             }
         }
 
@@ -230,20 +250,39 @@ HRESULT WINAPI IWineD3DStateBlockImpl_Ca
             This->pixelShader = targetStateBlock->pixelShader;
         }
 
-        /* Pixel Shader Constants */
         for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
-            if (This->set.pixelShaderConstants[i]) {
-                TRACE("Setting %p from %p %d to %f\n", This, targetStateBlock, i,  targetStateBlock->pixelShaderConstantF[i * 4 + 1]);
-                This->pixelShaderConstantB[i] = targetStateBlock->pixelShaderConstantB[i];
+
+            if (This->set.pixelShaderConstantsF[i]) {
+                TRACE("Setting %p from %p %d to { %f, %f, %f, %f }\n", This, targetStateBlock, i,
+                    targetStateBlock->pixelShaderConstantF[i * 4],
+                    targetStateBlock->pixelShaderConstantF[i * 4 + 1],
+                    targetStateBlock->pixelShaderConstantF[i * 4 + 2],
+                    targetStateBlock->pixelShaderConstantF[i * 4 + 3]);
+
                 This->pixelShaderConstantF[i * 4]      = targetStateBlock->pixelShaderConstantF[i * 4];
                 This->pixelShaderConstantF[i * 4 + 1]  = targetStateBlock->pixelShaderConstantF[i * 4 + 1];
                 This->pixelShaderConstantF[i * 4 + 2]  = targetStateBlock->pixelShaderConstantF[i * 4 + 2];
                 This->pixelShaderConstantF[i * 4 + 3]  = targetStateBlock->pixelShaderConstantF[i * 4 + 3];
+            }
+
+            if (This->set.pixelShaderConstantsI[i]) {
+                TRACE("Setting %p from %p %d to { %d, %d, %d, %d }\n", This, targetStateBlock, i,
+                    targetStateBlock->pixelShaderConstantI[i * 4],
+                    targetStateBlock->pixelShaderConstantI[i * 4 + 1],
+                    targetStateBlock->pixelShaderConstantI[i * 4 + 2],
+                    targetStateBlock->pixelShaderConstantI[i * 4 + 3]);
+
                 This->pixelShaderConstantI[i * 4]      = targetStateBlock->pixelShaderConstantI[i * 4];
                 This->pixelShaderConstantI[i * 4 + 1]  = targetStateBlock->pixelShaderConstantI[i * 4 + 1];
                 This->pixelShaderConstantI[i * 4 + 2]  = targetStateBlock->pixelShaderConstantI[i * 4 + 2];
                 This->pixelShaderConstantI[i * 4 + 3]  = targetStateBlock->pixelShaderConstantI[i * 4 + 3];
-                This->pixelShaderConstantT[i]          = targetStateBlock->pixelShaderConstantT[i];
+            }
+
+            if (This->set.pixelShaderConstantsB[i]) {
+                TRACE("Setting %p from %p %d to %s\n", This, targetStateBlock, i,
+                    targetStateBlock->pixelShaderConstantB[i]? "TRUE":"FALSE");
+
+                This->pixelShaderConstantB[i] =  targetStateBlock->pixelShaderConstantB[i];
             }
         }
 
@@ -408,24 +447,15 @@ should really perform a delta so that on
 
         /* Vertex Shader Constants */
         for (i = 0; i < MAX_VSHADER_CONSTANTS; ++i) {
-            if (This->set.vertexShaderConstants[i] && This->changed.vertexShaderConstants[i]) {
-                switch (This->vertexShaderConstantT[i]) {
-                case WINESHADERCNST_FLOAT:
-                    IWineD3DDevice_SetVertexShaderConstantF(pDevice, i, This->vertexShaderConstantF + i * 4, 1);
-                break;
-                case WINESHADERCNST_BOOL:
-                    IWineD3DDevice_SetVertexShaderConstantB(pDevice, i, This->vertexShaderConstantB + i, 1);
-                break;
-                case WINESHADERCNST_INTEGER:
-                    IWineD3DDevice_SetVertexShaderConstantI(pDevice, i, This->vertexShaderConstantI + i * 4, 1);
-                break;
-                case WINESHADERCNST_NONE:
-                    IWineD3DDevice_SetVertexShaderConstantN(pDevice, i, 1);
-                break;
-                }
-            }
-        }
+            if (This->set.vertexShaderConstantsF[i] && This->changed.vertexShaderConstantsF[i])
+                IWineD3DDevice_SetVertexShaderConstantF(pDevice, i, This->vertexShaderConstantF + i * 4, 1);
 
+            if (This->set.vertexShaderConstantsI[i] && This->changed.vertexShaderConstantsI[i])
+                IWineD3DDevice_SetVertexShaderConstantI(pDevice, i, This->vertexShaderConstantI + i * 4, 1);
+
+            if (This->set.vertexShaderConstantsB[i] && This->changed.vertexShaderConstantsB[i])
+                IWineD3DDevice_SetVertexShaderConstantB(pDevice, i, This->vertexShaderConstantB + i, 1);
+        }
     }
 
     if (/*TODO: 'magic' statetype, replace with BOOL This->blockType == D3DSBT_RECORDED || */ This->blockType == D3DSBT_ALL || This->blockType == D3DSBT_PIXELSTATE) {
@@ -437,22 +467,14 @@ should really perform a delta so that on
 
         /* Pixel Shader Constants */
         for (i = 0; i < MAX_PSHADER_CONSTANTS; ++i) {
-            if (This->set.pixelShaderConstants[i] && This->changed.pixelShaderConstants[i]) {
-                switch (This->pixelShaderConstantT[i]) {
-                case WINESHADERCNST_FLOAT:
-                    IWineD3DDevice_SetPixelShaderConstantF(pDevice, i, This->pixelShaderConstantF + i * 4, 1);
-                break;
-                case WINESHADERCNST_BOOL:
-                    IWineD3DDevice_SetPixelShaderConstantB(pDevice, i, This->pixelShaderConstantB + i, 1);
-                break;
-                case WINESHADERCNST_INTEGER:
-                    IWineD3DDevice_SetPixelShaderConstantI(pDevice, i, This->pixelShaderConstantI + i * 4, 1);
-                break;
-                case WINESHADERCNST_NONE:
-                    IWineD3DDevice_SetPixelShaderConstantN(pDevice, i, 1);
-                break;
-                }
-            }
+            if (This->set.pixelShaderConstantsF[i] && This->changed.pixelShaderConstantsF[i])
+                IWineD3DDevice_SetPixelShaderConstantF(pDevice, i, This->pixelShaderConstantF + i * 4, 1);
+
+            if (This->set.pixelShaderConstantsI[i] && This->changed.pixelShaderConstantsI[i])
+                IWineD3DDevice_SetPixelShaderConstantI(pDevice, i, This->pixelShaderConstantI + i * 4, 1);
+
+            if (This->set.pixelShaderConstantsB[i] && This->changed.pixelShaderConstantsB[i])
+                IWineD3DDevice_SetPixelShaderConstantB(pDevice, i, This->pixelShaderConstantB + i, 1);
         }
     }
 
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 5148c01..d9c7406 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -979,18 +979,15 @@ typedef struct SAVEDSTATES {
         BOOL                      clipplane[MAX_CLIPPLANES];
         BOOL                      vertexDecl;
         BOOL                      pixelShader;
-        BOOL                      pixelShaderConstants[MAX_PSHADER_CONSTANTS];
+        BOOL                      pixelShaderConstantsB[MAX_PSHADER_CONSTANTS];
+        BOOL                      pixelShaderConstantsI[MAX_PSHADER_CONSTANTS];
+        BOOL                      pixelShaderConstantsF[MAX_PSHADER_CONSTANTS];
         BOOL                      vertexShader;
-        BOOL                      vertexShaderConstants[MAX_VSHADER_CONSTANTS];
+        BOOL                      vertexShaderConstantsB[MAX_VSHADER_CONSTANTS];
+        BOOL                      vertexShaderConstantsI[MAX_VSHADER_CONSTANTS];
+        BOOL                      vertexShaderConstantsF[MAX_VSHADER_CONSTANTS];
 } SAVEDSTATES;
 
-typedef enum {
-    WINESHADERCNST_NONE     = 0,
-    WINESHADERCNST_FLOAT    = 1,
-    WINESHADERCNST_INTEGER  = 2,
-    WINESHADERCNST_BOOL     = 3
-} WINESHADERCNST;
-
 struct IWineD3DStateBlockImpl
 {
     /* IUnknown fields */
@@ -1017,7 +1014,6 @@ struct IWineD3DStateBlockImpl
     BOOL                       vertexShaderConstantB[MAX_VSHADER_CONSTANTS];
     INT                        vertexShaderConstantI[MAX_VSHADER_CONSTANTS * 4];
     float                      vertexShaderConstantF[MAX_VSHADER_CONSTANTS * 4];
-    WINESHADERCNST             vertexShaderConstantT[MAX_VSHADER_CONSTANTS]; /* TODO: Think about changing this to a char to possibly save a little memory */
 
     /* Stream Source */
     BOOL                      streamIsUP;
@@ -1054,7 +1050,6 @@ struct IWineD3DStateBlockImpl
     BOOL                       pixelShaderConstantB[MAX_PSHADER_CONSTANTS];
     INT                        pixelShaderConstantI[MAX_PSHADER_CONSTANTS * 4];
     float                      pixelShaderConstantF[MAX_PSHADER_CONSTANTS * 4];
-    WINESHADERCNST             pixelShaderConstantT[MAX_PSHADER_CONSTANTS]; /* TODO: Think about changing this to a char to possibly save a little memory */
 
     /* Indexed Vertex Blending */
     D3DVERTEXBLENDFLAGS       vertex_blend;
diff --git a/include/wine/wined3d_interface.h b/include/wine/wined3d_interface.h
index 944e764..c4fea25 100644
--- a/include/wine/wined3d_interface.h
+++ b/include/wine/wined3d_interface.h
@@ -433,15 +433,12 @@ DECLARE_INTERFACE_(IWineD3DDevice,IWineD
     STDMETHOD(GetPaletteEntries)(THIS_ UINT PaletteNumber,PALETTEENTRY* pEntries) PURE;
     STDMETHOD(SetPixelShader)(THIS_ struct IWineD3DPixelShader  *pShader) PURE;
     STDMETHOD(GetPixelShader)(THIS_ struct IWineD3DPixelShader **ppShader) PURE;
-    STDMETHOD(SetPixelShaderConstant)(THIS_ void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT countsize);
-    STDMETHOD(GetPixelShaderConstant)(THIS_ void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT countsize);
     STDMETHOD(SetPixelShaderConstantB)(THIS_ UINT StartRegister, CONST BOOL* pConstantData, UINT  BoolCount) PURE;
     STDMETHOD(GetPixelShaderConstantB)(THIS_ UINT StartRegister, BOOL* pConstantData, UINT BoolCount) PURE;
     STDMETHOD(SetPixelShaderConstantI)(THIS_ UINT StartRegister, CONST int* pConstantData, UINT Vector4iCount) PURE;
     STDMETHOD(GetPixelShaderConstantI)(THIS_ UINT StartRegister, int* pConstantData, UINT Vector4iCount) PURE;
     STDMETHOD(SetPixelShaderConstantF)(THIS_ UINT StartRegister, CONST float* pConstantData, UINT Vector4fCount) PURE;
     STDMETHOD(GetPixelShaderConstantF)(THIS_ UINT StartRegister, float* pConstantData, UINT Vector4fCount) PURE;
-    STDMETHOD(SetPixelShaderConstantN)(THIS_ UINT StartRegister, UINT VectorNCount) PURE;
     STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE  State,DWORD  Value) PURE;
     STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE  State,DWORD * pValue) PURE;
     STDMETHOD(SetRenderTarget)(THIS_ DWORD RenderTargetIndex, struct IWineD3DSurface* pRenderTarget) PURE;
@@ -467,15 +464,12 @@ DECLARE_INTERFACE_(IWineD3DDevice,IWineD
     STDMETHOD(GetVertexDeclaration)(THIS_ struct IWineD3DVertexDeclaration** ppDecl) PURE;
     STDMETHOD(SetVertexShader)(THIS_ struct IWineD3DVertexShader* pShader) PURE;
     STDMETHOD(GetVertexShader)(THIS_ struct IWineD3DVertexShader** ppShader) PURE;
-    STDMETHOD(SetVertexShaderConstant)(THIS_ void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT countsize);
-    STDMETHOD(GetVertexShaderConstant)(THIS_ void *dstData, const void *srcData, UINT type, UINT start, UINT count, UINT countsize);
     STDMETHOD(SetVertexShaderConstantB)(THIS_ UINT StartRegister, CONST BOOL*  pConstantData, UINT BoolCount) PURE;
     STDMETHOD(GetVertexShaderConstantB)(THIS_ UINT StartRegister, BOOL*        pConstantData, UINT BoolCount) PURE;
     STDMETHOD(SetVertexShaderConstantI)(THIS_ UINT StartRegister, CONST int*   pConstantData, UINT Vector4iCount) PURE;
     STDMETHOD(GetVertexShaderConstantI)(THIS_ UINT StartRegister, int*         pConstantData, UINT Vector4iCount) PURE;
     STDMETHOD(SetVertexShaderConstantF)(THIS_ UINT StartRegister, CONST float* pConstantData, UINT Vector4fCount) PURE;
     STDMETHOD(GetVertexShaderConstantF)(THIS_ UINT StartRegister, float*       pConstantData, UINT Vector4fCount) PURE;
-    STDMETHOD(SetVertexShaderConstantN)(THIS_ UINT StartRegister, UINT VectorNCount) PURE;
     STDMETHOD(SetViewport)(THIS_ CONST WINED3DVIEWPORT * pViewport) PURE;
     STDMETHOD(GetViewport)(THIS_ WINED3DVIEWPORT * pViewport) PURE;
     STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE  State, CONST D3DMATRIX * pMatrix) PURE;
@@ -579,15 +573,12 @@ #define IWineD3DDevice_SetPaletteEntries
 #define IWineD3DDevice_GetPaletteEntries(p,a,b)                 (p)->lpVtbl->GetPaletteEntries(p,a,b)
 #define IWineD3DDevice_SetPixelShader(p,a)                      (p)->lpVtbl->SetPixelShader(p,a)
 #define IWineD3DDevice_GetPixelShader(p,a)                      (p)->lpVtbl->GetPixelShader(p,a)
-#define IWineD3DDevice_SetPixelShaderConstant(p,a,b,c,d,e,f);   (p)->lpVtbl->SetPixelShaderConstant(p,a,b,c,d,e,f)
-#define IWineD3DDevice_GetPixelShaderConstant(p,a,b,c,d,e,f);   (p)->lpVtbl->GetPixelShaderConstant(p,a,b,c,d,e,f)
 #define IWineD3DDevice_SetPixelShaderConstantB(p,a,b,c)         (p)->lpVtbl->SetPixelShaderConstantB(p,a,b,c)
 #define IWineD3DDevice_GetPixelShaderConstantB(p,a,b,c)         (p)->lpVtbl->GetPixelShaderConstantB(p,a,b,c)
 #define IWineD3DDevice_SetPixelShaderConstantI(p,a,b,c)         (p)->lpVtbl->SetPixelShaderConstantI(p,a,b,c)
 #define IWineD3DDevice_GetPixelShaderConstantI(p,a,b,c)         (p)->lpVtbl->GetPixelShaderConstantI(p,a,b,c)
 #define IWineD3DDevice_SetPixelShaderConstantF(p,a,b,c)         (p)->lpVtbl->SetPixelShaderConstantF(p,a,b,c)
 #define IWineD3DDevice_GetPixelShaderConstantF(p,a,b,c)         (p)->lpVtbl->GetPixelShaderConstantF(p,a,b,c)
-#define IWineD3DDevice_SetPixelShaderConstantN(p,a,b)           (p)->lpVtbl->SetPixelShaderConstantN(p,a,b)
 #define IWineD3DDevice_GetRasterStatus(p,a,b)                   (p)->lpVtbl->GetRasterStatus(p,a,b)
 #define IWineD3DDevice_SetRenderState(p,a,b)                    (p)->lpVtbl->SetRenderState(p,a,b)
 #define IWineD3DDevice_GetRenderState(p,a,b)                    (p)->lpVtbl->GetRenderState(p,a,b)
@@ -615,15 +606,12 @@ #define IWineD3DDevice_SetVertexDeclarat
 #define IWineD3DDevice_GetVertexDeclaration(p,a)                (p)->lpVtbl->GetVertexDeclaration(p,a)
 #define IWineD3DDevice_SetVertexShader(p,a)                     (p)->lpVtbl->SetVertexShader(p,a)
 #define IWineD3DDevice_GetVertexShader(p,a)                     (p)->lpVtbl->GetVertexShader(p,a)
-#define IWineD3DDevice_SetVertexShaderConstant(p,a,b,c,d,e,f);  (p)->lpVtbl->SetVertexShaderConstant(p,a,b,c,d,e,f)
-#define IWineD3DDevice_GetVertexShaderConstant(p,a,b,c,d,e,f);  (p)->lpVtbl->GetVertexShaderConstant(p,a,b,c,d,e,f)
 #define IWineD3DDevice_SetVertexShaderConstantB(p,a,b,c)        (p)->lpVtbl->SetVertexShaderConstantB(p,a,b,c)
 #define IWineD3DDevice_GetVertexShaderConstantB(p,a,b,c)        (p)->lpVtbl->GetVertexShaderConstantB(p,a,b,c)
 #define IWineD3DDevice_SetVertexShaderConstantI(p,a,b,c)        (p)->lpVtbl->SetVertexShaderConstantI(p,a,b,c)
 #define IWineD3DDevice_GetVertexShaderConstantI(p,a,b,c)        (p)->lpVtbl->GetVertexShaderConstantI(p,a,b,c)
 #define IWineD3DDevice_SetVertexShaderConstantF(p,a,b,c)        (p)->lpVtbl->SetVertexShaderConstantF(p,a,b,c)
 #define IWineD3DDevice_GetVertexShaderConstantF(p,a,b,c)        (p)->lpVtbl->GetVertexShaderConstantF(p,a,b,c)
-#define IWineD3DDevice_SetVertexShaderConstantN(p,a,b)          (p)->lpVtbl->SetVertexShaderConstantN(p,a,b)
 #define IWineD3DDevice_SetViewport(p,a)                         (p)->lpVtbl->SetViewport(p,a)
 #define IWineD3DDevice_GetViewport(p,a)                         (p)->lpVtbl->GetViewport(p,a)
 #define IWineD3DDevice_MultiplyTransform(p,a,b)                 (p)->lpVtbl->MultiplyTransform(p,a,b)
-- 
1.3.3



More information about the wine-patches mailing list