diff --git a/dlls/d3d9/d3d9_private.h b/dlls/d3d9/d3d9_private.h
index 6e84faf..e90b43a 100644
--- a/dlls/d3d9/d3d9_private.h
+++ b/dlls/d3d9/d3d9_private.h
@@ -315,7 +315,7 @@ HRESULT vertexshader_init(struct d3d9_vertexshader *shader,
         struct d3d9_device *device, const DWORD *byte_code) DECLSPEC_HIDDEN;
 struct d3d9_vertexshader *unsafe_impl_from_IDirect3DVertexShader9(IDirect3DVertexShader9 *iface) DECLSPEC_HIDDEN;
 
-#define D3D9_MAX_VERTEX_SHADER_CONSTANTF 256
+#define D3D9_MAX_VERTEX_SHADER_CONSTANTF 1024
 #define D3D9_MAX_SIMULTANEOUS_RENDERTARGETS 4
 
 struct d3d9_pixelshader
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index 7e85988..cdc25a2 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -427,14 +427,14 @@ static void shader_set_limits(struct wined3d_shader *shader)
     vs_limits[] =
     {
         /* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packed_input */
-        {WINED3D_SHADER_VERSION(1, 0), WINED3D_SHADER_VERSION(1, 1), { 0,  0, 256,  0, 12,  0}},
-        {WINED3D_SHADER_VERSION(2, 0), WINED3D_SHADER_VERSION(2, 1), { 0, 16, 256, 16, 12,  0}},
+        {WINED3D_SHADER_VERSION(1, 0), WINED3D_SHADER_VERSION(1, 1), { 0,  0, /*256 */1024,  0, 12,  0}},
+        {WINED3D_SHADER_VERSION(2, 0), WINED3D_SHADER_VERSION(2, 1), { 0, 16, /*256 */1024, 16, 12,  0}},
         /* DX10 cards on Windows advertise a D3D9 constant limit of 256
          * even though they are capable of supporting much more (GL
          * drivers advertise 1024). d3d9.dll and d3d8.dll clamp the
          * wined3d-advertised maximum. Clamp the constant limit for <= 3.0
          * shaders to 256. */
-        {WINED3D_SHADER_VERSION(3, 0), WINED3D_SHADER_VERSION(3, 0), { 4, 16, 256, 16, 12,  0}},
+        {WINED3D_SHADER_VERSION(3, 0), WINED3D_SHADER_VERSION(3, 0), { 4, 16, /*256*/1024, 16, 12,  0}},
         {WINED3D_SHADER_VERSION(4, 0), WINED3D_SHADER_VERSION(4, 0), {16,  0,   0,  0, 16,  0}},
         {0}
     },
@@ -743,8 +743,10 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
                         break;
                     }
                     if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL && shader_version.major == 3
-                            && semantic->usage == WINED3D_DECL_USAGE_POSITION && !semantic->usage_idx)
+                            && semantic->usage == WINED3D_DECL_USAGE_POSITION && !semantic->usage_idx) {
+			WARN("shader_version.type == WINED3D_SHADER_TYPE_PIXEL && shader_version.major == 3 ...\n");
                         return WINED3DERR_INVALIDCALL;
+		    }
                     reg_maps->input_registers |= 1u << reg_idx;
                     shader_signature_from_semantic(&input_signature_elements[reg_idx], semantic);
                     break;
@@ -886,8 +888,10 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
             for (i = 0; i < ins.dst_count; ++i)
             {
                 if (!shader_record_register_usage(shader, reg_maps, &ins.dst[i].reg,
-                        shader_version.type, constf_size))
+                        shader_version.type, constf_size)) {
+                    WARN("!shader_record_register_usage\n");
                     return WINED3DERR_INVALIDCALL;
+		}
 
                 if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX)
                 {
@@ -1061,8 +1065,10 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
 
             if (ins.predicate)
                 if (!shader_record_register_usage(shader, reg_maps, &ins.predicate->reg,
-                        shader_version.type, constf_size))
+                        shader_version.type, constf_size)) {
+		    WARN("!shader_record_register_usage (2)");
                     return WINED3DERR_INVALIDCALL;
+		}
 
             for (i = 0; i < ins.src_count; ++i)
             {
@@ -1070,14 +1076,18 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
                 struct wined3d_shader_register reg = ins.src[i].reg;
 
                 if (!shader_record_register_usage(shader, reg_maps, &ins.src[i].reg,
-                        shader_version.type, constf_size))
+                        shader_version.type, constf_size)) {
+                    WARN("!shader_record_register_usage (3)\n");
                     return WINED3DERR_INVALIDCALL;
+		}
                 while (count)
                 {
                     ++reg.idx[0].offset;
                     if (!shader_record_register_usage(shader, reg_maps, &reg,
-                            shader_version.type, constf_size))
+                            shader_version.type, constf_size)) {
+			WARN("!shader_record_register_usage (4)");  
                         return WINED3DERR_INVALIDCALL;
+		    }
                     --count;
                 }
 
@@ -1090,7 +1100,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
                         shader->u.ps.color0_reg = ins.src[i].reg.idx[0].offset;
                     }
                 }
-            }
+            } //for (i = 0; i < ins.src_count; ++i)
         }
     }
     reg_maps->loop_depth = max_loop_depth;
@@ -2071,8 +2081,10 @@ static HRESULT shader_set_function(struct wined3d_shader *shader, const DWORD *b
 
     /* Second pass: figure out which registers are used, what the semantics are, etc. */
     if (FAILED(hr = shader_get_registers_used(shader, fe, reg_maps, &shader->input_signature,
-            &shader->output_signature, byte_code, float_const_count)))
-        return hr;
+            &shader->output_signature, byte_code, float_const_count))) {
+	    	WARN("Error shader_get_registers_used\n");
+        	return hr;
+	}
 
     if (reg_maps->shader_version.type != type)
     {