wine/wine-staging
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-staging.git synced 2025-01-28 22:04:43 -08:00
Code Issues Packages Projects Releases Wiki Activity

wined3d-SWVP-shaders, wined3d-Indexed_Vertex_Blending: Add new patch sets from Paul Gofman.

Browse Source
This commit is contained in:
Zebediah Figura 2019-02-27 20:23:10 -06:00
parent 7c1618b197
commit b02bd9c446
19 changed files with 2102 additions and 1504 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
patches/patchinstall.sh
View File

@ -52,7 +52,7 @@ usage()
# Get the upstream commit sha
upstream_commit()
{
echo "474a6771ba03e2c475cd088ff40c97e8285a455f"
echo "d88f12950761e9ff8d125a579de6e743979f4945"
}
# Show version information
@ -341,6 +341,7 @@ patch_enable_all ()
enable_wined3d_Dual_Source_Blending="$1"
enable_wined3d_Indexed_Vertex_Blending="$1"
enable_wined3d_Restore_DirectX10_Support="$1"
enable_wined3d_SWVP_shaders="$1"
enable_wined3d_Silence_FIXMEs="$1"
enable_wined3d_UAV_Counters="$1"
enable_wined3d_WINED3DFMT_B8G8R8X8_UNORM="$1"
@ -1170,6 +1171,9 @@ patch_enable ()
wined3d-Restore-DirectX10-Support)
enable_wined3d_Restore_DirectX10_Support="$2"
;;
wined3d-SWVP-shaders)
enable_wined3d_SWVP_shaders="$2"
;;
wined3d-Silence_FIXMEs)
enable_wined3d_Silence_FIXMEs="$2"
;;
@ -1723,9 +1727,20 @@ if test "$enable_winedevice_Default_Drivers" -eq 1; then
fi
if test "$enable_wined3d_Indexed_Vertex_Blending" -eq 1; then
if test "$enable_wined3d_SWVP_shaders" -gt 1; then
abort "Patchset wined3d-SWVP-shaders disabled, but wined3d-Indexed_Vertex_Blending depends on that."
fi
if test "$enable_wined3d_WINED3D_RS_COLORWRITEENABLE" -gt 1; then
abort "Patchset wined3d-WINED3D_RS_COLORWRITEENABLE disabled, but wined3d-Indexed_Vertex_Blending depends on that."
fi
enable_wined3d_SWVP_shaders=1
enable_wined3d_WINED3D_RS_COLORWRITEENABLE=1
fi
if test "$enable_wined3d_SWVP_shaders" -eq 1; then
if test "$enable_wined3d_WINED3D_RS_COLORWRITEENABLE" -gt 1; then
abort "Patchset wined3d-WINED3D_RS_COLORWRITEENABLE disabled, but wined3d-SWVP-shaders depends on that."
fi
enable_wined3d_WINED3D_RS_COLORWRITEENABLE=1
fi
@ -6819,38 +6834,59 @@ if test "$enable_wined3d_WINED3D_RS_COLORWRITEENABLE" -eq 1; then
) >> "$patchlist"
fi
# Patchset wined3d-Indexed_Vertex_Blending
# Patchset wined3d-SWVP-shaders
# |
# | This patchset has the following (direct or indirect) dependencies:
# | * wined3d-WINED3D_RS_COLORWRITEENABLE
# |
# | This patchset fixes the following Wine bugs:
# | * [#39057] Support for indexed vertex blending
# | * [#8051] Sims 2 demo exits prematurely
# |
# | Modified files:
# | * dlls/d3d9/tests/visual.c, dlls/wined3d/context.c, dlls/wined3d/device.c, dlls/wined3d/directx.c,
# | dlls/wined3d/glsl_shader.c, dlls/wined3d/utils.c, dlls/wined3d/vertexdeclaration.c, dlls/wined3d/wined3d_private.h
# | * dlls/d3d9/d3d9_private.h, dlls/d3d9/device.c, dlls/d3d9/directx.c, dlls/d3d9/tests/device.c, dlls/d3d9/tests/visual.c,
# | dlls/wined3d/adapter_gl.c, dlls/wined3d/device.c, dlls/wined3d/glsl_shader.c, dlls/wined3d/shader.c,
# | dlls/wined3d/shader_sm1.c, dlls/wined3d/stateblock.c, dlls/wined3d/utils.c, dlls/wined3d/wined3d_private.h
# |
if test "$enable_wined3d_SWVP_shaders" -eq 1; then
patch_apply wined3d-SWVP-shaders/0001-wined3d-Use-UBO-for-vertex-shader-float-constants-if.patch
patch_apply wined3d-SWVP-shaders/0002-d3d9-Support-SWVP-vertex-shader-float-constants-limi.patch
patch_apply wined3d-SWVP-shaders/0003-wined3d-Report-actual-vertex-shader-float-constants-.patch
patch_apply wined3d-SWVP-shaders/0004-wined3d-Support-SWVP-vertex-shader-constants-limit-i.patch
patch_apply wined3d-SWVP-shaders/0005-wined3d-Support-SWVP-mode-vertex-shaders.patch
(
printf '%s\n' '+ { "Paul Gofman", "wined3d: Use UBO for vertex shader float constants if supported.", 1 },';
printf '%s\n' '+ { "Paul Gofman", "d3d9: Support SWVP vertex shader float constants limits.", 1 },';
printf '%s\n' '+ { "Paul Gofman", "wined3d: Report actual vertex shader float constants limit for SWVP device.", 1 },';
printf '%s\n' '+ { "Paul Gofman", "wined3d: Support SWVP vertex shader constants limit in state tracking.", 1 },';
printf '%s\n' '+ { "Paul Gofman", "wined3d: Support SWVP mode vertex shaders.", 1 },';
) >> "$patchlist"
fi
# Patchset wined3d-Indexed_Vertex_Blending
# |
# | This patchset has the following (direct or indirect) dependencies:
# | * wined3d-WINED3D_RS_COLORWRITEENABLE, wined3d-SWVP-shaders
# |
# | This patchset fixes the following Wine bugs:
# | * [#39057] Support for Indexed Vertex Blending
# |
# | Modified files:
# | * dlls/d3d9/tests/visual.c, dlls/wined3d/adapter_gl.c, dlls/wined3d/cs.c, dlls/wined3d/device.c, dlls/wined3d/directx.c,
# | dlls/wined3d/glsl_shader.c, dlls/wined3d/state.c, dlls/wined3d/utils.c, dlls/wined3d/vertexdeclaration.c,
# | dlls/wined3d/wined3d_private.h
# |
if test "$enable_wined3d_Indexed_Vertex_Blending" -eq 1; then
patch_apply wined3d-Indexed_Vertex_Blending/0001-d3d9-tests-Add-test-for-indexed-vertex-blending.patch
patch_apply wined3d-Indexed_Vertex_Blending/0002-wined3d-Implement-hardware-indexed-vertex-blending-w.patch
patch_apply wined3d-Indexed_Vertex_Blending/0003-d3d9-tests-Test-normal-calculation-when-indexed-vert.patch
patch_apply wined3d-Indexed_Vertex_Blending/0004-wined3d-Fix-calculation-of-normal-when-vertex-blendi.patch
patch_apply wined3d-Indexed_Vertex_Blending/0005-wined3d-Move-matrix-inversion-functions-into-utils.c.patch
patch_apply wined3d-Indexed_Vertex_Blending/0006-wined3d-Implement-software-processing-for-indexed-ve.patch
patch_apply wined3d-Indexed_Vertex_Blending/0007-d3d9-tests-Check-MaxVertexBlendMatrixIndex-capabilit.patch
patch_apply wined3d-Indexed_Vertex_Blending/0008-wined3d-Report-correct-number-of-blend-matrices-when.patch
patch_apply wined3d-Indexed_Vertex_Blending/0009-wined3d-Track-updates-of-vertex-blend-matrices-separ.patch
patch_apply wined3d-Indexed_Vertex_Blending/0002-d3d9-tests-Test-normal-calculation-when-indexed-vert.patch
patch_apply wined3d-Indexed_Vertex_Blending/0003-d3d9-tests-Check-MaxVertexBlendMatrixIndex-capabilit.patch
patch_apply wined3d-Indexed_Vertex_Blending/0004-wined3d-Allow-higher-world-matrix-states.patch
patch_apply wined3d-Indexed_Vertex_Blending/0005-wined3d-Support-indexed-vertex-blending.patch
(
printf '%s\n' '+ { "Paul Gofman", "d3d9/tests: Add test for indexed vertex blending.", 1 },';
printf '%s\n' '+ { "Paul Gofman", "wined3d: Implement hardware indexed vertex blending with 9 matrices.", 1 },';
printf '%s\n' '+ { "Michael Müller", "d3d9/tests: Test normal calculation when indexed vertex blending is enabled.", 1 },';
printf '%s\n' '+ { "Michael Müller", "wined3d: Fix calculation of normal when vertex blending is enabled.", 1 },';
printf '%s\n' '+ { "Michael Müller", "wined3d: Move matrix inversion functions into utils.c.", 1 },';
printf '%s\n' '+ { "Michael Müller", "wined3d: Implement software processing for indexed vertex blending.", 1 },';
printf '%s\n' '+ { "Michael Müller", "d3d9/tests: Check MaxVertexBlendMatrixIndex capability.", 1 },';
printf '%s\n' '+ { "Michael Müller", "wined3d: Report correct number of blend matrices when software vertex processing is used.", 1 },';
printf '%s\n' '+ { "Sebastian Lackner", "wined3d: Track updates of vertex blend matrices separately.", 1 },';
printf '%s\n' '+ { "Paul Gofman", "wined3d: Allow higher world matrix states.", 1 },';
printf '%s\n' '+ { "Paul Gofman", "wined3d: Support indexed vertex blending.", 1 },';
) >> "$patchlist"
fi

15
patches/wined3d-Indexed_Vertex_Blending/0001-d3d9-tests-Add-test-for-indexed-vertex-blending.patch
View File

@ -1,17 +1,18 @@
From b008821675b5e7ad2ed3d4f721d7fbb05c8f8ce4 Mon Sep 17 00:00:00 2001
From 22479b6d05acd8bdd81f6e8ea84425ad55b9b48b Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Thu, 17 Aug 2017 17:46:50 +0300
Subject: d3d9/tests: Add test for indexed vertex blending.
Subject: [PATCH 1/5] d3d9/tests: Add test for indexed vertex blending.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/d3d9/tests/visual.c | 252 +++++++++++++++++++++++++++++++++++++++++++++++
dlls/d3d9/tests/visual.c | 252 +++++++++++++++++++++++++++++++++++++++
1 file changed, 252 insertions(+)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index 3686fc6..9e0c33b 100644
index 67e1133c51..3d7a64b91f 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -20263,6 +20263,257 @@ done:
@@ -20765,6 +20765,257 @@ done:
DestroyWindow(window);
}
@ -269,7 +270,7 @@ index 3686fc6..9e0c33b 100644
static void test_updatetexture(void)
{
BOOL r32f_supported, ati2n_supported, do_visual_test;
@@ -23930,6 +24181,7 @@ START_TEST(visual)
@@ -24872,6 +25123,7 @@ START_TEST(visual)
test_multisample_mismatch();
test_texcoordindex();
test_vertex_blending();
@ -278,5 +279,5 @@ index 3686fc6..9e0c33b 100644
test_depthbias();
test_flip();
--
2.7.4
2.20.1

23
patches/wined3d-Indexed_Vertex_Blending/0003-d3d9-tests-Test-normal-calculation-when-indexed-vert.patch → patches/wined3d-Indexed_Vertex_Blending/0002-d3d9-tests-Test-normal-calculation-when-indexed-vert.patch
View File

@ -1,18 +1,19 @@
From 0a10d9871b0a6fe7bda8cca3b6f2c93ecf359f50 Mon Sep 17 00:00:00 2001
From f3c0bad722ce7f98931cd1ee14ecfae6f3540c0a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20M=C3=BCller?= <michael@fds-team.de>
Date: Thu, 31 Aug 2017 00:23:43 +0200
Subject: d3d9/tests: Test normal calculation when indexed vertex blending is
enabled.
Subject: [PATCH 2/5] d3d9/tests: Test normal calculation when indexed vertex
blending is enabled.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/d3d9/tests/visual.c | 117 ++++++++++++++++++++++++++++++++++++++---------
dlls/d3d9/tests/visual.c | 117 +++++++++++++++++++++++++++++++--------
1 file changed, 95 insertions(+), 22 deletions(-)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index dbf2a22..f9473ba 100644
index 3d7a64b91f..0768a35752 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -20446,47 +20446,68 @@ done:
@@ -20767,47 +20767,68 @@ done:
static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char *test_id_str)
{
@ -85,7 +86,7 @@ index dbf2a22..f9473ba 100644
static const POINT quad_upper_right_points[] =
{
{576, 48}, {-1, -1},
@@ -20527,6 +20548,7 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
@@ -20848,6 +20869,7 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
struct vec3 position;
struct vec3 blendweights;
DWORD matrixIndices;
@ -93,7 +94,7 @@ index dbf2a22..f9473ba 100644
}
vertex_data[4];
const POINT *quad_points;
@@ -20536,34 +20558,34 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
@@ -20857,34 +20879,34 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
{
/* upper right */
{
@ -144,7 +145,7 @@ index dbf2a22..f9473ba 100644
quad_fullscreen_points, quad_fullscreen_empty_points
}
};
@@ -20598,21 +20620,32 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
@@ -20919,21 +20941,32 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
ok(hr == D3D_OK, "(%s) IDirect3DDevice9_SetRenderState D3DRS_INDEXEDVERTEXBLENDENABLE failed %08x.\n",
test_id_str, hr);
@ -179,7 +180,7 @@ index dbf2a22..f9473ba 100644
ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
hr = IDirect3DDevice9_EndScene(device);
@@ -20636,7 +20669,47 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
@@ -20957,7 +20990,47 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
ok(SUCCEEDED(hr), "Failed to present, hr %#x.\n", hr);
@ -228,5 +229,5 @@ index dbf2a22..f9473ba 100644
static void test_indexed_vertex_blending(void)
--
2.7.4
2.20.1

219
patches/wined3d-Indexed_Vertex_Blending/0002-wined3d-Implement-hardware-indexed-vertex-blending-w.patch
View File

@ -1,219 +0,0 @@
From f928a3edbf09ab9e758fec84e77216fab4f3b4e4 Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Sat, 26 Aug 2017 00:59:29 +0200
Subject: [PATCH] wined3d: Implement hardware indexed vertex blending with 9
matrices.
---
dlls/d3d9/tests/visual.c | 2 +-
dlls/wined3d/glsl_shader.c | 31 +++++++++++++++++++++----------
dlls/wined3d/utils.c | 3 +++
dlls/wined3d/vertexdeclaration.c | 9 +++++++++
dlls/wined3d/wined3d_private.h | 18 +++++++++++++++++-
5 files changed, 51 insertions(+), 12 deletions(-)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index b9e97da3..d78dc449 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -20892,7 +20892,7 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
if (caps.MaxVertexBlendMatrixIndex < 7 || caps.MaxVertexBlendMatrices < 4)
{
- todo_wine win_skip("(%s) Too few vertex blend matrices supported: MaxVertexBlendMatrices=%u, MaxVertexBlendMatrixIndex=%u.\n",
+ win_skip("(%s) Too few vertex blend matrices supported: MaxVertexBlendMatrices=%u, MaxVertexBlendMatrixIndex=%u.\n",
test_id_str, caps.MaxVertexBlendMatrices, caps.MaxVertexBlendMatrixIndex);
return;
}
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 660005f5..873e5ff3 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -157,7 +157,7 @@ struct glsl_vs_program
GLint pos_fixup_location;
GLint base_vertex_id_location;
- GLint modelview_matrix_location[MAX_VERTEX_BLENDS];
+ GLint modelview_matrix_location[MAX_VERTEX_INDEX_BLENDS];
GLint projection_matrix_location;
GLint normal_matrix_location;
GLint texture_matrix_location[WINED3D_MAX_TEXTURES];
@@ -1855,7 +1855,7 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
{
struct wined3d_matrix mat;
- for (i = 1; i < MAX_VERTEX_BLENDS; ++i)
+ for (i = 1; i < MAX_VERTEX_INDEX_BLENDS; ++i)
{
if (prog->vs.modelview_matrix_location[i] == -1)
break;
@@ -9127,8 +9127,7 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
{
{"vec4", "ffp_attrib_position"}, /* WINED3D_FFP_POSITION */
{"vec4", "ffp_attrib_blendweight"}, /* WINED3D_FFP_BLENDWEIGHT */
- /* TODO: Indexed vertex blending */
- {"float", ""}, /* WINED3D_FFP_BLENDINDICES */
+ {"vec4", "ffp_attrib_blendindices"}, /* WINED3D_FFP_BLENDINDICES */
{"vec3", "ffp_attrib_normal"}, /* WINED3D_FFP_NORMAL */
{"float", "ffp_attrib_psize"}, /* WINED3D_FFP_PSIZE */
{"vec4", "ffp_attrib_diffuse"}, /* WINED3D_FFP_DIFFUSE */
@@ -9140,6 +9139,7 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
BOOL legacy_lighting = priv->legacy_lighting;
GLuint shader_obj;
unsigned int i;
+ char var[64];
string_buffer_clear(buffer);
@@ -9158,7 +9158,7 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
}
shader_addline(buffer, "\n");
- shader_addline(buffer, "uniform mat4 ffp_modelview_matrix[%u];\n", MAX_VERTEX_BLENDS);
+ shader_addline(buffer, "uniform mat4 ffp_modelview_matrix[%u];\n", MAX_VERTEX_INDEX_BLENDS);
shader_addline(buffer, "uniform mat4 ffp_projection_matrix;\n");
shader_addline(buffer, "uniform mat3 ffp_normal_matrix;\n");
shader_addline(buffer, "uniform mat4 ffp_texture_matrix[%u];\n", WINED3D_MAX_TEXTURES);
@@ -9250,7 +9250,10 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
shader_addline(buffer, "vec4 ec_pos = vec4(0.0);\n");
for (i = 0; i < settings->vertexblends + 1; ++i)
- shader_addline(buffer, "ec_pos += ffp_attrib_blendweight[%u] * (ffp_modelview_matrix[%u] * ffp_attrib_position);\n", i, i);
+ {
+ sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
+ shader_addline(buffer, "ec_pos += ffp_attrib_blendweight[%u] * (ffp_modelview_matrix[%s] * ffp_attrib_position);\n", i, var);
+ }
shader_addline(buffer, "gl_Position = ffp_projection_matrix * ec_pos;\n");
if (settings->clipping)
@@ -9274,7 +9277,10 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
else
{
for (i = 0; i < settings->vertexblends + 1; ++i)
- shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * (mat3(ffp_modelview_matrix[%u]) * ffp_attrib_normal);\n", i, i);
+ {
+ sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
+ shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * (mat3(ffp_modelview_matrix[%s]) * ffp_attrib_normal);\n", i, var);
+ }
}
if (settings->normalize)
@@ -10114,7 +10120,7 @@ static void shader_glsl_init_vs_uniform_locations(const struct wined3d_gl_info *
vs->pos_fixup_location = GL_EXTCALL(glGetUniformLocation(program_id, "pos_fixup"));
vs->base_vertex_id_location = GL_EXTCALL(glGetUniformLocation(program_id, "base_vertex_id"));
- for (i = 0; i < MAX_VERTEX_BLENDS; ++i)
+ for (i = 0; i < MAX_VERTEX_INDEX_BLENDS; ++i)
{
string_buffer_sprintf(name, "ffp_modelview_matrix[%u]", i);
vs->modelview_matrix_location[i] = GL_EXTCALL(glGetUniformLocation(program_id, name->buffer));
@@ -10694,7 +10700,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MODELVIEW
| WINED3D_SHADER_CONST_FFP_PROJ;
- for (i = 1; i < MAX_VERTEX_BLENDS; ++i)
+ for (i = 1; i < MAX_VERTEX_INDEX_BLENDS; ++i)
{
if (entry->vs.modelview_matrix_location[i] != -1)
{
@@ -11663,7 +11669,7 @@ static void glsl_vertex_pipe_vp_get_caps(const struct wined3d_gl_info *gl_info,
caps->ffp_generic_attributes = TRUE;
caps->max_active_lights = WINED3D_MAX_ACTIVE_LIGHTS;
caps->max_vertex_blend_matrices = MAX_VERTEX_BLENDS;
- caps->max_vertex_blend_matrix_index = 0;
+ caps->max_vertex_blend_matrix_index = MAX_VERTEX_INDEX_BLENDS - 1;
caps->vertex_processing_caps = WINED3DVTXPCAPS_TEXGEN
| WINED3DVTXPCAPS_MATERIALSOURCE7
| WINED3DVTXPCAPS_VERTEXFOG
@@ -12051,6 +12057,11 @@ static const struct StateEntryTemplate glsl_vertex_pipe_vp_states[] =
{STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(1)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(1)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
{STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(2)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(2)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
{STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(3)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(3)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(4)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(4)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(5)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(5)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(6)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(6)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(7)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(7)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(8)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(8)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_vertex_pipe_texmatrix}, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_vertex_pipe_texmatrix}, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_vertex_pipe_texmatrix}, WINED3D_GL_EXT_NONE },
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index d77cb1ce..bd70801c 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -6245,6 +6245,9 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_context *context,
break;
}
+ if (use_indexed_vertex_blending(state, si))
+ settings->vb_indices = 1;
+
settings->clipping = state->render_states[WINED3D_RS_CLIPPING]
&& state->render_states[WINED3D_RS_CLIPPLANEENABLE];
settings->normal = !!(si->use_map & (1u << WINED3D_FFP_NORMAL));
diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c
index cd8bb5e4..d37f3ce8 100644
--- a/dlls/wined3d/vertexdeclaration.c
+++ b/dlls/wined3d/vertexdeclaration.c
@@ -119,6 +119,15 @@ static BOOL declaration_element_valid_ffp(const struct wined3d_vertex_element *e
return FALSE;
}
+ case WINED3D_DECL_USAGE_BLEND_INDICES:
+ switch(element->format)
+ {
+ case WINED3DFMT_R8G8B8A8_UINT:
+ return TRUE;
+ default:
+ return FALSE;
+ }
+
case WINED3D_DECL_USAGE_NORMAL:
switch(element->format)
{
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 01c1af6d..e0a07023 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -272,6 +272,7 @@ static inline enum complex_fixup get_complex_fixup(struct color_fixup_desc fixup
#define MAX_UNORDERED_ACCESS_VIEWS 8
#define MAX_TGSM_REGISTERS 8192
#define MAX_VERTEX_BLENDS 4
+#define MAX_VERTEX_INDEX_BLENDS 9
#define MAX_RENDER_TARGETS 8
struct min_lookup
@@ -2827,7 +2828,8 @@ struct wined3d_ffp_vs_settings
DWORD ortho_fog : 1;
DWORD flatshading : 1;
DWORD swizzle_map : 16; /* MAX_ATTRIBS, 16 */
- DWORD padding : 2;
+ DWORD vb_indices : 1;
+ DWORD padding : 1;
DWORD texgen[WINED3D_MAX_TEXTURES];
};
@@ -4569,6 +4571,20 @@ static inline BOOL wined3d_format_is_typeless(const struct wined3d_format *forma
return format->id == format->typeless_id && format->id != WINED3DFMT_UNKNOWN;
}
+static inline BOOL use_indexed_vertex_blending(const struct wined3d_state *state, const struct wined3d_stream_info *si)
+{
+ if (!state->render_states[WINED3D_RS_INDEXEDVERTEXBLENDENABLE])
+ return FALSE;
+
+ if (state->render_states[WINED3D_RS_VERTEXBLEND] == WINED3D_VBF_DISABLE)
+ return FALSE;
+
+ if (!(si->use_map & (1 << WINED3D_FFP_BLENDINDICES)) || !(si->use_map & (1 << WINED3D_FFP_BLENDWEIGHT)))
+ return FALSE;
+
+ return TRUE;
+}
+
static inline BOOL use_vs(const struct wined3d_state *state)
{
/* Check state->vertex_declaration to allow this to be used before the
--
2.20.1

15
patches/wined3d-Indexed_Vertex_Blending/0007-d3d9-tests-Check-MaxVertexBlendMatrixIndex-capabilit.patch → patches/wined3d-Indexed_Vertex_Blending/0003-d3d9-tests-Check-MaxVertexBlendMatrixIndex-capabilit.patch
View File

@ -1,17 +1,18 @@
From 92cf51ff4ea2c2fa41d1996062a357b4b4017268 Mon Sep 17 00:00:00 2001
From 8bb56418a2b9ffffe8bd8592a43306a6bad6d740 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20M=C3=BCller?= <michael@fds-team.de>
Date: Thu, 31 Aug 2017 01:47:49 +0200
Subject: d3d9/tests: Check MaxVertexBlendMatrixIndex capability.
Subject: [PATCH 3/5] d3d9/tests: Check MaxVertexBlendMatrixIndex capability.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/d3d9/tests/visual.c | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index 1fe62fa..11b933f 100644
index 0768a35752..c2737c3605 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -20535,7 +20535,9 @@ static void test_indexed_vertex_blending(void)
@@ -21039,7 +21039,9 @@ static void test_indexed_vertex_blending(void)
IDirect3DDevice9 *device;
IDirect3D9 *d3d;
ULONG refcount;
@ -21,7 +22,7 @@ index 1fe62fa..11b933f 100644
window = CreateWindowA("static", "d3d9_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
0, 0, 640, 480, NULL, NULL, NULL, NULL);
@@ -20564,7 +20566,14 @@ static void test_indexed_vertex_blending(void)
@@ -21068,7 +21070,14 @@ static void test_indexed_vertex_blending(void)
if (SUCCEEDED(IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device)))
{
@ -36,7 +37,7 @@ index 1fe62fa..11b933f 100644
refcount = IDirect3DDevice9_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
}
@@ -20574,7 +20583,26 @@ static void test_indexed_vertex_blending(void)
@@ -21078,7 +21087,26 @@ static void test_indexed_vertex_blending(void)
if (SUCCEEDED(IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
D3DCREATE_MIXED_VERTEXPROCESSING, &present_parameters, &device)))
{
@ -64,5 +65,5 @@ index 1fe62fa..11b933f 100644
ok(!refcount, "Device has %u references left.\n", refcount);
}
--
2.7.4
2.20.1

383
patches/wined3d-Indexed_Vertex_Blending/0004-wined3d-Allow-higher-world-matrix-states.patch Normal file
View File

@ -0,0 +1,383 @@
From 38a3612bf075bcb4989a10ab75d6bfc7c31f6d94 Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Mon, 25 Feb 2019 20:15:07 +0300
Subject: [PATCH 4/5] wined3d: Allow higher world matrix states.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/wined3d/adapter_gl.c | 1 +
dlls/wined3d/cs.c | 3 +-
dlls/wined3d/device.c | 5 +
dlls/wined3d/directx.c | 2 +
dlls/wined3d/glsl_shader.c | 252 +++++++++++++++++++++++++++++++++
dlls/wined3d/state.c | 3 +-
dlls/wined3d/utils.c | 8 +-
dlls/wined3d/wined3d_private.h | 1 +
8 files changed, 268 insertions(+), 7 deletions(-)
diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c
index 1b386a7b8e..b50b50b74c 100644
--- a/dlls/wined3d/adapter_gl.c
+++ b/dlls/wined3d/adapter_gl.c
@@ -3744,6 +3744,7 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter,
d3d_info->ffp_generic_attributes = vertex_caps.ffp_generic_attributes;
d3d_info->limits.ffp_vertex_blend_matrices = vertex_caps.max_vertex_blend_matrices;
d3d_info->limits.active_light_count = vertex_caps.max_active_lights;
+ d3d_info->limits.ffp_max_vertex_blend_matrix_index = vertex_caps.max_vertex_blend_matrix_index;
d3d_info->emulated_flatshading = vertex_caps.emulated_flatshading;
adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c
index b5ad1f8875..2dc509749a 100644
--- a/dlls/wined3d/cs.c
+++ b/dlls/wined3d/cs.c
@@ -1672,7 +1672,8 @@ static void wined3d_cs_exec_set_transform(struct wined3d_cs *cs, const void *dat
const struct wined3d_cs_set_transform *op = data;
cs->state.transforms[op->state] = op->matrix;
- if (op->state < WINED3D_TS_WORLD_MATRIX(cs->device->adapter->d3d_info.limits.ffp_vertex_blend_matrices))
+ if (op->state < WINED3D_TS_WORLD_MATRIX(max(cs->device->adapter->d3d_info.limits.ffp_vertex_blend_matrices,
+ cs->device->adapter->d3d_info.limits.ffp_max_vertex_blend_matrix_index + 1)))
device_invalidate_state(cs->device, STATE_TRANSFORM(op->state));
}
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 307993286c..b1df64bed7 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -3644,6 +3644,11 @@ HRESULT CDECL wined3d_device_get_device_caps(const struct wined3d_device *device
adapter->vertex_pipe->vp_get_caps(&adapter->gl_info, &vertex_caps);
if (device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING)
caps->MaxVertexShaderConst = adapter->d3d_info.limits.vs_uniform_count_swvp;
+ caps->MaxVertexBlendMatrixIndex = vertex_caps.max_vertex_blend_matrix_index;
+ if (!((device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING)
+ || ((device->create_parms.flags & WINED3DCREATE_MIXED_VERTEXPROCESSING)
+ && device->softwareVertexProcessing)))
+ caps->MaxVertexBlendMatrixIndex = min(caps->MaxVertexBlendMatrixIndex, 8);
return hr;
}
diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index 0c70f046eb..511c2da808 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -2250,6 +2250,8 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapte
caps->MaxActiveLights = vertex_caps.max_active_lights;
caps->MaxVertexBlendMatrices = vertex_caps.max_vertex_blend_matrices;
caps->MaxVertexBlendMatrixIndex = vertex_caps.max_vertex_blend_matrix_index;
+ if (caps->DeviceType == WINED3D_DEVICE_TYPE_HAL)
+ caps->MaxVertexBlendMatrixIndex = min(caps->MaxVertexBlendMatrixIndex, 8);
caps->VertexProcessingCaps = vertex_caps.vertex_processing_caps;
caps->FVFCaps = vertex_caps.fvf_caps;
caps->RasterCaps |= vertex_caps.raster_caps;
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index b7ccfc633e..1dcb0ef7c2 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -12192,6 +12192,258 @@ static const struct StateEntryTemplate glsl_vertex_pipe_vp_states[] =
{STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(1)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(1)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
{STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(2)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(2)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
{STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(3)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(3)), glsl_vertex_pipe_vertexblend }, WINED3D_GL_EXT_NONE },
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(4)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(4)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(5)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(5)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(6)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(6)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(7)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(7)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(8)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(8)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(9)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(9)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(10)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(10)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(11)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(11)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(12)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(12)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(13)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(13)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(14)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(14)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(15)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(15)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(16)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(16)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(17)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(17)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(18)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(18)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(19)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(19)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(20)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(20)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(21)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(21)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(22)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(22)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(23)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(23)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(24)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(24)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(25)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(25)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(26)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(26)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(27)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(27)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(28)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(28)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(29)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(29)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(30)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(30)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(31)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(31)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(32)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(32)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(33)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(33)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(34)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(34)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(35)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(35)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(36)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(36)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(37)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(37)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(38)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(38)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(39)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(39)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(40)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(40)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(41)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(41)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(42)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(42)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(43)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(43)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(44)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(44)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(45)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(45)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(46)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(46)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(47)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(47)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(48)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(48)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(49)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(49)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(50)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(50)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(51)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(51)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(52)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(52)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(53)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(53)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(54)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(54)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(55)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(55)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(56)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(56)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(57)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(57)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(58)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(58)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(59)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(59)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(60)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(60)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(61)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(61)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(62)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(62)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(63)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(63)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(64)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(64)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(65)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(65)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(66)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(66)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(67)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(67)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(68)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(68)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(69)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(69)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(70)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(70)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(71)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(71)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(72)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(72)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(73)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(73)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(74)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(74)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(75)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(75)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(76)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(76)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(77)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(77)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(78)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(78)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(79)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(79)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(80)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(80)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(81)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(81)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(82)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(82)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(83)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(83)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(84)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(84)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(85)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(85)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(86)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(86)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(87)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(87)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(88)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(88)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(89)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(89)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(90)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(90)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(91)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(91)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(92)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(92)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(93)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(93)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(94)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(94)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(95)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(95)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(96)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(96)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(97)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(97)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(98)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(98)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(99)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(99)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
+ {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), {STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), glsl_vertex_pipe_vertexblend }, ARB_UNIFORM_BUFFER_OBJECT},
{STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_vertex_pipe_texmatrix}, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_vertex_pipe_texmatrix}, WINED3D_GL_EXT_NONE },
{STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), glsl_vertex_pipe_texmatrix}, WINED3D_GL_EXT_NONE },
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 25205c9aca..d68933802d 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -5412,7 +5412,8 @@ static void prune_invalid_states(struct StateEntry *state_table, const struct wi
state_table[i].apply = state_undefined;
}
- start = STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(d3d_info->limits.ffp_vertex_blend_matrices));
+ start = STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(max(d3d_info->limits.ffp_vertex_blend_matrices,
+ d3d_info->limits.ffp_max_vertex_blend_matrix_index + 1)));
last = STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255));
for (i = start; i <= last; ++i)
{
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 104e276585..3785ae104b 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -4933,11 +4933,9 @@ const char *debug_d3dtstype(enum wined3d_transform_state tstype)
TSTYPE_TO_STR(WINED3D_TS_WORLD_MATRIX(3));
#undef TSTYPE_TO_STR
default:
- if (tstype > 256 && tstype < 512)
- {
- FIXME("WINED3D_TS_WORLD_MATRIX(%u). 1..255 not currently supported.\n", tstype);
- return ("WINED3D_TS_WORLD_MATRIX > 0");
- }
+ if (tstype > WINED3D_TS_WORLD_MATRIX(3) && tstype < WINED3D_TS_WORLD_MATRIX(256))
+ return ("WINED3D_TS_WORLD_MATRIX > 3");
+
FIXME("Unrecognized transform state %#x.\n", tstype);
return "unrecognized";
}
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 7014e6760d..134a376707 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -170,6 +170,7 @@ struct wined3d_d3d_limits
unsigned int ffp_blend_stages;
unsigned int ffp_vertex_blend_matrices;
unsigned int active_light_count;
+ unsigned int ffp_max_vertex_blend_matrix_index;
unsigned int max_rt_count;
unsigned int max_clip_distances;
--
2.20.1

173
patches/wined3d-Indexed_Vertex_Blending/0004-wined3d-Fix-calculation-of-normal-when-vertex-blendi.patch
View File

@ -1,173 +0,0 @@
From b3c3b13e6910b831de236987c4ac7f2b03cd2bc5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20M=C3=BCller?= <michael@fds-team.de>
Date: Thu, 31 Aug 2017 01:00:04 +0200
Subject: wined3d: Fix calculation of normal when vertex blending is enabled.
---
dlls/d3d9/tests/visual.c | 2 +-
dlls/wined3d/glsl_shader.c | 76 ++++++++++++++++++--------------------
2 files changed, 36 insertions(+), 42 deletions(-)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index 7c3b5de4..4edd6c57 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -21012,7 +21012,7 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
while (point->x != -1 && point->y != -1)
{
color = getPixelColor(device, point->x, point->y);
- todo_wine ok(color_match(color, 0x0000007f, 1), "(%s) Expected color 0x0000007f at %dx%d, got 0x%08x.\n", test_id_str, point->x, point->y, color);
+ ok(color_match(color, 0x0000007f, 1), "(%s) Expected color 0x0000007f at %dx%d, got 0x%08x.\n", test_id_str, point->x, point->y, color);
++point;
}
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 873e5ff3..5e3732a0 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -158,8 +158,8 @@ struct glsl_vs_program
GLint base_vertex_id_location;
GLint modelview_matrix_location[MAX_VERTEX_INDEX_BLENDS];
+ GLint normal_matrix_location[MAX_VERTEX_INDEX_BLENDS];
GLint projection_matrix_location;
- GLint normal_matrix_location;
GLint texture_matrix_location[WINED3D_MAX_TEXTURES];
GLint material_ambient_location;
GLint material_diffuse_location;
@@ -1553,33 +1553,6 @@ static void transpose_matrix(struct wined3d_matrix *out, const struct wined3d_ma
*out = temp;
}
-static void shader_glsl_ffp_vertex_normalmatrix_uniform(const struct wined3d_context *context,
- const struct wined3d_state *state, struct glsl_shader_prog_link *prog)
-{
- const struct wined3d_gl_info *gl_info = context->gl_info;
- float mat[3 * 3];
- struct wined3d_matrix mv;
- unsigned int i, j;
-
- if (prog->vs.normal_matrix_location == -1)
- return;
-
- get_modelview_matrix(context, state, 0, &mv);
- if (context->d3d_info->wined3d_creation_flags & WINED3D_LEGACY_FFP_LIGHTING)
- invert_matrix_3d(&mv, &mv);
- else
- invert_matrix(&mv, &mv);
- /* Tests show that singular modelview matrices are used unchanged as normal
- * matrices on D3D3 and older. There seems to be no clearly consistent
- * behavior on newer D3D versions so always follow older ddraw behavior. */
- for (i = 0; i < 3; ++i)
- for (j = 0; j < 3; ++j)
- mat[i * 3 + j] = (&mv._11)[j * 4 + i];
-
- GL_EXTCALL(glUniformMatrix3fv(prog->vs.normal_matrix_location, 1, FALSE, mat));
- checkGLcall("glUniformMatrix3fv");
-}
-
static void shader_glsl_ffp_vertex_texmatrix_uniform(const struct wined3d_context *context,
const struct wined3d_state *state, unsigned int tex, struct glsl_shader_prog_link *prog)
{
@@ -1777,6 +1750,23 @@ static void shader_glsl_load_color_key_constant(const struct glsl_ps_program *ps
GL_EXTCALL(glUniform4fv(ps->color_key_location, 2, &float_key[0].r));
}
+/* Context activation is done by the caller. */
+static void get_normal_matrix(struct wined3d_context *context, struct wined3d_matrix *mat, float *normal)
+{
+ int i, j;
+
+ if (context->d3d_info->wined3d_creation_flags & WINED3D_LEGACY_FFP_LIGHTING)
+ invert_matrix_3d(mat, mat);
+ else
+ invert_matrix(mat, mat);
+ /* Tests show that singular modelview matrices are used unchanged as normal
+ * matrices on D3D3 and older. There seems to be no clearly consistent
+ * behavior on newer D3D versions so always follow older ddraw behavior. */
+ for (i = 0; i < 3; ++i)
+ for (j = 0; j < 3; ++j)
+ normal[i * 3 + j] = (&mat->_11)[j * 4 + i];
+}
+
/* Context activation is done by the caller (state handler). */
static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context *context,
const struct wined3d_state *state)
@@ -1789,6 +1779,7 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
float position_fixup[4 * WINED3D_MAX_VIEWPORTS];
struct shader_glsl_priv *priv = shader_priv;
unsigned int constant_version;
+ float normal[3 * 3];
DWORD update_mask;
int i;
@@ -1848,7 +1839,9 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
GL_EXTCALL(glUniformMatrix4fv(prog->vs.modelview_matrix_location[0], 1, FALSE, &mat._11));
checkGLcall("glUniformMatrix4fv");
- shader_glsl_ffp_vertex_normalmatrix_uniform(context, state, prog);
+ get_normal_matrix(context, &mat, normal);
+ GL_EXTCALL(glUniformMatrix3fv(prog->vs.normal_matrix_location[0], 1, FALSE, normal));
+ checkGLcall("glUniformMatrix3fv");
}
if (update_mask & WINED3D_SHADER_CONST_FFP_VERTEXBLEND)
@@ -1863,6 +1856,10 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
get_modelview_matrix(context, state, i, &mat);
GL_EXTCALL(glUniformMatrix4fv(prog->vs.modelview_matrix_location[i], 1, FALSE, &mat._11));
checkGLcall("glUniformMatrix4fv");
+
+ get_normal_matrix(context, &mat, normal);
+ GL_EXTCALL(glUniformMatrix3fv(prog->vs.normal_matrix_location[i], 1, FALSE, normal));
+ checkGLcall("glUniformMatrix3fv");
}
}
@@ -9159,8 +9156,8 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
shader_addline(buffer, "\n");
shader_addline(buffer, "uniform mat4 ffp_modelview_matrix[%u];\n", MAX_VERTEX_INDEX_BLENDS);
+ shader_addline(buffer, "uniform mat3 ffp_normal_matrix[%u];\n", MAX_VERTEX_INDEX_BLENDS);
shader_addline(buffer, "uniform mat4 ffp_projection_matrix;\n");
- shader_addline(buffer, "uniform mat3 ffp_normal_matrix;\n");
shader_addline(buffer, "uniform mat4 ffp_texture_matrix[%u];\n", WINED3D_MAX_TEXTURES);
shader_addline(buffer, "uniform struct\n{\n");
@@ -9270,17 +9267,10 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
shader_addline(buffer, "vec3 normal = vec3(0.0);\n");
if (settings->normal)
{
- if (!settings->vertexblends)
+ for (i = 0; i < settings->vertexblends + 1; ++i)
{
- shader_addline(buffer, "normal = ffp_normal_matrix * ffp_attrib_normal;\n");
- }
- else
- {
- for (i = 0; i < settings->vertexblends + 1; ++i)
- {
- sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
- shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * (mat3(ffp_modelview_matrix[%s]) * ffp_attrib_normal);\n", i, var);
- }
+ sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
+ shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * (ffp_normal_matrix[%s] * ffp_attrib_normal);\n", i, var);
}
if (settings->normalize)
@@ -10125,8 +10115,12 @@ static void shader_glsl_init_vs_uniform_locations(const struct wined3d_gl_info *
string_buffer_sprintf(name, "ffp_modelview_matrix[%u]", i);
vs->modelview_matrix_location[i] = GL_EXTCALL(glGetUniformLocation(program_id, name->buffer));
}
+ for (i = 0; i < MAX_VERTEX_INDEX_BLENDS; ++i)
+ {
+ string_buffer_sprintf(name, "ffp_normal_matrix[%u]", i);
+ vs->normal_matrix_location[i] = GL_EXTCALL(glGetUniformLocation(program_id, name->buffer));
+ }
vs->projection_matrix_location = GL_EXTCALL(glGetUniformLocation(program_id, "ffp_projection_matrix"));
- vs->normal_matrix_location = GL_EXTCALL(glGetUniformLocation(program_id, "ffp_normal_matrix"));
for (i = 0; i < WINED3D_MAX_TEXTURES; ++i)
{
string_buffer_sprintf(name, "ffp_texture_matrix[%u]", i);
--
2.20.1

624
patches/wined3d-Indexed_Vertex_Blending/0005-wined3d-Move-matrix-inversion-functions-into-utils.c.patch
View File

@ -1,624 +0,0 @@
From f8d05e2411769d61a7120f426b51e48a4a4a945c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20M=C3=BCller?= <michael@fds-team.de>
Date: Thu, 31 Aug 2017 01:07:25 +0200
Subject: wined3d: Move matrix inversion functions into utils.c
---
dlls/wined3d/glsl_shader.c | 287 -----------------------------------------
dlls/wined3d/utils.c | 287 +++++++++++++++++++++++++++++++++++++++++
dlls/wined3d/wined3d_private.h | 3 +
3 files changed, 290 insertions(+), 287 deletions(-)
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 302c64b..cfe316b 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -1260,293 +1260,6 @@ static void shader_glsl_load_np2fixup_constants(const struct glsl_ps_program *ps
GL_EXTCALL(glUniform4fv(ps->np2_fixup_location, ps->np2_fixup_info->num_consts, &np2fixup_constants[0].sx));
}
-/* Taken and adapted from Mesa. */
-static BOOL invert_matrix_3d(struct wined3d_matrix *out, const struct wined3d_matrix *in)
-{
- float pos, neg, t, det;
- struct wined3d_matrix temp;
-
- /* Calculate the determinant of upper left 3x3 submatrix and
- * determine if the matrix is singular. */
- pos = neg = 0.0f;
- t = in->_11 * in->_22 * in->_33;
- if (t >= 0.0f)
- pos += t;
- else
- neg += t;
-
- t = in->_21 * in->_32 * in->_13;
- if (t >= 0.0f)
- pos += t;
- else
- neg += t;
- t = in->_31 * in->_12 * in->_23;
- if (t >= 0.0f)
- pos += t;
- else
- neg += t;
-
- t = -in->_31 * in->_22 * in->_13;
- if (t >= 0.0f)
- pos += t;
- else
- neg += t;
- t = -in->_21 * in->_12 * in->_33;
- if (t >= 0.0f)
- pos += t;
- else
- neg += t;
-
- t = -in->_11 * in->_32 * in->_23;
- if (t >= 0.0f)
- pos += t;
- else
- neg += t;
-
- det = pos + neg;
-
- if (fabsf(det) < 1e-25f)
- return FALSE;
-
- det = 1.0f / det;
- temp._11 = (in->_22 * in->_33 - in->_32 * in->_23) * det;
- temp._12 = -(in->_12 * in->_33 - in->_32 * in->_13) * det;
- temp._13 = (in->_12 * in->_23 - in->_22 * in->_13) * det;
- temp._21 = -(in->_21 * in->_33 - in->_31 * in->_23) * det;
- temp._22 = (in->_11 * in->_33 - in->_31 * in->_13) * det;
- temp._23 = -(in->_11 * in->_23 - in->_21 * in->_13) * det;
- temp._31 = (in->_21 * in->_32 - in->_31 * in->_22) * det;
- temp._32 = -(in->_11 * in->_32 - in->_31 * in->_12) * det;
- temp._33 = (in->_11 * in->_22 - in->_21 * in->_12) * det;
-
- *out = temp;
- return TRUE;
-}
-
-static void swap_rows(float **a, float **b)
-{
- float *tmp = *a;
-
- *a = *b;
- *b = tmp;
-}
-
-static BOOL invert_matrix(struct wined3d_matrix *out, const struct wined3d_matrix *m)
-{
- float wtmp[4][8];
- float m0, m1, m2, m3, s;
- float *r0, *r1, *r2, *r3;
-
- r0 = wtmp[0];
- r1 = wtmp[1];
- r2 = wtmp[2];
- r3 = wtmp[3];
-
- r0[0] = m->_11;
- r0[1] = m->_12;
- r0[2] = m->_13;
- r0[3] = m->_14;
- r0[4] = 1.0f;
- r0[5] = r0[6] = r0[7] = 0.0f;
-
- r1[0] = m->_21;
- r1[1] = m->_22;
- r1[2] = m->_23;
- r1[3] = m->_24;
- r1[5] = 1.0f;
- r1[4] = r1[6] = r1[7] = 0.0f;
-
- r2[0] = m->_31;
- r2[1] = m->_32;
- r2[2] = m->_33;
- r2[3] = m->_34;
- r2[6] = 1.0f;
- r2[4] = r2[5] = r2[7] = 0.0f;
-
- r3[0] = m->_41;
- r3[1] = m->_42;
- r3[2] = m->_43;
- r3[3] = m->_44;
- r3[7] = 1.0f;
- r3[4] = r3[5] = r3[6] = 0.0f;
-
- /* Choose pivot - or die. */
- if (fabsf(r3[0]) > fabsf(r2[0]))
- swap_rows(&r3, &r2);
- if (fabsf(r2[0]) > fabsf(r1[0]))
- swap_rows(&r2, &r1);
- if (fabsf(r1[0]) > fabsf(r0[0]))
- swap_rows(&r1, &r0);
- if (r0[0] == 0.0f)
- return FALSE;
-
- /* Eliminate first variable. */
- m1 = r1[0] / r0[0]; m2 = r2[0] / r0[0]; m3 = r3[0] / r0[0];
- s = r0[1]; r1[1] -= m1 * s; r2[1] -= m2 * s; r3[1] -= m3 * s;
- s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
- s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
- s = r0[4];
- if (s != 0.0f)
- {
- r1[4] -= m1 * s;
- r2[4] -= m2 * s;
- r3[4] -= m3 * s;
- }
- s = r0[5];
- if (s != 0.0f)
- {
- r1[5] -= m1 * s;
- r2[5] -= m2 * s;
- r3[5] -= m3 * s;
- }
- s = r0[6];
- if (s != 0.0f)
- {
- r1[6] -= m1 * s;
- r2[6] -= m2 * s;
- r3[6] -= m3 * s;
- }
- s = r0[7];
- if (s != 0.0f)
- {
- r1[7] -= m1 * s;
- r2[7] -= m2 * s;
- r3[7] -= m3 * s;
- }
-
- /* Choose pivot - or die. */
- if (fabsf(r3[1]) > fabsf(r2[1]))
- swap_rows(&r3, &r2);
- if (fabsf(r2[1]) > fabsf(r1[1]))
- swap_rows(&r2, &r1);
- if (r1[1] == 0.0f)
- return FALSE;
-
- /* Eliminate second variable. */
- m2 = r2[1] / r1[1]; m3 = r3[1] / r1[1];
- r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
- r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
- s = r1[4];
- if (s != 0.0f)
- {
- r2[4] -= m2 * s;
- r3[4] -= m3 * s;
- }
- s = r1[5];
- if (s != 0.0f)
- {
- r2[5] -= m2 * s;
- r3[5] -= m3 * s;
- }
- s = r1[6];
- if (s != 0.0f)
- {
- r2[6] -= m2 * s;
- r3[6] -= m3 * s;
- }
- s = r1[7];
- if (s != 0.0f)
- {
- r2[7] -= m2 * s;
- r3[7] -= m3 * s;
- }
-
- /* Choose pivot - or die. */
- if (fabsf(r3[2]) > fabsf(r2[2]))
- swap_rows(&r3, &r2);
- if (r2[2] == 0.0f)
- return FALSE;
-
- /* Eliminate third variable. */
- m3 = r3[2] / r2[2];
- r3[3] -= m3 * r2[3];
- r3[4] -= m3 * r2[4];
- r3[5] -= m3 * r2[5];
- r3[6] -= m3 * r2[6];
- r3[7] -= m3 * r2[7];
-
- /* Last check. */
- if (r3[3] == 0.0f)
- return FALSE;
-
- /* Back substitute row 3. */
- s = 1.0f / r3[3];
- r3[4] *= s;
- r3[5] *= s;
- r3[6] *= s;
- r3[7] *= s;
-
- /* Back substitute row 2. */
- m2 = r2[3];
- s = 1.0f / r2[2];
- r2[4] = s * (r2[4] - r3[4] * m2);
- r2[5] = s * (r2[5] - r3[5] * m2);
- r2[6] = s * (r2[6] - r3[6] * m2);
- r2[7] = s * (r2[7] - r3[7] * m2);
- m1 = r1[3];
- r1[4] -= r3[4] * m1;
- r1[5] -= r3[5] * m1;
- r1[6] -= r3[6] * m1;
- r1[7] -= r3[7] * m1;
- m0 = r0[3];
- r0[4] -= r3[4] * m0;
- r0[5] -= r3[5] * m0;
- r0[6] -= r3[6] * m0;
- r0[7] -= r3[7] * m0;
-
- /* Back substitute row 1. */
- m1 = r1[2];
- s = 1.0f / r1[1];
- r1[4] = s * (r1[4] - r2[4] * m1);
- r1[5] = s * (r1[5] - r2[5] * m1);
- r1[6] = s * (r1[6] - r2[6] * m1);
- r1[7] = s * (r1[7] - r2[7] * m1);
- m0 = r0[2];
- r0[4] -= r2[4] * m0;
- r0[5] -= r2[5] * m0;
- r0[6] -= r2[6] * m0;
- r0[7] -= r2[7] * m0;
-
- /* Back substitute row 0. */
- m0 = r0[1];
- s = 1.0f / r0[0];
- r0[4] = s * (r0[4] - r1[4] * m0);
- r0[5] = s * (r0[5] - r1[5] * m0);
- r0[6] = s * (r0[6] - r1[6] * m0);
- r0[7] = s * (r0[7] - r1[7] * m0);
-
- out->_11 = r0[4];
- out->_12 = r0[5];
- out->_13 = r0[6];
- out->_14 = r0[7];
- out->_21 = r1[4];
- out->_22 = r1[5];
- out->_23 = r1[6];
- out->_24 = r1[7];
- out->_31 = r2[4];
- out->_32 = r2[5];
- out->_33 = r2[6];
- out->_34 = r2[7];
- out->_41 = r3[4];
- out->_42 = r3[5];
- out->_43 = r3[6];
- out->_44 = r3[7];
-
- return TRUE;
-}
-
-static void transpose_matrix(struct wined3d_matrix *out, const struct wined3d_matrix *m)
-{
- struct wined3d_matrix temp;
- unsigned int i, j;
-
- for (i = 0; i < 4; ++i)
- for (j = 0; j < 4; ++j)
- (&temp._11)[4 * j + i] = (&m->_11)[4 * i + j];
-
- *out = temp;
-}
-
static void shader_glsl_ffp_vertex_texmatrix_uniform(const struct wined3d_context *context,
const struct wined3d_state *state, unsigned int tex, struct glsl_shader_prog_link *prog)
{
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 95fcd81..3a8f567 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -5568,6 +5568,293 @@ void multiply_matrix(struct wined3d_matrix *dst, const struct wined3d_matrix *sr
*dst = tmp;
}
+/* Taken and adapted from Mesa. */
+BOOL invert_matrix_3d(struct wined3d_matrix *out, const struct wined3d_matrix *in)
+{
+ float pos, neg, t, det;
+ struct wined3d_matrix temp;
+
+ /* Calculate the determinant of upper left 3x3 submatrix and
+ * determine if the matrix is singular. */
+ pos = neg = 0.0f;
+ t = in->_11 * in->_22 * in->_33;
+ if (t >= 0.0f)
+ pos += t;
+ else
+ neg += t;
+
+ t = in->_21 * in->_32 * in->_13;
+ if (t >= 0.0f)
+ pos += t;
+ else
+ neg += t;
+ t = in->_31 * in->_12 * in->_23;
+ if (t >= 0.0f)
+ pos += t;
+ else
+ neg += t;
+
+ t = -in->_31 * in->_22 * in->_13;
+ if (t >= 0.0f)
+ pos += t;
+ else
+ neg += t;
+ t = -in->_21 * in->_12 * in->_33;
+ if (t >= 0.0f)
+ pos += t;
+ else
+ neg += t;
+
+ t = -in->_11 * in->_32 * in->_23;
+ if (t >= 0.0f)
+ pos += t;
+ else
+ neg += t;
+
+ det = pos + neg;
+
+ if (fabsf(det) < 1e-25f)
+ return FALSE;
+
+ det = 1.0f / det;
+ temp._11 = (in->_22 * in->_33 - in->_32 * in->_23) * det;
+ temp._12 = -(in->_12 * in->_33 - in->_32 * in->_13) * det;
+ temp._13 = (in->_12 * in->_23 - in->_22 * in->_13) * det;
+ temp._21 = -(in->_21 * in->_33 - in->_31 * in->_23) * det;
+ temp._22 = (in->_11 * in->_33 - in->_31 * in->_13) * det;
+ temp._23 = -(in->_11 * in->_23 - in->_21 * in->_13) * det;
+ temp._31 = (in->_21 * in->_32 - in->_31 * in->_22) * det;
+ temp._32 = -(in->_11 * in->_32 - in->_31 * in->_12) * det;
+ temp._33 = (in->_11 * in->_22 - in->_21 * in->_12) * det;
+
+ *out = temp;
+ return TRUE;
+}
+
+static void swap_rows(float **a, float **b)
+{
+ float *tmp = *a;
+
+ *a = *b;
+ *b = tmp;
+}
+
+BOOL invert_matrix(struct wined3d_matrix *out, const struct wined3d_matrix *m)
+{
+ float wtmp[4][8];
+ float m0, m1, m2, m3, s;
+ float *r0, *r1, *r2, *r3;
+
+ r0 = wtmp[0];
+ r1 = wtmp[1];
+ r2 = wtmp[2];
+ r3 = wtmp[3];
+
+ r0[0] = m->_11;
+ r0[1] = m->_12;
+ r0[2] = m->_13;
+ r0[3] = m->_14;
+ r0[4] = 1.0f;
+ r0[5] = r0[6] = r0[7] = 0.0f;
+
+ r1[0] = m->_21;
+ r1[1] = m->_22;
+ r1[2] = m->_23;
+ r1[3] = m->_24;
+ r1[5] = 1.0f;
+ r1[4] = r1[6] = r1[7] = 0.0f;
+
+ r2[0] = m->_31;
+ r2[1] = m->_32;
+ r2[2] = m->_33;
+ r2[3] = m->_34;
+ r2[6] = 1.0f;
+ r2[4] = r2[5] = r2[7] = 0.0f;
+
+ r3[0] = m->_41;
+ r3[1] = m->_42;
+ r3[2] = m->_43;
+ r3[3] = m->_44;
+ r3[7] = 1.0f;
+ r3[4] = r3[5] = r3[6] = 0.0f;
+
+ /* Choose pivot - or die. */
+ if (fabsf(r3[0]) > fabsf(r2[0]))
+ swap_rows(&r3, &r2);
+ if (fabsf(r2[0]) > fabsf(r1[0]))
+ swap_rows(&r2, &r1);
+ if (fabsf(r1[0]) > fabsf(r0[0]))
+ swap_rows(&r1, &r0);
+ if (r0[0] == 0.0f)
+ return FALSE;
+
+ /* Eliminate first variable. */
+ m1 = r1[0] / r0[0]; m2 = r2[0] / r0[0]; m3 = r3[0] / r0[0];
+ s = r0[1]; r1[1] -= m1 * s; r2[1] -= m2 * s; r3[1] -= m3 * s;
+ s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
+ s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
+ s = r0[4];
+ if (s != 0.0f)
+ {
+ r1[4] -= m1 * s;
+ r2[4] -= m2 * s;
+ r3[4] -= m3 * s;
+ }
+ s = r0[5];
+ if (s != 0.0f)
+ {
+ r1[5] -= m1 * s;
+ r2[5] -= m2 * s;
+ r3[5] -= m3 * s;
+ }
+ s = r0[6];
+ if (s != 0.0f)
+ {
+ r1[6] -= m1 * s;
+ r2[6] -= m2 * s;
+ r3[6] -= m3 * s;
+ }
+ s = r0[7];
+ if (s != 0.0f)
+ {
+ r1[7] -= m1 * s;
+ r2[7] -= m2 * s;
+ r3[7] -= m3 * s;
+ }
+
+ /* Choose pivot - or die. */
+ if (fabsf(r3[1]) > fabsf(r2[1]))
+ swap_rows(&r3, &r2);
+ if (fabsf(r2[1]) > fabsf(r1[1]))
+ swap_rows(&r2, &r1);
+ if (r1[1] == 0.0f)
+ return FALSE;
+
+ /* Eliminate second variable. */
+ m2 = r2[1] / r1[1]; m3 = r3[1] / r1[1];
+ r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
+ r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
+ s = r1[4];
+ if (s != 0.0f)
+ {
+ r2[4] -= m2 * s;
+ r3[4] -= m3 * s;
+ }
+ s = r1[5];
+ if (s != 0.0f)
+ {
+ r2[5] -= m2 * s;
+ r3[5] -= m3 * s;
+ }
+ s = r1[6];
+ if (s != 0.0f)
+ {
+ r2[6] -= m2 * s;
+ r3[6] -= m3 * s;
+ }
+ s = r1[7];
+ if (s != 0.0f)
+ {
+ r2[7] -= m2 * s;
+ r3[7] -= m3 * s;
+ }
+
+ /* Choose pivot - or die. */
+ if (fabsf(r3[2]) > fabsf(r2[2]))
+ swap_rows(&r3, &r2);
+ if (r2[2] == 0.0f)
+ return FALSE;
+
+ /* Eliminate third variable. */
+ m3 = r3[2] / r2[2];
+ r3[3] -= m3 * r2[3];
+ r3[4] -= m3 * r2[4];
+ r3[5] -= m3 * r2[5];
+ r3[6] -= m3 * r2[6];
+ r3[7] -= m3 * r2[7];
+
+ /* Last check. */
+ if (r3[3] == 0.0f)
+ return FALSE;
+
+ /* Back substitute row 3. */
+ s = 1.0f / r3[3];
+ r3[4] *= s;
+ r3[5] *= s;
+ r3[6] *= s;
+ r3[7] *= s;
+
+ /* Back substitute row 2. */
+ m2 = r2[3];
+ s = 1.0f / r2[2];
+ r2[4] = s * (r2[4] - r3[4] * m2);
+ r2[5] = s * (r2[5] - r3[5] * m2);
+ r2[6] = s * (r2[6] - r3[6] * m2);
+ r2[7] = s * (r2[7] - r3[7] * m2);
+ m1 = r1[3];
+ r1[4] -= r3[4] * m1;
+ r1[5] -= r3[5] * m1;
+ r1[6] -= r3[6] * m1;
+ r1[7] -= r3[7] * m1;
+ m0 = r0[3];
+ r0[4] -= r3[4] * m0;
+ r0[5] -= r3[5] * m0;
+ r0[6] -= r3[6] * m0;
+ r0[7] -= r3[7] * m0;
+
+ /* Back substitute row 1. */
+ m1 = r1[2];
+ s = 1.0f / r1[1];
+ r1[4] = s * (r1[4] - r2[4] * m1);
+ r1[5] = s * (r1[5] - r2[5] * m1);
+ r1[6] = s * (r1[6] - r2[6] * m1);
+ r1[7] = s * (r1[7] - r2[7] * m1);
+ m0 = r0[2];
+ r0[4] -= r2[4] * m0;
+ r0[5] -= r2[5] * m0;
+ r0[6] -= r2[6] * m0;
+ r0[7] -= r2[7] * m0;
+
+ /* Back substitute row 0. */
+ m0 = r0[1];
+ s = 1.0f / r0[0];
+ r0[4] = s * (r0[4] - r1[4] * m0);
+ r0[5] = s * (r0[5] - r1[5] * m0);
+ r0[6] = s * (r0[6] - r1[6] * m0);
+ r0[7] = s * (r0[7] - r1[7] * m0);
+
+ out->_11 = r0[4];
+ out->_12 = r0[5];
+ out->_13 = r0[6];
+ out->_14 = r0[7];
+ out->_21 = r1[4];
+ out->_22 = r1[5];
+ out->_23 = r1[6];
+ out->_24 = r1[7];
+ out->_31 = r2[4];
+ out->_32 = r2[5];
+ out->_33 = r2[6];
+ out->_34 = r2[7];
+ out->_41 = r3[4];
+ out->_42 = r3[5];
+ out->_43 = r3[6];
+ out->_44 = r3[7];
+
+ return TRUE;
+}
+
+void transpose_matrix(struct wined3d_matrix *out, const struct wined3d_matrix *m)
+{
+ struct wined3d_matrix temp;
+ unsigned int i, j;
+
+ for (i = 0; i < 4; ++i)
+ for (j = 0; j < 4; ++j)
+ (&temp._11)[4 * j + i] = (&m->_11)[4 * i + j];
+
+ *out = temp;
+}
+
unsigned int wined3d_max_compat_varyings(const struct wined3d_gl_info *gl_info)
{
/* On core profile we have to also count diffuse and specular colors and the
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 7e5502e..baba9ec 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -3958,6 +3958,9 @@ enum wined3d_primitive_type d3d_primitive_type_from_gl(GLenum primitive_type) DE
/* Math utils */
void multiply_matrix(struct wined3d_matrix *dest, const struct wined3d_matrix *src1,
const struct wined3d_matrix *src2) DECLSPEC_HIDDEN;
+BOOL invert_matrix_3d(struct wined3d_matrix *out, const struct wined3d_matrix *in) DECLSPEC_HIDDEN;
+BOOL invert_matrix(struct wined3d_matrix *out, const struct wined3d_matrix *m) DECLSPEC_HIDDEN;
+void transpose_matrix(struct wined3d_matrix *out, const struct wined3d_matrix *m) DECLSPEC_HIDDEN;
void wined3d_release_dc(HWND window, HDC dc) DECLSPEC_HIDDEN;
--
2.7.4

407
patches/wined3d-Indexed_Vertex_Blending/0005-wined3d-Support-indexed-vertex-blending.patch Normal file
View File

@ -0,0 +1,407 @@
From eaf6f839138991a05e565c5dc94954e9a2eb3dfa Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Mon, 25 Feb 2019 20:28:35 +0300
Subject: [PATCH 5/5] wined3d: Support indexed vertex blending.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/d3d9/tests/visual.c | 6 +-
dlls/wined3d/glsl_shader.c | 162 ++++++++++++++++++++++++++-----
dlls/wined3d/utils.c | 6 +-
dlls/wined3d/vertexdeclaration.c | 9 ++
dlls/wined3d/wined3d_private.h | 11 ++-
5 files changed, 165 insertions(+), 29 deletions(-)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index c2737c3605..ddc6a0699b 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -20916,7 +20916,7 @@ static void do_test_indexed_vertex_blending(IDirect3DDevice9 *device, const char
ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
if (caps.MaxVertexBlendMatrixIndex < 7 || caps.MaxVertexBlendMatrices < 4)
{
- todo_wine win_skip("(%s) Too few vertex blend matrices supported: MaxVertexBlendMatrices=%u, MaxVertexBlendMatrixIndex=%u.\n",
+ win_skip("(%s) Too few vertex blend matrices supported: MaxVertexBlendMatrices=%u, MaxVertexBlendMatrixIndex=%u.\n",
test_id_str, caps.MaxVertexBlendMatrices, caps.MaxVertexBlendMatrixIndex);
return;
}
@@ -21073,7 +21073,7 @@ static void test_indexed_vertex_blending(void)
memset(&caps, 0, sizeof(caps));
hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
- todo_wine ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
+ ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
caps.MaxVertexBlendMatrixIndex);
do_test_indexed_vertex_blending(device,"IVB software");
@@ -21099,7 +21099,7 @@ static void test_indexed_vertex_blending(void)
memset(&caps, 0, sizeof(caps));
hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
- todo_wine ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
+ ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
caps.MaxVertexBlendMatrixIndex);
hr = IDirect3DDevice9_SetSoftwareVertexProcessing(device, FALSE);
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 1dcb0ef7c2..1607fa6405 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -150,6 +150,9 @@ struct shader_glsl_priv
struct wine_rb_tree ffp_fragment_shaders;
BOOL ffp_proj_control;
BOOL legacy_lighting;
+
+ GLuint ubo_modelview;
+ struct wined3d_matrix *modelview_buffer;
};
struct glsl_vs_program
@@ -164,6 +167,7 @@ struct glsl_vs_program
GLint base_vertex_id_location;
GLint modelview_matrix_location[MAX_VERTEX_BLENDS];
+ GLint modelview_block_index;
GLint projection_matrix_location;
GLint normal_matrix_location;
GLint texture_matrix_location[WINED3D_MAX_TEXTURES];
@@ -1897,28 +1901,41 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
}
if (update_mask & WINED3D_SHADER_CONST_FFP_MODELVIEW)
- {
- struct wined3d_matrix mat;
-
- get_modelview_matrix(context, state, 0, &mat);
- GL_EXTCALL(glUniformMatrix4fv(prog->vs.modelview_matrix_location[0], 1, FALSE, &mat._11));
- checkGLcall("glUniformMatrix4fv");
-
shader_glsl_ffp_vertex_normalmatrix_uniform(context, state, prog);
- }
if (update_mask & WINED3D_SHADER_CONST_FFP_VERTEXBLEND)
{
struct wined3d_matrix mat;
- for (i = 1; i < MAX_VERTEX_BLENDS; ++i)
+ if (prog->vs.modelview_block_index != -1)
{
- if (prog->vs.modelview_matrix_location[i] == -1)
- break;
+ if (priv->ubo_modelview == -1)
+ FIXME("UBO buffer with vertex blend matrices is not initialized.\n");
- get_modelview_matrix(context, state, i, &mat);
- GL_EXTCALL(glUniformMatrix4fv(prog->vs.modelview_matrix_location[i], 1, FALSE, &mat._11));
- checkGLcall("glUniformMatrix4fv");
+ GL_EXTCALL(glBindBuffer(GL_UNIFORM_BUFFER, priv->ubo_modelview));
+ checkGLcall("glBindBuffer (UBO)");
+ GL_EXTCALL(glBufferData(GL_UNIFORM_BUFFER, sizeof(*priv->modelview_buffer) * MAX_VERTEX_BLEND_UBO,
+ NULL, GL_STREAM_DRAW));
+ checkGLcall("glBufferData");
+
+ for (i = 0; i < MAX_VERTEX_BLEND_UBO; ++i)
+ get_modelview_matrix(context, state, i, &priv->modelview_buffer[i]);
+
+ GL_EXTCALL(glBufferSubData(GL_UNIFORM_BUFFER, 0,
+ sizeof(*priv->modelview_buffer) * MAX_VERTEX_BLEND_UBO, priv->modelview_buffer));
+ checkGLcall("glBufferSubData");
+ }
+ else
+ {
+ for (i = 0; i < MAX_VERTEX_BLENDS; ++i)
+ {
+ if (prog->vs.modelview_matrix_location[i] == -1)
+ break;
+
+ get_modelview_matrix(context, state, i, &mat);
+ GL_EXTCALL(glUniformMatrix4fv(prog->vs.modelview_matrix_location[i], 1, FALSE, &mat._11));
+ checkGLcall("glUniformMatrix4fv");
+ }
}
}
@@ -9211,8 +9228,7 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
{
{"vec4", "ffp_attrib_position"}, /* WINED3D_FFP_POSITION */
{"vec4", "ffp_attrib_blendweight"}, /* WINED3D_FFP_BLENDWEIGHT */
- /* TODO: Indexed vertex blending */
- {"float", ""}, /* WINED3D_FFP_BLENDINDICES */
+ {"vec4", "ffp_attrib_blendindices"}, /* WINED3D_FFP_BLENDINDICES */
{"vec3", "ffp_attrib_normal"}, /* WINED3D_FFP_NORMAL */
{"float", "ffp_attrib_psize"}, /* WINED3D_FFP_PSIZE */
{"vec4", "ffp_attrib_diffuse"}, /* WINED3D_FFP_DIFFUSE */
@@ -9228,6 +9244,9 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
string_buffer_clear(buffer);
shader_glsl_add_version_declaration(buffer, gl_info);
+ TRACE("settings->vb_indices %#x.\n", settings->vb_indices);
+ if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
+ shader_addline(buffer,"#extension GL_ARB_uniform_buffer_object : enable\n");
if (shader_glsl_use_explicit_attrib_location(gl_info))
shader_addline(buffer, "#extension GL_ARB_explicit_attrib_location : enable\n");
@@ -9242,7 +9261,18 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
}
shader_addline(buffer, "\n");
- shader_addline(buffer, "uniform mat4 ffp_modelview_matrix[%u];\n", MAX_VERTEX_BLENDS);
+ if (settings->vb_indices && gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
+ {
+ shader_addline(buffer,"layout(std140) uniform ffp_modelview_ubo\n\
+ { \n\
+ mat4 ffp_modelview_matrix[%u];\n\
+ };\n", MAX_VERTEX_BLEND_UBO);
+ }
+ else
+ {
+ shader_addline(buffer, "uniform mat4 ffp_modelview_matrix[%u];\n", MAX_VERTEX_BLENDS);
+ }
+
shader_addline(buffer, "uniform mat4 ffp_projection_matrix;\n");
shader_addline(buffer, "uniform mat3 ffp_normal_matrix;\n");
shader_addline(buffer, "uniform mat4 ffp_texture_matrix[%u];\n", WINED3D_MAX_TEXTURES);
@@ -9304,6 +9334,8 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
shader_addline(buffer, "\nvoid main()\n{\n");
shader_addline(buffer, "float m;\n");
shader_addline(buffer, "vec3 r;\n");
+ if (settings->vb_indices)
+ shader_addline(buffer, "int ind;\n");
for (i = 0; i < ARRAY_SIZE(attrib_info); ++i)
{
@@ -9333,8 +9365,21 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
shader_addline(buffer, "ffp_attrib_blendweight[%u] -= ffp_attrib_blendweight[%u];\n", settings->vertexblends, i);
shader_addline(buffer, "vec4 ec_pos = vec4(0.0);\n");
- for (i = 0; i < settings->vertexblends + 1; ++i)
- shader_addline(buffer, "ec_pos += ffp_attrib_blendweight[%u] * (ffp_modelview_matrix[%u] * ffp_attrib_position);\n", i, i);
+ if (settings->vb_indices)
+ {
+ for (i = 0; i < settings->vertexblends + 1; ++i)
+ {
+ shader_addline(buffer, "ind = int(ffp_attrib_blendindices[%u] + 0.1);\n", i);
+ shader_addline(buffer, "ec_pos += ffp_attrib_blendweight[%u] * "
+ "(ffp_modelview_matrix[ind] * ffp_attrib_position);\n", i);
+ }
+ }
+ else
+ {
+ for (i = 0; i < settings->vertexblends + 1; ++i)
+ shader_addline(buffer, "ec_pos += ffp_attrib_blendweight[%u] * "
+ "(ffp_modelview_matrix[%u] * ffp_attrib_position);\n", i, i);
+ }
shader_addline(buffer, "gl_Position = ffp_projection_matrix * ec_pos;\n");
if (settings->clipping)
@@ -9358,7 +9403,19 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
else
{
for (i = 0; i < settings->vertexblends + 1; ++i)
- shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * (mat3(ffp_modelview_matrix[%u]) * ffp_attrib_normal);\n", i, i);
+ {
+ if (settings->vb_indices)
+ {
+ shader_addline(buffer, "ind = int(ffp_attrib_blendindices[%u] + 0.1);\n", i);
+ shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * "
+ "(mat3(ffp_modelview_matrix[ind]) * ffp_attrib_normal);\n", i);
+ }
+ else
+ {
+ shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * "
+ "(mat3(ffp_modelview_matrix[%u]) * ffp_attrib_normal);\n", i, i);
+ }
+ }
}
if (settings->normalize)
@@ -10231,6 +10288,39 @@ static void shader_glsl_init_vs_uniform_locations(const struct wined3d_gl_info *
string_buffer_sprintf(name, "ffp_modelview_matrix[%u]", i);
vs->modelview_matrix_location[i] = GL_EXTCALL(glGetUniformLocation(program_id, name->buffer));
}
+
+ if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
+ {
+ vs->modelview_block_index = GL_EXTCALL(glGetUniformBlockIndex(program_id, "ffp_modelview_ubo"));
+ checkGLcall("glGetUniformBlockIndex");
+ if (vs->modelview_block_index != -1)
+ {
+ unsigned int base, count;
+
+ wined3d_gl_limits_get_uniform_block_range(&gl_info->limits, WINED3D_SHADER_TYPE_VERTEX,
+ &base, &count);
+ assert(count >= 1);
+
+ GL_EXTCALL(glUniformBlockBinding(program_id, vs->modelview_block_index, base + count));
+ checkGLcall("glUniformBlockBinding");
+ if (priv->ubo_modelview == -1)
+ {
+ GL_EXTCALL(glGenBuffers(1, &priv->ubo_modelview));
+ GL_EXTCALL(glBindBuffer(GL_UNIFORM_BUFFER, priv->ubo_modelview));
+ checkGLcall("glBindBuffer (UBO)");
+ GL_EXTCALL(glBufferData(GL_UNIFORM_BUFFER,
+ sizeof(struct wined3d_matrix) * MAX_VERTEX_BLEND_UBO, NULL, GL_DYNAMIC_DRAW));
+ checkGLcall("glBufferData (UBO)");
+ GL_EXTCALL(glBindBufferBase(GL_UNIFORM_BUFFER, base + count, priv->ubo_modelview));
+ checkGLcall("glBindBufferBase");
+ }
+ }
+ }
+ else
+ {
+ vs->modelview_block_index = -1;
+ }
+
vs->projection_matrix_location = GL_EXTCALL(glGetUniformLocation(program_id, "ffp_projection_matrix"));
vs->normal_matrix_location = GL_EXTCALL(glGetUniformLocation(program_id, "ffp_normal_matrix"));
for (i = 0; i < WINED3D_MAX_TEXTURES; ++i)
@@ -10819,6 +10909,9 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
}
}
+ if (entry->vs.modelview_block_index != -1)
+ entry->constant_update_mask |= WINED3D_SHADER_CONST_FFP_VERTEXBLEND;
+
for (i = 0; i < WINED3D_MAX_TEXTURES; ++i)
{
if (entry->vs.texture_matrix_location[i] != -1)
@@ -11355,7 +11448,17 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
fragment_pipe->get_caps(gl_info, &fragment_caps);
priv->ffp_proj_control = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_PROJ_CONTROL;
priv->legacy_lighting = device->wined3d->flags & WINED3D_LEGACY_FFP_LIGHTING;
-
+ priv->ubo_modelview = -1; /* To be initialized on first usage. */
+ if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
+ {
+ priv->modelview_buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv->modelview_buffer)
+ * MAX_VERTEX_BLEND_UBO);
+ if (!priv->modelview_buffer)
+ {
+ ERR("Failed to alloacte modelview buffer.\n");
+ goto fail;
+ }
+ }
device->vertex_priv = vertex_priv;
device->fragment_priv = fragment_priv;
device->shader_priv = priv;
@@ -11388,6 +11491,14 @@ static void shader_glsl_free(struct wined3d_device *device)
string_buffer_free(&priv->shader_buffer);
priv->fragment_pipe->free_private(device);
priv->vertex_pipe->vp_free(device);
+ if (priv->ubo_modelview != -1)
+ {
+ const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
+ GL_EXTCALL(glDeleteBuffers(1, &priv->ubo_modelview));
+ checkGLcall("glDeleteBuffers");
+ priv->ubo_modelview = -1;
+ }
+ HeapFree(GetProcessHeap(), 0, priv->modelview_buffer);
if (priv->ubo_vs_c != -1)
{
@@ -11804,7 +11915,11 @@ static void glsl_vertex_pipe_vp_get_caps(const struct wined3d_gl_info *gl_info,
caps->ffp_generic_attributes = TRUE;
caps->max_active_lights = WINED3D_MAX_ACTIVE_LIGHTS;
caps->max_vertex_blend_matrices = MAX_VERTEX_BLENDS;
- caps->max_vertex_blend_matrix_index = 0;
+ if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
+ caps->max_vertex_blend_matrix_index = MAX_VERTEX_BLEND_UBO - 1;
+ else
+ caps->max_vertex_blend_matrix_index = MAX_VERTEX_BLENDS - 1;
+
caps->vertex_processing_caps = WINED3DVTXPCAPS_TEXGEN
| WINED3DVTXPCAPS_MATERIALSOURCE7
| WINED3DVTXPCAPS_VERTEXFOG
@@ -12003,7 +12118,8 @@ static void glsl_vertex_pipe_pixel_shader(struct wined3d_context *context,
static void glsl_vertex_pipe_world(struct wined3d_context *context,
const struct wined3d_state *state, DWORD state_id)
{
- context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MODELVIEW;
+ context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_MODELVIEW
+ | WINED3D_SHADER_CONST_FFP_VERTEXBLEND;
}
static void glsl_vertex_pipe_vertexblend(struct wined3d_context *context,
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 3785ae104b..f2362b0266 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -6331,6 +6331,7 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_context *context,
settings->flatshading = FALSE;
settings->swizzle_map = si->swizzle_map;
+ settings->vb_indices = is_indexed_vertex_blending(context, state);
}
int wined3d_ffp_vertex_program_key_compare(const void *key, const struct wine_rb_entry *entry)
@@ -6462,8 +6463,9 @@ void wined3d_gl_limits_get_uniform_block_range(const struct wined3d_gl_limits *g
*base += *count;
if (i == WINED3D_SHADER_TYPE_VERTEX)
{
- /* Reserve binding location for vs_c UBO. */
- ++*base;
+ /* Reserve binding locations for vs_c UBO and modelview UBO
+ used for indexed vertex blending. */
+ *base += 2;
}
}
diff --git a/dlls/wined3d/vertexdeclaration.c b/dlls/wined3d/vertexdeclaration.c
index cd8bb5e423..d37f3ce860 100644
--- a/dlls/wined3d/vertexdeclaration.c
+++ b/dlls/wined3d/vertexdeclaration.c
@@ -119,6 +119,15 @@ static BOOL declaration_element_valid_ffp(const struct wined3d_vertex_element *e
return FALSE;
}
+ case WINED3D_DECL_USAGE_BLEND_INDICES:
+ switch(element->format)
+ {
+ case WINED3DFMT_R8G8B8A8_UINT:
+ return TRUE;
+ default:
+ return FALSE;
+ }
+
case WINED3D_DECL_USAGE_NORMAL:
switch(element->format)
{
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 134a376707..1da3236add 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -275,6 +275,7 @@ static inline enum complex_fixup get_complex_fixup(struct color_fixup_desc fixup
#define MAX_UNORDERED_ACCESS_VIEWS 8
#define MAX_TGSM_REGISTERS 8192
#define MAX_VERTEX_BLENDS 4
+#define MAX_VERTEX_BLEND_UBO 256
#define MAX_RENDER_TARGETS 8
struct min_lookup
@@ -2836,7 +2837,8 @@ struct wined3d_ffp_vs_settings
DWORD ortho_fog : 1;
DWORD flatshading : 1;
DWORD swizzle_map : 16; /* MAX_ATTRIBS, 16 */
- DWORD padding : 2;
+ DWORD vb_indices : 1;
+ DWORD padding : 1;
DWORD texgen[WINED3D_MAX_TEXTURES];
};
@@ -4733,6 +4735,13 @@ static inline void wined3d_not_from_cs(struct wined3d_cs *cs)
assert(cs->thread_id != GetCurrentThreadId());
}
+static inline BOOL is_indexed_vertex_blending(const struct wined3d_context *context,
+ const struct wined3d_state *state)
+{
+ return state->render_states[WINED3D_RS_INDEXEDVERTEXBLENDENABLE]
+ && (context->stream_info.use_map & (1 << WINED3D_FFP_BLENDINDICES));
+}
+
/* The WNDCLASS-Name for the fake window which we use to retrieve the GL capabilities */
#define WINED3D_OPENGL_WINDOW_CLASS_NAME "WineD3D_OpenGL"
--
2.20.1

310
patches/wined3d-Indexed_Vertex_Blending/0006-wined3d-Implement-software-processing-for-indexed-ve.patch
View File

@ -1,310 +0,0 @@
From 5e7d9e0d6a83ef9d175e2953a39f299a4b91975a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20M=C3=BCller?= <michael@fds-team.de>
Date: Thu, 31 Aug 2017 01:26:38 +0200
Subject: wined3d: Implement software processing for indexed vertex blending.
---
dlls/wined3d/context.c | 107 ++++++++++++++++++++++++++++++++-
dlls/wined3d/device.c | 16 -----
dlls/wined3d/glsl_shader.c | 32 +++++++---
dlls/wined3d/utils.c | 7 ++-
dlls/wined3d/wined3d_private.h | 16 ++++-
5 files changed, 148 insertions(+), 30 deletions(-)
diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c
index cf250162..272792fb 100644
--- a/dlls/wined3d/context.c
+++ b/dlls/wined3d/context.c
@@ -4508,6 +4508,101 @@ static void draw_primitive_arrays(struct wined3d_context *context, const struct
}
}
+static const BYTE *software_vertex_blending(struct wined3d_context *context,
+ const struct wined3d_state *state, const struct wined3d_stream_info *si,
+ unsigned int element_idx, unsigned int stride_idx, float *result)
+{
+#define SI_FORMAT(idx) (si->elements[(idx)].format->emit_idx)
+#define SI_PTR(idx1, idx2) (si->elements[(idx1)].data.addr + si->elements[(idx1)].stride * (idx2))
+
+ const float *data = (const float *)SI_PTR(element_idx, stride_idx);
+ float vector[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+ float cur_weight, weight_sum = 0.0f;
+ struct wined3d_matrix m;
+ const BYTE *blend_index;
+ const float *weights;
+ int i, num_weights;
+
+ if (element_idx != WINED3D_FFP_POSITION && element_idx != WINED3D_FFP_NORMAL)
+ return (BYTE *)data;
+
+ if (!use_indexed_vertex_blending(state, si) || !use_software_vertex_processing(context->device))
+ return (BYTE *)data;
+
+ if (!si->elements[WINED3D_FFP_BLENDINDICES].data.addr ||
+ !si->elements[WINED3D_FFP_BLENDWEIGHT].data.addr)
+ {
+ FIXME("no blend indices / weights set\n");
+ return (BYTE *)data;
+ }
+
+ if (SI_FORMAT(WINED3D_FFP_BLENDINDICES) != WINED3D_FFP_EMIT_UBYTE4)
+ {
+ FIXME("unsupported blend index format: %u\n", SI_FORMAT(WINED3D_FFP_BLENDINDICES));
+ return (BYTE *)data;
+ }
+
+ /* FIXME: validate weight format */
+ switch (state->render_states[WINED3D_RS_VERTEXBLEND])
+ {
+ case WINED3D_VBF_0WEIGHTS: num_weights = 0; break;
+ case WINED3D_VBF_1WEIGHTS: num_weights = 1; break;
+ case WINED3D_VBF_2WEIGHTS: num_weights = 2; break;
+ case WINED3D_VBF_3WEIGHTS: num_weights = 3; break;
+ default:
+ FIXME("unsupported vertex blend render state: %u\n", state->render_states[WINED3D_RS_VERTEXBLEND]);
+ return (BYTE *)data;
+ }
+
+ switch (SI_FORMAT(element_idx))
+ {
+ case WINED3D_FFP_EMIT_FLOAT4: vector[3] = data[3];
+ case WINED3D_FFP_EMIT_FLOAT3: vector[2] = data[2];
+ case WINED3D_FFP_EMIT_FLOAT2: vector[1] = data[1];
+ case WINED3D_FFP_EMIT_FLOAT1: vector[0] = data[0]; break;
+ default:
+ FIXME("unsupported value format: %u\n", SI_FORMAT(element_idx));
+ return (BYTE *)data;
+ }
+
+ blend_index = SI_PTR(WINED3D_FFP_BLENDINDICES, stride_idx);
+ weights = (const float *)SI_PTR(WINED3D_FFP_BLENDWEIGHT, stride_idx);
+ result[0] = result[1] = result[2] = result[3] = 0.0f;
+
+ for (i = 0; i < num_weights + 1; i++)
+ {
+ cur_weight = (i < num_weights) ? weights[i] : 1.0f - weight_sum;
+ get_modelview_matrix(context, state, blend_index[i], &m);
+
+ if (element_idx == WINED3D_FFP_POSITION)
+ {
+ result[0] += cur_weight * (vector[0] * m._11 + vector[1] * m._21 + vector[2] * m._31 + vector[3] * m._41);
+ result[1] += cur_weight * (vector[0] * m._12 + vector[1] * m._22 + vector[2] * m._32 + vector[3] * m._42);
+ result[2] += cur_weight * (vector[0] * m._13 + vector[1] * m._23 + vector[2] * m._33 + vector[3] * m._43);
+ result[3] += cur_weight * (vector[0] * m._14 + vector[1] * m._24 + vector[2] * m._34 + vector[3] * m._44);
+ }
+ else
+ {
+ if (context->d3d_info->wined3d_creation_flags & WINED3D_LEGACY_FFP_LIGHTING)
+ invert_matrix_3d(&m, &m);
+ else
+ invert_matrix(&m, &m);
+
+ /* multiply with transposed M */
+ result[0] += cur_weight * (vector[0] * m._11 + vector[1] * m._12 + vector[2] * m._13);
+ result[1] += cur_weight * (vector[0] * m._21 + vector[1] * m._22 + vector[2] * m._23);
+ result[2] += cur_weight * (vector[0] * m._31 + vector[1] * m._32 + vector[2] * m._33);
+ }
+
+ weight_sum += weights[i];
+ }
+
+#undef SI_FORMAT
+#undef SI_PTR
+
+ return (BYTE *)result;
+}
+
static unsigned int get_stride_idx(const void *idx_data, unsigned int idx_size,
unsigned int base_vertex_idx, unsigned int start_idx, unsigned int vertex_idx)
{
@@ -4536,6 +4631,7 @@ static void draw_primitive_immediate_mode(struct wined3d_context *context, const
BOOL specular_fog = FALSE;
BOOL ps = use_ps(state);
const void *ptr;
+ float tmp[4];
static unsigned int once;
@@ -4572,7 +4668,7 @@ static void draw_primitive_immediate_mode(struct wined3d_context *context, const
if (!(use_map & 1u << element_idx))
continue;
- ptr = si->elements[element_idx].data.addr + si->elements[element_idx].stride * stride_idx;
+ ptr = software_vertex_blending(context, state, si, element_idx, stride_idx, tmp);
ops->generic[si->elements[element_idx].format->emit_idx](element_idx, ptr);
}
}
@@ -4684,7 +4780,7 @@ static void draw_primitive_immediate_mode(struct wined3d_context *context, const
if (normal)
{
- ptr = normal + stride_idx * si->elements[WINED3D_FFP_NORMAL].stride;
+ ptr = software_vertex_blending(context, state, si, WINED3D_FFP_NORMAL, stride_idx, tmp);
ops->normal[si->elements[WINED3D_FFP_NORMAL].format->emit_idx](ptr);
}
@@ -4729,7 +4825,7 @@ static void draw_primitive_immediate_mode(struct wined3d_context *context, const
if (position)
{
- ptr = position + stride_idx * si->elements[WINED3D_FFP_POSITION].stride;
+ ptr = software_vertex_blending(context, state, si, WINED3D_FFP_POSITION, stride_idx, tmp);
ops->position[si->elements[WINED3D_FFP_POSITION].format->emit_idx](ptr);
}
}
@@ -4958,6 +5054,11 @@ void draw_primitive(struct wined3d_device *device, const struct wined3d_state *s
WARN_(d3d_perf)("Using software emulation because manual fog coordinates are provided.\n");
emulation = TRUE;
}
+ else if (use_indexed_vertex_blending(state, stream_info) && use_software_vertex_processing(context->device))
+ {
+ WARN_(d3d_perf)("Using software emulation because application requested SVP.\n");
+ emulation = TRUE;
+ }
if (emulation)
{
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 0d936bcb..dcae682a 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -4027,31 +4027,15 @@ HRESULT CDECL wined3d_device_validate_device(const struct wined3d_device *device
void CDECL wined3d_device_set_software_vertex_processing(struct wined3d_device *device, BOOL software)
{
- static BOOL warned;
-
TRACE("device %p, software %#x.\n", device, software);
- if (!warned)
- {
- FIXME("device %p, software %#x stub!\n", device, software);
- warned = TRUE;
- }
-
device->softwareVertexProcessing = software;
}
BOOL CDECL wined3d_device_get_software_vertex_processing(const struct wined3d_device *device)
{
- static BOOL warned;
-
TRACE("device %p.\n", device);
- if (!warned)
- {
- TRACE("device %p stub!\n", device);
- warned = TRUE;
- }
-
return device->softwareVertexProcessing;
}
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 244b5eb3..8dec8114 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -8955,14 +8955,21 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
}
else
{
- for (i = 0; i < settings->vertexblends; ++i)
- shader_addline(buffer, "ffp_attrib_blendweight[%u] -= ffp_attrib_blendweight[%u];\n", settings->vertexblends, i);
+ if (!settings->sw_blending)
+ {
+ for (i = 0; i < settings->vertexblends; ++i)
+ shader_addline(buffer, "ffp_attrib_blendweight[%u] -= ffp_attrib_blendweight[%u];\n", settings->vertexblends, i);
- shader_addline(buffer, "vec4 ec_pos = vec4(0.0);\n");
- for (i = 0; i < settings->vertexblends + 1; ++i)
+ shader_addline(buffer, "vec4 ec_pos = vec4(0.0);\n");
+ for (i = 0; i < settings->vertexblends + 1; ++i)
+ {
+ sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
+ shader_addline(buffer, "ec_pos += ffp_attrib_blendweight[%u] * (ffp_modelview_matrix[%s] * ffp_attrib_position);\n", i, var);
+ }
+ }
+ else
{
- sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
- shader_addline(buffer, "ec_pos += ffp_attrib_blendweight[%u] * (ffp_modelview_matrix[%s] * ffp_attrib_position);\n", i, var);
+ shader_addline(buffer, "vec4 ec_pos = ffp_attrib_position;\n");
}
shader_addline(buffer, "gl_Position = ffp_projection_matrix * ec_pos;\n");
@@ -8980,10 +8987,17 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct shader_glsl_priv *pr
shader_addline(buffer, "vec3 normal = vec3(0.0);\n");
if (settings->normal)
{
- for (i = 0; i < settings->vertexblends + 1; ++i)
+ if (!settings->sw_blending)
+ {
+ for (i = 0; i < settings->vertexblends + 1; ++i)
+ {
+ sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
+ shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * (ffp_normal_matrix[%s] * ffp_attrib_normal);\n", i, var);
+ }
+ }
+ else
{
- sprintf(var, settings->vb_indices ? "int(ffp_attrib_blendindices[%u] + 0.1)" : "%u", i);
- shader_addline(buffer, "normal += ffp_attrib_blendweight[%u] * (ffp_normal_matrix[%s] * ffp_attrib_normal);\n", i, var);
+ shader_addline(buffer, "normal = ffp_attrib_normal;\n");
}
if (settings->normalize)
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index cb9efef0..a699cf5b 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -6533,7 +6533,12 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_context *context,
}
if (use_indexed_vertex_blending(state, si))
- settings->vb_indices = 1;
+ {
+ if (use_software_vertex_processing(context->device))
+ settings->sw_blending = 1;
+ else
+ settings->vb_indices = 1;
+ }
settings->clipping = state->render_states[WINED3D_RS_CLIPPING]
&& state->render_states[WINED3D_RS_CLIPPLANEENABLE];
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index d84ed0d4..492b9190 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -2829,7 +2829,7 @@ struct wined3d_ffp_vs_settings
DWORD flatshading : 1;
DWORD swizzle_map : 16; /* MAX_ATTRIBS, 16 */
DWORD vb_indices : 1;
- DWORD padding : 1;
+ DWORD sw_blending : 1;
DWORD texgen[WINED3D_MAX_TEXTURES];
};
@@ -4588,6 +4588,20 @@ static inline BOOL use_indexed_vertex_blending(const struct wined3d_state *state
return TRUE;
}
+static inline BOOL use_software_vertex_processing(const struct wined3d_device *device)
+{
+ if (device->shader_backend != &glsl_shader_backend)
+ return FALSE;
+
+ if (device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING)
+ return TRUE;
+
+ if (!(device->create_parms.flags & WINED3DCREATE_MIXED_VERTEXPROCESSING))
+ return FALSE;
+
+ return device->softwareVertexProcessing;
+}
+
static inline BOOL use_vs(const struct wined3d_state *state)
{
/* Check state->vertex_declaration to allow this to be used before the
--
2.20.1

76
patches/wined3d-Indexed_Vertex_Blending/0008-wined3d-Report-correct-number-of-blend-matrices-when.patch
View File

@ -1,76 +0,0 @@
From 8e3863a2416027b47d38f01f0e6d0755c8ce1cd4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Michael=20M=C3=BCller?= <michael@fds-team.de>
Date: Thu, 31 Aug 2017 01:54:22 +0200
Subject: [PATCH] wined3d: Report correct number of blend matrices when
software vertex processing is used.
---
dlls/d3d9/tests/visual.c | 4 ++--
dlls/wined3d/device.c | 9 ++++++++-
dlls/wined3d/directx.c | 5 ++++-
3 files changed, 14 insertions(+), 4 deletions(-)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index b5c610e6a36..7346fcccf70 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -20666,7 +20666,7 @@ static void test_indexed_vertex_blending(void)
memset(&caps, 0, sizeof(caps));
hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
- todo_wine ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
+ ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
caps.MaxVertexBlendMatrixIndex);
do_test_indexed_vertex_blending(device,"IVB software");
@@ -20692,7 +20692,7 @@ static void test_indexed_vertex_blending(void)
memset(&caps, 0, sizeof(caps));
hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
- todo_wine ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
+ ok(caps.MaxVertexBlendMatrixIndex == 255, "Expected 255 as maximum blend matrix index, got %u.\n",
caps.MaxVertexBlendMatrixIndex);
hr = IDirect3DDevice9_SetSoftwareVertexProcessing(device, FALSE);
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index bab2fcc89c4..31c843829aa 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -3500,10 +3500,17 @@ struct wined3d_texture * CDECL wined3d_device_get_texture(const struct wined3d_d
HRESULT CDECL wined3d_device_get_device_caps(const struct wined3d_device *device, struct wined3d_caps *caps)
{
+ HRESULT hr;
+
TRACE("device %p, caps %p.\n", device, caps);
- return wined3d_get_device_caps(device->wined3d, device->adapter->ordinal,
+ hr = wined3d_get_device_caps(device->wined3d, device->adapter->ordinal,
device->create_parms.device_type, caps);
+
+ if (SUCCEEDED(hr) && use_software_vertex_processing(device))
+ caps->MaxVertexBlendMatrixIndex = 255;
+
+ return hr;
}
HRESULT CDECL wined3d_device_get_display_mode(const struct wined3d_device *device, UINT swapchain_idx,
diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index 63cd4f33041..bb332a48464 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -6022,7 +6022,10 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapte
caps->MaxUserClipPlanes = vertex_caps.max_user_clip_planes;
caps->MaxActiveLights = vertex_caps.max_active_lights;
caps->MaxVertexBlendMatrices = vertex_caps.max_vertex_blend_matrices;
- caps->MaxVertexBlendMatrixIndex = vertex_caps.max_vertex_blend_matrix_index;
+ if (device_type == WINED3D_DEVICE_TYPE_HAL)
+ caps->MaxVertexBlendMatrixIndex = vertex_caps.max_vertex_blend_matrix_index;
+ else
+ caps->MaxVertexBlendMatrixIndex = 255;
caps->VertexProcessingCaps = vertex_caps.vertex_processing_caps;
caps->FVFCaps = vertex_caps.fvf_caps;
caps->RasterCaps |= vertex_caps.raster_caps;
--
2.17.1

57
patches/wined3d-Indexed_Vertex_Blending/0009-wined3d-Track-updates-of-vertex-blend-matrices-separ.patch
View File

@ -1,57 +0,0 @@
From 726f9593426745c69d5a907e210c9fcff88a2bbb Mon Sep 17 00:00:00 2001
From: Sebastian Lackner <sebastian@fds-team.de>
Date: Thu, 31 Aug 2017 07:42:31 +0200
Subject: wined3d: Track updates of vertex blend matrices separately.
---
dlls/wined3d/glsl_shader.c | 5 ++++-
dlls/wined3d/wined3d_private.h | 3 ++-
2 files changed, 6 insertions(+), 2 deletions(-)
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index cc6068cf44..11887b74ff 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -1560,6 +1560,8 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
{
if (prog->vs.modelview_matrix_location[i] == -1)
break;
+ if (!(update_mask & WINED3D_SHADER_CONST_FFP_VERTEXBLEND_INDEX(i)))
+ continue;
get_modelview_matrix(context, state, i, &mat);
GL_EXTCALL(glUniformMatrix4fv(prog->vs.modelview_matrix_location[i], 1, FALSE, &mat._11));
@@ -11612,7 +11614,8 @@ static void glsl_vertex_pipe_world(struct wined3d_context *context,
static void glsl_vertex_pipe_vertexblend(struct wined3d_context *context,
const struct wined3d_state *state, DWORD state_id)
{
- context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_VERTEXBLEND;
+ int i = state_id - STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0));
+ context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_VERTEXBLEND_INDEX(i);
}
static void glsl_vertex_pipe_view(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index c76a72131f..75697216f1 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -440,7 +440,6 @@ enum wined3d_shader_resource_type
#define WINED3D_SHADER_CONST_PS_Y_CORR 0x00001000
#define WINED3D_SHADER_CONST_PS_NP2_FIXUP 0x00002000
#define WINED3D_SHADER_CONST_FFP_MODELVIEW 0x00004000
-#define WINED3D_SHADER_CONST_FFP_VERTEXBLEND 0x00008000
#define WINED3D_SHADER_CONST_FFP_PROJ 0x00010000
#define WINED3D_SHADER_CONST_FFP_TEXMATRIX 0x00020000
#define WINED3D_SHADER_CONST_FFP_MATERIAL 0x00040000
@@ -448,6 +447,8 @@ enum wined3d_shader_resource_type
#define WINED3D_SHADER_CONST_FFP_PS 0x00100000
#define WINED3D_SHADER_CONST_FFP_COLOR_KEY 0x00200000
#define WINED3D_SHADER_CONST_BASE_VERTEX_ID 0x00400000
+#define WINED3D_SHADER_CONST_FFP_VERTEXBLEND 0xff000000
+#define WINED3D_SHADER_CONST_FFP_VERTEXBLEND_INDEX(i) (0x01000000 << ((i) - 1))
enum wined3d_shader_register_type
{
--
2.14.1

3
patches/wined3d-Indexed_Vertex_Blending/definition
View File

@ -1,2 +1,3 @@
Fixes: [39057] Support for indexed vertex blending
Fixes: [39057] Support for Indexed Vertex Blending
Depends: wined3d-WINED3D_RS_COLORWRITEENABLE
Depends: wined3d-SWVP-shaders

303
patches/wined3d-SWVP-shaders/0001-wined3d-Use-UBO-for-vertex-shader-float-constants-if.patch Normal file
View File

@ -0,0 +1,303 @@
From 6b44ab2e3f778bf8b7837ea02dca26abdc1547a2 Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Mon, 25 Feb 2019 13:17:01 +0300
Subject: [PATCH 1/5] wined3d: Use UBO for vertex shader float constants if
supported.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/wined3d/adapter_gl.c | 3 +
dlls/wined3d/glsl_shader.c | 113 +++++++++++++++++++++++++++++----
dlls/wined3d/shader.c | 2 +
dlls/wined3d/utils.c | 5 ++
dlls/wined3d/wined3d_private.h | 2 +
5 files changed, 114 insertions(+), 11 deletions(-)
diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c
index 48eca14fe2..493bca5d90 100644
--- a/dlls/wined3d/adapter_gl.c
+++ b/dlls/wined3d/adapter_gl.c
@@ -3081,6 +3081,9 @@ static void wined3d_adapter_init_limits(struct wined3d_gl_info *gl_info, struct
gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_VERTEX] = min(gl_max, WINED3D_MAX_CBS);
TRACE("Max vertex uniform blocks: %u (%d).\n",
gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_VERTEX], gl_max);
+ gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &gl_max);
+ gl_info->limits.glsl_max_uniform_block_size = gl_max;
+ TRACE("Max uniform block size %u.\n", gl_max);
}
}
if (gl_info->supported[ARB_TESSELLATION_SHADER])
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 470cb0c3ba..625997470f 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -138,6 +138,10 @@ struct shader_glsl_priv
unsigned char *stack;
UINT next_constant_version;
+ BOOL consts_ubo;
+ GLuint ubo_vs_c;
+ struct wined3d_vec4 vs_c_buffer[WINED3D_MAX_VS_CONSTS_F];
+
const struct wined3d_vertex_pipe_ops *vertex_pipe;
const struct fragment_pipeline *fragment_pipe;
struct wine_rb_tree ffp_vertex_shaders;
@@ -189,6 +193,7 @@ struct glsl_vs_program
GLint pointsize_l_att_location;
GLint pointsize_q_att_location;
GLint clip_planes_location;
+ GLint vs_c_block_index;
};
struct glsl_hs_program
@@ -1145,12 +1150,48 @@ static inline void walk_constant_heap_clamped(const struct wined3d_gl_info *gl_i
checkGLcall("walk_constant_heap_clamped()");
}
+static void bind_and_orphan_consts_ubo(const struct wined3d_gl_info *gl_info, struct shader_glsl_priv *priv)
+{
+ GL_EXTCALL(glBindBuffer(GL_UNIFORM_BUFFER, priv->ubo_vs_c));
+ checkGLcall("glBindBuffer");
+ GL_EXTCALL(glBufferData(GL_UNIFORM_BUFFER, WINED3D_MAX_VS_CONSTS_F * sizeof(struct wined3d_vec4),
+ NULL, GL_STREAM_DRAW));
+ checkGLcall("glBufferData");
+}
+
/* Context activation is done by the caller. */
static void shader_glsl_load_constants_f(const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info,
const struct wined3d_vec4 *constants, const GLint *constant_locations, const struct constant_heap *heap,
- unsigned char *stack, unsigned int version)
+ unsigned char *stack, unsigned int version, struct shader_glsl_priv *priv)
{
const struct wined3d_shader_lconst *lconst;
+ BOOL is_vertex_shader = shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_VERTEX;
+
+ if (is_vertex_shader && priv->consts_ubo)
+ {
+ const struct wined3d_vec4 *data;
+ unsigned max_const_used;
+
+ bind_and_orphan_consts_ubo(gl_info, priv);
+ max_const_used = shader->reg_maps.usesrelconstF
+ ? WINED3D_MAX_VS_CONSTS_F : shader->reg_maps.constant_float_count;
+ if (shader->load_local_constsF)
+ {
+ data = priv->vs_c_buffer;
+ memcpy(priv->vs_c_buffer, constants, max_const_used * sizeof(*constants));
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
+ {
+ priv->vs_c_buffer[lconst->idx] = *(const struct wined3d_vec4 *)lconst->value;
+ }
+ }
+ else
+ {
+ data = constants;
+ }
+ GL_EXTCALL(glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(*constants) * max_const_used, data));
+ checkGLcall("glBufferSubData");
+ return;
+ }
/* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
if (shader->reg_maps.shader_version.major == 1
@@ -1801,7 +1842,7 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
if (update_mask & WINED3D_SHADER_CONST_VS_F)
shader_glsl_load_constants_f(vshader, gl_info, state->vs_consts_f,
- prog->vs.uniform_f_locations, &priv->vconst_heap, priv->stack, constant_version);
+ prog->vs.uniform_f_locations, &priv->vconst_heap, priv->stack, constant_version, priv);
if (update_mask & WINED3D_SHADER_CONST_VS_I)
shader_glsl_load_constants_i(vshader, gl_info, state->vs_consts_i,
@@ -1954,7 +1995,7 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
if (update_mask & WINED3D_SHADER_CONST_PS_F)
shader_glsl_load_constants_f(pshader, gl_info, state->ps_consts_f,
- prog->ps.uniform_f_locations, &priv->pconst_heap, priv->stack, constant_version);
+ prog->ps.uniform_f_locations, &priv->pconst_heap, priv->stack, constant_version, priv);
if (update_mask & WINED3D_SHADER_CONST_PS_I)
shader_glsl_load_constants_i(pshader, gl_info, state->ps_consts_i,
@@ -2093,6 +2134,9 @@ static void shader_glsl_update_float_vertex_constants(struct wined3d_device *dev
struct constant_heap *heap = &priv->vconst_heap;
UINT i;
+ if (priv->consts_ubo)
+ return;
+
for (i = start; i < count + start; ++i)
{
update_heap_entry(heap, i, priv->next_constant_version);
@@ -2408,6 +2452,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
const struct wined3d_shader_version *version = &reg_maps->shader_version;
const struct vs_compile_args *vs_args = ctx_priv->cur_vs_args;
const struct ps_compile_args *ps_args = ctx_priv->cur_ps_args;
+ struct shader_glsl_priv *priv = context->device->shader_priv;
const struct wined3d_gl_info *gl_info = context->gl_info;
const struct wined3d_shader_indexable_temp *idx_temp_reg;
unsigned int uniform_block_base, uniform_block_count;
@@ -2425,7 +2470,15 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
}
/* Declare the constants (aka uniforms) */
- if (shader->limits->constant_float > 0)
+ if (shader->limits->constant_float > 0 && priv->consts_ubo
+ && version->type == WINED3D_SHADER_TYPE_VERTEX)
+ {
+ shader_addline(buffer,"layout(std140) uniform vs_c_ubo\n"
+ "{ \n"
+ " vec4 %s_c[%u];\n"
+ "};\n", prefix, min(shader->limits->constant_float, WINED3D_MAX_VS_CONSTS_F));
+ }
+ else if (shader->limits->constant_float > 0)
{
unsigned max_constantsF;
@@ -2490,11 +2543,12 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
}
else
{
- max_constantsF = gl_info->limits.glsl_vs_float_constants;
+ max_constantsF = reg_maps->constant_float_count;
}
}
max_constantsF = min(shader->limits->constant_float, max_constantsF);
- shader_addline(buffer, "uniform vec4 %s_c[%u];\n", prefix, max_constantsF);
+ if (max_constantsF)
+ shader_addline(buffer, "uniform vec4 %s_c[%u];\n", prefix, max_constantsF);
}
/* Always declare the full set of constants, the compiler can remove the
@@ -10101,17 +10155,44 @@ static struct glsl_ffp_fragment_shader *shader_glsl_find_ffp_fragment_shader(str
static void shader_glsl_init_vs_uniform_locations(const struct wined3d_gl_info *gl_info,
- struct shader_glsl_priv *priv, GLuint program_id, struct glsl_vs_program *vs, unsigned int vs_c_count)
+ struct shader_glsl_priv *priv, GLuint program_id, struct glsl_vs_program *vs,
+ unsigned int vs_c_count)
{
unsigned int i;
struct wined3d_string_buffer *name = string_buffer_get(&priv->string_buffers);
- for (i = 0; i < vs_c_count; ++i)
+ if (priv->consts_ubo && vs_c_count)
{
- string_buffer_sprintf(name, "vs_c[%u]", i);
- vs->uniform_f_locations[i] = GL_EXTCALL(glGetUniformLocation(program_id, name->buffer));
+ unsigned int base, count;
+
+ vs->vs_c_block_index = GL_EXTCALL(glGetUniformBlockIndex(program_id, "vs_c_ubo"));
+ checkGLcall("glGetUniformBlockIndex");
+ if (vs->vs_c_block_index == -1)
+ ERR("Could not get ubo_vs_c block index.\n");
+
+ wined3d_gl_limits_get_uniform_block_range(&gl_info->limits, WINED3D_SHADER_TYPE_VERTEX,
+ &base, &count);
+ assert(count >= 1);
+ GL_EXTCALL(glUniformBlockBinding(program_id, vs->vs_c_block_index, base + count + 1));
+ checkGLcall("glUniformBlockBinding");
+ if (priv->ubo_vs_c == -1)
+ {
+ GL_EXTCALL(glGenBuffers(1, &priv->ubo_vs_c));
+ GL_EXTCALL(glBindBuffer(GL_UNIFORM_BUFFER, priv->ubo_vs_c));
+ checkGLcall("glBindBuffer (UBO)");
+ GL_EXTCALL(glBindBufferBase(GL_UNIFORM_BUFFER, base + count + 1, priv->ubo_vs_c));
+ checkGLcall("glBindBufferBase");
+ }
+ }
+ else if (!priv->consts_ubo)
+ {
+ for (i = 0; i < vs_c_count; ++i)
+ {
+ string_buffer_sprintf(name, "vs_c[%u]", i);
+ vs->uniform_f_locations[i] = GL_EXTCALL(glGetUniformLocation(program_id, name->buffer));
+ }
+ memset(&vs->uniform_f_locations[vs_c_count], 0xff, (WINED3D_MAX_VS_CONSTS_F - vs_c_count) * sizeof(GLuint));
}
- memset(&vs->uniform_f_locations[vs_c_count], 0xff, (WINED3D_MAX_VS_CONSTS_F - vs_c_count) * sizeof(GLuint));
for (i = 0; i < WINED3D_MAX_CONSTS_I; ++i)
{
@@ -11191,6 +11272,7 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
if (!(priv = heap_alloc_zero(sizeof(*priv))))
return E_OUTOFMEMORY;
+ priv->consts_ubo = gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT];
string_buffer_list_init(&priv->string_buffers);
if (!(vertex_priv = vertex_pipe->vp_alloc(&glsl_shader_backend, priv)))
@@ -11245,6 +11327,8 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
device->fragment_priv = fragment_priv;
device->shader_priv = priv;
+ priv->ubo_vs_c = -1;
+
return WINED3D_OK;
fail:
@@ -11272,6 +11356,13 @@ static void shader_glsl_free(struct wined3d_device *device)
priv->fragment_pipe->free_private(device);
priv->vertex_pipe->vp_free(device);
+ if (priv->ubo_vs_c != -1)
+ {
+ const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
+ GL_EXTCALL(glDeleteBuffers(1, &priv->ubo_vs_c));
+ checkGLcall("glDeleteBuffers");
+ priv->ubo_vs_c = -1;
+ }
heap_free(device->shader_priv);
device->shader_priv = NULL;
}
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index 2db4a3cbc2..e34b6548cd 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -764,6 +764,8 @@ static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct w
}
else
{
+ if (reg->idx[0].offset >= reg_maps->constant_float_count)
+ reg_maps->constant_float_count = reg->idx[0].offset + 1;
wined3d_insert_bits(reg_maps->constf, reg->idx[0].offset, 1, 0x1);
}
}
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index d77cb1ce11..104e276585 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -6462,6 +6462,11 @@ void wined3d_gl_limits_get_uniform_block_range(const struct wined3d_gl_limits *g
if (i == shader_type)
return;
*base += *count;
+ if (i == WINED3D_SHADER_TYPE_VERTEX)
+ {
+ /* Reserve binding location for vs_c UBO. */
+ ++*base;
+ }
}
ERR("Unrecognized shader type %#x.\n", shader_type);
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index f23b84a6f4..b9ec04080d 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -1042,6 +1042,7 @@ struct wined3d_shader_reg_maps
struct wined3d_shader_tgsm *tgsm;
SIZE_T tgsm_capacity;
unsigned int tgsm_count;
+ UINT constant_float_count;
};
/* Keeps track of details for TEX_M#x# instructions which need to maintain
@@ -2580,6 +2581,7 @@ struct wined3d_gl_limits
UINT glsl_varyings;
UINT glsl_vs_float_constants;
UINT glsl_ps_float_constants;
+ UINT glsl_max_uniform_block_size;
UINT arb_vs_float_constants;
UINT arb_vs_native_constants;
--
2.20.1

145
patches/wined3d-SWVP-shaders/0002-d3d9-Support-SWVP-vertex-shader-float-constants-limi.patch Normal file
View File

@ -0,0 +1,145 @@
From b6f4150aa69d697f08abcf82ee59ffadb2fa6ad2 Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Mon, 25 Feb 2019 14:24:50 +0300
Subject: [PATCH 2/5] d3d9: Support SWVP vertex shader float constants limits.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/d3d9/d3d9_private.h | 3 ++-
dlls/d3d9/device.c | 32 +++++++++++++++++++++++++-------
dlls/d3d9/directx.c | 2 +-
3 files changed, 28 insertions(+), 9 deletions(-)
diff --git a/dlls/d3d9/d3d9_private.h b/dlls/d3d9/d3d9_private.h
index 3fe0376e5c..300bee73c7 100644
--- a/dlls/d3d9/d3d9_private.h
+++ b/dlls/d3d9/d3d9_private.h
@@ -41,6 +41,7 @@
#include "wine/wined3d.h"
#define D3D9_MAX_VERTEX_SHADER_CONSTANTF 256
+#define D3D9_MAX_VERTEX_SHADER_CONSTANTF_SWVP 8192
#define D3D9_MAX_TEXTURE_UNITS 20
#define D3D9_MAX_STREAMS 16
@@ -57,7 +58,7 @@ enum wined3d_format_id wined3dformat_from_d3dformat(D3DFORMAT format) DECLSPEC_H
unsigned int wined3dmapflags_from_d3dmapflags(unsigned int flags, unsigned int usage) DECLSPEC_HIDDEN;
void present_parameters_from_wined3d_swapchain_desc(D3DPRESENT_PARAMETERS *present_parameters,
const struct wined3d_swapchain_desc *swapchain_desc, DWORD presentation_interval) DECLSPEC_HIDDEN;
-void d3dcaps_from_wined3dcaps(D3DCAPS9 *caps, const struct wined3d_caps *wined3d_caps) DECLSPEC_HIDDEN;
+void d3dcaps_from_wined3dcaps(D3DCAPS9 *caps, const struct wined3d_caps *wined3d_caps, DWORD flags) DECLSPEC_HIDDEN;
struct d3d9
{
diff --git a/dlls/d3d9/device.c b/dlls/d3d9/device.c
index 6cc3f180b0..03d2faf61a 100644
--- a/dlls/d3d9/device.c
+++ b/dlls/d3d9/device.c
@@ -362,7 +362,7 @@ static BOOL wined3d_swapchain_desc_from_present_parameters(struct wined3d_swapch
return TRUE;
}
-void d3dcaps_from_wined3dcaps(D3DCAPS9 *caps, const struct wined3d_caps *wined3d_caps)
+void d3dcaps_from_wined3dcaps(D3DCAPS9 *caps, const struct wined3d_caps *wined3d_caps, DWORD creation_flags)
{
static const DWORD ps_minor_version[] = {0, 4, 0, 0};
static const DWORD vs_minor_version[] = {0, 1, 0, 0};
@@ -500,7 +500,10 @@ void d3dcaps_from_wined3dcaps(D3DCAPS9 *caps, const struct wined3d_caps *wined3d
D3DPTEXTURECAPS_MIPMAP | D3DPTEXTURECAPS_MIPVOLUMEMAP | D3DPTEXTURECAPS_MIPCUBEMAP |
D3DPTEXTURECAPS_CUBEMAP_POW2 | D3DPTEXTURECAPS_VOLUMEMAP_POW2| D3DPTEXTURECAPS_NOPROJECTEDBUMPENV;
- caps->MaxVertexShaderConst = min(D3D9_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);
+ if (creation_flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING)
+ caps->MaxVertexShaderConst = min(D3D9_MAX_VERTEX_SHADER_CONSTANTF_SWVP, caps->MaxVertexShaderConst);
+ else
+ caps->MaxVertexShaderConst = min(D3D9_MAX_VERTEX_SHADER_CONSTANTF, caps->MaxVertexShaderConst);
caps->NumSimultaneousRTs = min(D3D_MAX_SIMULTANEOUS_RENDERTARGETS, caps->NumSimultaneousRTs);
if (caps->PixelShaderVersion > 3)
@@ -679,6 +682,7 @@ static HRESULT WINAPI d3d9_device_GetDirect3D(IDirect3DDevice9Ex *iface, IDirect
static HRESULT WINAPI d3d9_device_GetDeviceCaps(IDirect3DDevice9Ex *iface, D3DCAPS9 *caps)
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
+ struct wined3d_device_creation_parameters creation_parameters;
struct wined3d_caps wined3d_caps;
HRESULT hr;
@@ -687,13 +691,15 @@ static HRESULT WINAPI d3d9_device_GetDeviceCaps(IDirect3DDevice9Ex *iface, D3DCA
if (!caps)
return D3DERR_INVALIDCALL;
+ wined3d_device_get_creation_parameters(device->wined3d_device, &creation_parameters);
+
memset(caps, 0, sizeof(*caps));
wined3d_mutex_lock();
hr = wined3d_device_get_device_caps(device->wined3d_device, &wined3d_caps);
wined3d_mutex_unlock();
- d3dcaps_from_wined3dcaps(caps, &wined3d_caps);
+ d3dcaps_from_wined3dcaps(caps, &wined3d_caps, creation_parameters.flags);
return hr;
}
@@ -3418,14 +3424,20 @@ static HRESULT WINAPI d3d9_device_SetVertexShaderConstantF(IDirect3DDevice9Ex *i
UINT reg_idx, const float *data, UINT count)
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
+ struct wined3d_device_creation_parameters creation_parameters;
+ unsigned int max_constants;
HRESULT hr;
TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count);
- if (reg_idx + count > D3D9_MAX_VERTEX_SHADER_CONSTANTF)
+ wined3d_device_get_creation_parameters(device->wined3d_device, &creation_parameters);
+ max_constants = creation_parameters.flags
+ & (WINED3DCREATE_SOFTWARE_VERTEXPROCESSING | WINED3DCREATE_MIXED_VERTEXPROCESSING)
+ ? D3D9_MAX_VERTEX_SHADER_CONSTANTF_SWVP : D3D9_MAX_VERTEX_SHADER_CONSTANTF;
+ if (reg_idx + count > max_constants)
{
WARN("Trying to access %u constants, but d3d9 only supports %u\n",
- reg_idx + count, D3D9_MAX_VERTEX_SHADER_CONSTANTF);
+ reg_idx + count, max_constants);
return D3DERR_INVALIDCALL;
}
@@ -3441,14 +3453,20 @@ static HRESULT WINAPI d3d9_device_GetVertexShaderConstantF(IDirect3DDevice9Ex *i
UINT reg_idx, float *data, UINT count)
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
+ struct wined3d_device_creation_parameters creation_parameters;
+ unsigned int max_constants;
HRESULT hr;
TRACE("iface %p, reg_idx %u, data %p, count %u.\n", iface, reg_idx, data, count);
- if (reg_idx + count > D3D9_MAX_VERTEX_SHADER_CONSTANTF)
+ wined3d_device_get_creation_parameters(device->wined3d_device, &creation_parameters);
+ max_constants = creation_parameters.flags
+ & (WINED3DCREATE_SOFTWARE_VERTEXPROCESSING | WINED3DCREATE_MIXED_VERTEXPROCESSING)
+ ? D3D9_MAX_VERTEX_SHADER_CONSTANTF_SWVP : D3D9_MAX_VERTEX_SHADER_CONSTANTF;
+ if (reg_idx + count > max_constants)
{
WARN("Trying to access %u constants, but d3d9 only supports %u\n",
- reg_idx + count, D3D9_MAX_VERTEX_SHADER_CONSTANTF);
+ reg_idx + count, max_constants);
return D3DERR_INVALIDCALL;
}
diff --git a/dlls/d3d9/directx.c b/dlls/d3d9/directx.c
index eab114d19c..7c4defa169 100644
--- a/dlls/d3d9/directx.c
+++ b/dlls/d3d9/directx.c
@@ -371,7 +371,7 @@ static HRESULT WINAPI d3d9_GetDeviceCaps(IDirect3D9Ex *iface, UINT adapter, D3DD
hr = wined3d_get_device_caps(d3d9->wined3d, adapter, device_type, &wined3d_caps);
wined3d_mutex_unlock();
- d3dcaps_from_wined3dcaps(caps, &wined3d_caps);
+ d3dcaps_from_wined3dcaps(caps, &wined3d_caps, 0);
return hr;
}
--
2.20.1

94
patches/wined3d-SWVP-shaders/0003-wined3d-Report-actual-vertex-shader-float-constants-.patch Normal file
View File

@ -0,0 +1,94 @@
From c028015c9ec3bcbeac6a57315f81e61f5b56a196 Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Mon, 25 Feb 2019 14:47:28 +0300
Subject: [PATCH 3/5] wined3d: Report actual vertex shader float constants
limit for SWVP device.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/wined3d/adapter_gl.c | 3 ++-
dlls/wined3d/device.c | 13 ++++++++++++-
dlls/wined3d/glsl_shader.c | 5 ++++-
dlls/wined3d/wined3d_private.h | 2 ++
4 files changed, 20 insertions(+), 3 deletions(-)
diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c
index 493bca5d90..1b386a7b8e 100644
--- a/dlls/wined3d/adapter_gl.c
+++ b/dlls/wined3d/adapter_gl.c
@@ -3731,7 +3731,8 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter,
d3d_info->limits.gs_version = shader_caps.gs_version;
d3d_info->limits.ps_version = shader_caps.ps_version;
d3d_info->limits.cs_version = shader_caps.cs_version;
- d3d_info->limits.vs_uniform_count = shader_caps.vs_uniform_count;
+ d3d_info->limits.vs_uniform_count_swvp = shader_caps.vs_uniform_count;
+ d3d_info->limits.vs_uniform_count = min(WINED3D_MAX_VS_CONSTS_F, shader_caps.vs_uniform_count);
d3d_info->limits.ps_uniform_count = shader_caps.ps_uniform_count;
d3d_info->limits.varying_count = shader_caps.varying_count;
d3d_info->shader_double_precision = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION);
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index af73751dbf..0be43d4551 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -3623,10 +3623,21 @@ struct wined3d_texture * CDECL wined3d_device_get_texture(const struct wined3d_d
HRESULT CDECL wined3d_device_get_device_caps(const struct wined3d_device *device, struct wined3d_caps *caps)
{
+ const struct wined3d_adapter *adapter = &device->wined3d->adapters[device->adapter->ordinal];
+ struct wined3d_vertex_caps vertex_caps;
+ HRESULT hr;
+
TRACE("device %p, caps %p.\n", device, caps);
- return wined3d_get_device_caps(device->wined3d, device->adapter->ordinal,
+ hr = wined3d_get_device_caps(device->wined3d, device->adapter->ordinal,
device->create_parms.device_type, caps);
+ if (FAILED(hr))
+ return hr;
+
+ adapter->vertex_pipe->vp_get_caps(&adapter->gl_info, &vertex_caps);
+ if (device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING)
+ caps->MaxVertexShaderConst = adapter->d3d_info.limits.vs_uniform_count_swvp;
+ return hr;
}
HRESULT CDECL wined3d_device_get_display_mode(const struct wined3d_device *device, UINT swapchain_idx,
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 625997470f..a1e75bf4d4 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -11438,7 +11438,10 @@ static void shader_glsl_get_caps(const struct wined3d_gl_info *gl_info, struct s
caps->vs_version = gl_info->supported[ARB_VERTEX_SHADER] ? caps->vs_version : 0;
caps->ps_version = gl_info->supported[ARB_FRAGMENT_SHADER] ? caps->ps_version : 0;
- caps->vs_uniform_count = min(WINED3D_MAX_VS_CONSTS_F, gl_info->limits.glsl_vs_float_constants);
+ caps->vs_uniform_count = min(WINED3D_MAX_VS_CONSTS_F_SWVP,
+ gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT]
+ ? gl_info->limits.glsl_max_uniform_block_size / sizeof(struct wined3d_vec4)
+ : gl_info->limits.glsl_vs_float_constants);
caps->ps_uniform_count = min(WINED3D_MAX_PS_CONSTS_F, gl_info->limits.glsl_ps_float_constants);
caps->varying_count = gl_info->limits.glsl_varyings;
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index b9ec04080d..7100816279 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -163,6 +163,7 @@ struct wined3d_d3d_limits
{
unsigned int vs_version, hs_version, ds_version, gs_version, ps_version, cs_version;
DWORD vs_uniform_count;
+ DWORD vs_uniform_count_swvp;
DWORD ps_uniform_count;
unsigned int varying_count;
unsigned int ffp_textures;
@@ -672,6 +673,7 @@ enum wined3d_shader_conditional_op
#define WINED3D_MAX_CONSTS_B 16
#define WINED3D_MAX_CONSTS_I 16
#define WINED3D_MAX_VS_CONSTS_F 256
+#define WINED3D_MAX_VS_CONSTS_F_SWVP 8192
#define WINED3D_MAX_PS_CONSTS_F 224
/* FIXME: This needs to go up to 2048 for
--
2.20.1

191
patches/wined3d-SWVP-shaders/0004-wined3d-Support-SWVP-vertex-shader-constants-limit-i.patch Normal file
View File

@ -0,0 +1,191 @@
From 991225512f6251e7567d510028c69344811e7544 Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Mon, 25 Feb 2019 15:05:12 +0300
Subject: [PATCH 4/5] wined3d: Support SWVP vertex shader constants limit in
state tracking.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/d3d9/tests/device.c | 5 -----
dlls/d3d9/tests/visual.c | 1 -
dlls/wined3d/device.c | 15 +++++++++++----
dlls/wined3d/glsl_shader.c | 2 +-
dlls/wined3d/stateblock.c | 6 +++---
dlls/wined3d/wined3d_private.h | 8 ++++----
6 files changed, 19 insertions(+), 18 deletions(-)
diff --git a/dlls/d3d9/tests/device.c b/dlls/d3d9/tests/device.c
index 030b34c4e4..5f7944b93a 100644
--- a/dlls/d3d9/tests/device.c
+++ b/dlls/d3d9/tests/device.c
@@ -6425,13 +6425,10 @@ static void test_vertex_shader_constant(void)
ok(consts_swvp == 8192, "Unexpected consts_swvp %u.\n", consts_swvp);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts + 0, c, 1);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts + 1, c, 1);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts - 1, d, 4);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts_swvp - 1, c, 1);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
@@ -6456,7 +6453,6 @@ static void test_vertex_shader_constant(void)
IDirect3DDevice9_SetSoftwareVertexProcessing(device, 0);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts + 0, c, 1);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts_swvp - 1, c, 1);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
@@ -6464,7 +6460,6 @@ static void test_vertex_shader_constant(void)
IDirect3DDevice9_SetSoftwareVertexProcessing(device, 1);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts + 0, c, 1);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, consts_swvp - 1, c, 1);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index e8279213d0..26085440fd 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -23948,7 +23948,6 @@ static void test_mvp_software_vertex_shaders(void)
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, c_index, 1);
ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShaderConstantF(device, (unsigned int)c_index[0], c_color, 1);
- todo_wine
ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_BeginScene(device);
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 0be43d4551..ff0cb61f08 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -2557,13 +2557,17 @@ HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
{
const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
+ unsigned int constants_count;
unsigned int i;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- if (!constants || start_idx >= d3d_info->limits.vs_uniform_count
- || count > d3d_info->limits.vs_uniform_count - start_idx)
+ constants_count = device->create_parms.flags
+ & (WINED3DCREATE_SOFTWARE_VERTEXPROCESSING | WINED3DCREATE_MIXED_VERTEXPROCESSING)
+ ? d3d_info->limits.vs_uniform_count_swvp : d3d_info->limits.vs_uniform_count;
+ if (!constants || start_idx >= constants_count
+ || count > constants_count - start_idx)
return WINED3DERR_INVALIDCALL;
memcpy(&device->update_stateblock_state->vs_consts_f[start_idx], constants, count * sizeof(*constants));
@@ -2590,12 +2594,15 @@ HRESULT CDECL wined3d_device_get_vs_consts_f(const struct wined3d_device *device
unsigned int start_idx, unsigned int count, struct wined3d_vec4 *constants)
{
const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
+ unsigned int constants_count;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
- if (!constants || start_idx >= d3d_info->limits.vs_uniform_count
- || count > d3d_info->limits.vs_uniform_count - start_idx)
+ constants_count = device->create_parms.flags & WINED3DCREATE_HARDWARE_VERTEXPROCESSING
+ ? d3d_info->limits.vs_uniform_count : d3d_info->limits.vs_uniform_count_swvp;
+ if (!constants || start_idx >= constants_count
+ || count > constants_count - start_idx)
return WINED3DERR_INVALIDCALL;
memcpy(constants, &device->state.vs_consts_f[start_idx], count * sizeof(*constants));
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index a1e75bf4d4..8fdab07ab0 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -2137,7 +2137,7 @@ static void shader_glsl_update_float_vertex_constants(struct wined3d_device *dev
if (priv->consts_ubo)
return;
- for (i = start; i < count + start; ++i)
+ for (i = start; i < min(WINED3D_MAX_VS_CONSTS_F, count + start); ++i)
{
update_heap_entry(heap, i, priv->next_constant_version);
}
diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c
index 820089d0b8..cd5c8bd5dc 100644
--- a/dlls/wined3d/stateblock.c
+++ b/dlls/wined3d/stateblock.c
@@ -316,7 +316,7 @@ void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
}
}
- for (i = 0; i < d3d_info->limits.vs_uniform_count; ++i)
+ for (i = 0; i < d3d_info->limits.vs_uniform_count_swvp; ++i)
{
if (stateblock->changed.vs_consts_f[i])
{
@@ -1572,7 +1572,7 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock,
stateblock_init_lights(stateblock->stateblock_state.light_state.light_map,
device->stateblock_state.light_state.light_map);
stateblock_savedstates_set_all(&stateblock->changed,
- d3d_info->limits.vs_uniform_count, d3d_info->limits.ps_uniform_count);
+ d3d_info->limits.vs_uniform_count_swvp, d3d_info->limits.ps_uniform_count);
break;
case WINED3D_SBT_PIXEL_STATE:
@@ -1584,7 +1584,7 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock,
stateblock_init_lights(stateblock->stateblock_state.light_state.light_map,
device->stateblock_state.light_state.light_map);
stateblock_savedstates_set_vertex(&stateblock->changed,
- d3d_info->limits.vs_uniform_count);
+ d3d_info->limits.vs_uniform_count_swvp);
break;
default:
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 7100816279..51214d89dc 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -2937,7 +2937,7 @@ struct wined3d_state
BOOL vs_consts_b[WINED3D_MAX_CONSTS_B];
struct wined3d_ivec4 vs_consts_i[WINED3D_MAX_CONSTS_I];
- struct wined3d_vec4 vs_consts_f[WINED3D_MAX_VS_CONSTS_F];
+ struct wined3d_vec4 vs_consts_f[WINED3D_MAX_VS_CONSTS_F_SWVP];
BOOL ps_consts_b[WINED3D_MAX_CONSTS_B];
struct wined3d_ivec4 ps_consts_i[WINED3D_MAX_CONSTS_I];
@@ -3009,7 +3009,7 @@ struct wined3d_stateblock_state
int base_vertex_index;
struct wined3d_shader *vs;
- struct wined3d_vec4 vs_consts_f[WINED3D_MAX_VS_CONSTS_F];
+ struct wined3d_vec4 vs_consts_f[WINED3D_MAX_VS_CONSTS_F_SWVP];
struct wined3d_ivec4 vs_consts_i[WINED3D_MAX_CONSTS_I];
BOOL vs_consts_b[WINED3D_MAX_CONSTS_B];
@@ -3604,7 +3604,7 @@ struct wined3d_saved_states
BOOL ps_consts_f[WINED3D_MAX_PS_CONSTS_F];
WORD vertexShaderConstantsB; /* WINED3D_MAX_CONSTS_B, 16 */
WORD vertexShaderConstantsI; /* WINED3D_MAX_CONSTS_I, 16 */
- BOOL vs_consts_f[WINED3D_MAX_VS_CONSTS_F];
+ BOOL vs_consts_f[WINED3D_MAX_VS_CONSTS_F_SWVP];
DWORD textures : 20; /* WINED3D_MAX_COMBINED_SAMPLERS, 20 */
DWORD indices : 1;
DWORD material : 1;
@@ -3640,7 +3640,7 @@ struct wined3d_stateblock
unsigned int num_contained_vs_consts_i;
DWORD contained_vs_consts_b[WINED3D_MAX_CONSTS_B];
unsigned int num_contained_vs_consts_b;
- DWORD contained_vs_consts_f[WINED3D_MAX_VS_CONSTS_F];
+ DWORD contained_vs_consts_f[WINED3D_MAX_VS_CONSTS_F_SWVP];
unsigned int num_contained_vs_consts_f;
DWORD contained_ps_consts_i[WINED3D_MAX_CONSTS_I];
unsigned int num_contained_ps_consts_i;
--
2.20.1

492
patches/wined3d-SWVP-shaders/0005-wined3d-Support-SWVP-mode-vertex-shaders.patch Normal file
View File

@ -0,0 +1,492 @@
From dd16fac7bbbc3a9197d1866e59d945a1552cc654 Mon Sep 17 00:00:00 2001
From: Paul Gofman <gofmanp@gmail.com>
Date: Mon, 25 Feb 2019 15:23:33 +0300
Subject: [PATCH 5/5] wined3d: Support SWVP mode vertex shaders.
Signed-off-by: Paul Gofman <gofmanp@gmail.com>
---
dlls/d3d9/tests/device.c | 16 ++------
dlls/d3d9/tests/visual.c | 5 +--
dlls/wined3d/device.c | 8 ++++
dlls/wined3d/glsl_shader.c | 69 +++++++++++++++++++++++++---------
dlls/wined3d/shader.c | 44 +++++++++++++++-------
dlls/wined3d/shader_sm1.c | 2 +-
dlls/wined3d/wined3d_private.h | 7 ++++
7 files changed, 103 insertions(+), 48 deletions(-)
diff --git a/dlls/d3d9/tests/device.c b/dlls/d3d9/tests/device.c
index 5f7944b93a..cef0759610 100644
--- a/dlls/d3d9/tests/device.c
+++ b/dlls/d3d9/tests/device.c
@@ -6913,15 +6913,11 @@ float4 main(const float4 color : COLOR) : SV_TARGET
vs = NULL;
hr = IDirect3DDevice9_CreateVertexShader(device, vs_1_256, &vs);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
- if (vs)
- IDirect3DVertexShader9_Release(vs);
+ IDirect3DVertexShader9_Release(vs);
hr = IDirect3DDevice9_CreateVertexShader(device, vs_3_256, &vs);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
- if (vs)
- IDirect3DVertexShader9_Release(vs);
+ IDirect3DVertexShader9_Release(vs);
refcount = IDirect3DDevice9_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
@@ -6938,20 +6934,16 @@ float4 main(const float4 color : COLOR) : SV_TARGET
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_CreateVertexShader(device, vs_1_256, &vs);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShader(device, vs);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
- if (vs)
- IDirect3DVertexShader9_Release(vs);
+ IDirect3DVertexShader9_Release(vs);
hr = IDirect3DDevice9_CreateVertexShader(device, vs_3_256, &vs);
- todo_wine
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_SetVertexShader(device, vs);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
- if (vs)
- IDirect3DVertexShader9_Release(vs);
+ IDirect3DVertexShader9_Release(vs);
cleanup:
refcount = IDirect3DDevice9_Release(device);
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
index 26085440fd..67e1133c51 100644
--- a/dlls/d3d9/tests/visual.c
+++ b/dlls/d3d9/tests/visual.c
@@ -23874,7 +23874,6 @@ static void test_mvp_software_vertex_shaders(void)
hr = IDirect3DDevice9_CreateVertexShader(device, reladdr_shader_code, &reladdr_shader);
ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_CreateVertexShader(device, pure_sw_shader_code, &pure_sw_shader);
- todo_wine
ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
@@ -23912,7 +23911,7 @@ static void test_mvp_software_vertex_shaders(void)
expected_color = 0x00ff0000; /* Color from vertex data and not from the shader. */
color = getPixelColor(device, 5, 5);
- ok(color == expected_color, "Expected color 0x%08x, got 0x%08x (sw shader in hw mode, second attempt).\n",
+ todo_wine ok(color == expected_color, "Expected color 0x%08x, got 0x%08x (sw shader in hw mode, second attempt).\n",
expected_color, color);
hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
@@ -23931,7 +23930,6 @@ static void test_mvp_software_vertex_shaders(void)
expected_color = 0x00ffffff;
color = getPixelColor(device, 5, 5);
- todo_wine
ok(color == expected_color, "Expected color 0x%08x, got 0x%08x (sw shader in sw mode).\n",
expected_color, color);
@@ -23981,7 +23979,6 @@ static void test_mvp_software_vertex_shaders(void)
expected_color = 0x0000ffff; /* c[256] is c_color for SW shader. */
color = getPixelColor(device, 5, 5);
- todo_wine
ok(color == expected_color, "Expected color 0x%08x, got 0x%08x (shader in sw mode).\n",
expected_color, color);
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index ff0cb61f08..307993286c 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -4079,6 +4079,14 @@ void CDECL wined3d_device_set_software_vertex_processing(struct wined3d_device *
warned = TRUE;
}
+ wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
+ if (!device->softwareVertexProcessing != !software)
+ {
+ unsigned int i;
+
+ for (i = 0; i < device->context_count; ++i)
+ device->contexts[i]->constant_update_mask |= WINED3D_SHADER_CONST_VS_F;
+ }
device->softwareVertexProcessing = software;
}
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 8fdab07ab0..b7ccfc633e 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -140,7 +140,9 @@ struct shader_glsl_priv
BOOL consts_ubo;
GLuint ubo_vs_c;
- struct wined3d_vec4 vs_c_buffer[WINED3D_MAX_VS_CONSTS_F];
+ BOOL prev_device_swvp;
+ struct wined3d_vec4 vs_c_buffer[WINED3D_MAX_VS_CONSTS_F_SWVP];
+ unsigned int max_vs_consts_f;
const struct wined3d_vertex_pipe_ops *vertex_pipe;
const struct fragment_pipeline *fragment_pipe;
@@ -155,7 +157,7 @@ struct glsl_vs_program
struct list shader_entry;
GLuint id;
GLenum vertex_color_clamp;
- GLint uniform_f_locations[WINED3D_MAX_VS_CONSTS_F];
+ GLint uniform_f_locations[WINED3D_MAX_VS_CONSTS_F_SWVP];
GLint uniform_i_locations[WINED3D_MAX_CONSTS_I];
GLint uniform_b_locations[WINED3D_MAX_CONSTS_B];
GLint pos_fixup_location;
@@ -1154,7 +1156,7 @@ static void bind_and_orphan_consts_ubo(const struct wined3d_gl_info *gl_info, st
{
GL_EXTCALL(glBindBuffer(GL_UNIFORM_BUFFER, priv->ubo_vs_c));
checkGLcall("glBindBuffer");
- GL_EXTCALL(glBufferData(GL_UNIFORM_BUFFER, WINED3D_MAX_VS_CONSTS_F * sizeof(struct wined3d_vec4),
+ GL_EXTCALL(glBufferData(GL_UNIFORM_BUFFER, priv->max_vs_consts_f * sizeof(struct wined3d_vec4),
NULL, GL_STREAM_DRAW));
checkGLcall("glBufferData");
}
@@ -1162,33 +1164,45 @@ static void bind_and_orphan_consts_ubo(const struct wined3d_gl_info *gl_info, st
/* Context activation is done by the caller. */
static void shader_glsl_load_constants_f(const struct wined3d_shader *shader, const struct wined3d_gl_info *gl_info,
const struct wined3d_vec4 *constants, const GLint *constant_locations, const struct constant_heap *heap,
- unsigned char *stack, unsigned int version, struct shader_glsl_priv *priv)
+ unsigned char *stack, unsigned int version, struct shader_glsl_priv *priv, BOOL device_swvp)
{
const struct wined3d_shader_lconst *lconst;
BOOL is_vertex_shader = shader->reg_maps.shader_version.type == WINED3D_SHADER_TYPE_VERTEX;
if (is_vertex_shader && priv->consts_ubo)
{
+ BOOL zero_sw_constants = !device_swvp && priv->prev_device_swvp;
const struct wined3d_vec4 *data;
+ unsigned int const_count;
unsigned max_const_used;
bind_and_orphan_consts_ubo(gl_info, priv);
- max_const_used = shader->reg_maps.usesrelconstF
- ? WINED3D_MAX_VS_CONSTS_F : shader->reg_maps.constant_float_count;
- if (shader->load_local_constsF)
+ const_count = device_swvp ? priv->max_vs_consts_f : WINED3D_MAX_VS_CONSTS_F;
+ max_const_used = shader->reg_maps.usesrelconstF ? const_count : shader->reg_maps.constant_float_count;
+ if (shader->load_local_constsF || (zero_sw_constants && shader->reg_maps.usesrelconstF))
{
data = priv->vs_c_buffer;
memcpy(priv->vs_c_buffer, constants, max_const_used * sizeof(*constants));
- LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
+ if (zero_sw_constants)
{
- priv->vs_c_buffer[lconst->idx] = *(const struct wined3d_vec4 *)lconst->value;
+ memset(&priv->vs_c_buffer[const_count], 0, (priv->max_vs_consts_f - WINED3D_MAX_VS_CONSTS_F)
+ * sizeof(*constants));
+ priv->prev_device_swvp = FALSE;
+ }
+ if (shader->load_local_constsF)
+ {
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, struct wined3d_shader_lconst, entry)
+ {
+ priv->vs_c_buffer[lconst->idx] = *(const struct wined3d_vec4 *)lconst->value;
+ }
}
}
else
{
data = constants;
}
- GL_EXTCALL(glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(*constants) * max_const_used, data));
+ GL_EXTCALL(glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(*constants)
+ * (zero_sw_constants ? priv->max_vs_consts_f : max_const_used), data));
checkGLcall("glBufferSubData");
return;
}
@@ -1842,7 +1856,8 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
if (update_mask & WINED3D_SHADER_CONST_VS_F)
shader_glsl_load_constants_f(vshader, gl_info, state->vs_consts_f,
- prog->vs.uniform_f_locations, &priv->vconst_heap, priv->stack, constant_version, priv);
+ prog->vs.uniform_f_locations, &priv->vconst_heap, priv->stack,
+ constant_version, priv, device_is_swvp(context->device));
if (update_mask & WINED3D_SHADER_CONST_VS_I)
shader_glsl_load_constants_i(vshader, gl_info, state->vs_consts_i,
@@ -1995,7 +2010,8 @@ static void shader_glsl_load_constants(void *shader_priv, struct wined3d_context
if (update_mask & WINED3D_SHADER_CONST_PS_F)
shader_glsl_load_constants_f(pshader, gl_info, state->ps_consts_f,
- prog->ps.uniform_f_locations, &priv->pconst_heap, priv->stack, constant_version, priv);
+ prog->ps.uniform_f_locations, &priv->pconst_heap, priv->stack, constant_version,
+ priv, FALSE);
if (update_mask & WINED3D_SHADER_CONST_PS_I)
shader_glsl_load_constants_i(pshader, gl_info, state->ps_consts_i,
@@ -2137,7 +2153,7 @@ static void shader_glsl_update_float_vertex_constants(struct wined3d_device *dev
if (priv->consts_ubo)
return;
- for (i = start; i < min(WINED3D_MAX_VS_CONSTS_F, count + start); ++i)
+ for (i = start; i < count + start; ++i)
{
update_heap_entry(heap, i, priv->next_constant_version);
}
@@ -2476,7 +2492,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
shader_addline(buffer,"layout(std140) uniform vs_c_ubo\n"
"{ \n"
" vec4 %s_c[%u];\n"
- "};\n", prefix, min(shader->limits->constant_float, WINED3D_MAX_VS_CONSTS_F));
+ "};\n", prefix, min(shader->limits->constant_float, priv->max_vs_consts_f));
}
else if (shader->limits->constant_float > 0)
{
@@ -10186,12 +10202,13 @@ static void shader_glsl_init_vs_uniform_locations(const struct wined3d_gl_info *
}
else if (!priv->consts_ubo)
{
- for (i = 0; i < vs_c_count; ++i)
+ for (i = 0; i < min(vs_c_count, priv->max_vs_consts_f); ++i)
{
string_buffer_sprintf(name, "vs_c[%u]", i);
vs->uniform_f_locations[i] = GL_EXTCALL(glGetUniformLocation(program_id, name->buffer));
}
- memset(&vs->uniform_f_locations[vs_c_count], 0xff, (WINED3D_MAX_VS_CONSTS_F - vs_c_count) * sizeof(GLuint));
+ if (vs_c_count < priv->max_vs_consts_f)
+ memset(&vs->uniform_f_locations[vs_c_count], 0xff, (priv->max_vs_consts_f - vs_c_count) * sizeof(GLuint));
}
for (i = 0; i < WINED3D_MAX_CONSTS_I; ++i)
@@ -10510,6 +10527,10 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
vs_list = &ffp_shader->linked_programs;
}
+ if (vshader && vshader->reg_maps.constant_float_count > WINED3D_MAX_VS_CONSTS_F
+ && !device_is_swvp(context->device))
+ FIXME("Applying context with SW shader in HW mode.\n");
+
hshader = state->shader[WINED3D_SHADER_TYPE_HULL];
if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_HULL)) && ctx_data->glsl_program)
hs_id = ctx_data->glsl_program->hs.id;
@@ -11263,7 +11284,7 @@ static void constant_heap_free(struct constant_heap *heap)
static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
const struct fragment_pipeline *fragment_pipe)
{
- SIZE_T stack_size = wined3d_log2i(max(WINED3D_MAX_VS_CONSTS_F, WINED3D_MAX_PS_CONSTS_F)) + 1;
+ SIZE_T stack_size;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
struct fragment_caps fragment_caps;
void *vertex_priv, *fragment_priv;
@@ -11273,6 +11294,18 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
return E_OUTOFMEMORY;
priv->consts_ubo = gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT];
+ priv->max_vs_consts_f = priv->consts_ubo
+ ? gl_info->limits.glsl_max_uniform_block_size / sizeof(struct wined3d_vec4)
+ : gl_info->limits.glsl_vs_float_constants;
+
+ if (!(device->create_parms.flags & (WINED3DCREATE_SOFTWARE_VERTEXPROCESSING | WINED3DCREATE_MIXED_VERTEXPROCESSING)))
+ priv->max_vs_consts_f = min(priv->max_vs_consts_f, WINED3D_MAX_VS_CONSTS_F);
+
+ stack_size = priv->consts_ubo
+ ? wined3d_log2i(WINED3D_MAX_PS_CONSTS_F) + 1
+ : wined3d_log2i(max(priv->max_vs_consts_f, WINED3D_MAX_PS_CONSTS_F)) + 1;
+ TRACE("consts_ubo %#x, max_vs_consts_f %u.\n", priv->consts_ubo, priv->max_vs_consts_f);
+
string_buffer_list_init(&priv->string_buffers);
if (!(vertex_priv = vertex_pipe->vp_alloc(&glsl_shader_backend, priv)))
@@ -11302,7 +11335,7 @@ static HRESULT shader_glsl_alloc(struct wined3d_device *device, const struct win
goto fail;
}
- if (!constant_heap_init(&priv->vconst_heap, WINED3D_MAX_VS_CONSTS_F))
+ if (!priv->consts_ubo && !constant_heap_init(&priv->vconst_heap, priv->max_vs_consts_f))
{
ERR("Failed to initialize vertex shader constant heap\n");
goto fail;
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index e34b6548cd..965471e0e5 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -589,7 +589,7 @@ static void shader_delete_constant_list(struct list *clist)
list_init(clist);
}
-static void shader_set_limits(struct wined3d_shader *shader)
+static void shader_set_limits(struct wined3d_shader *shader, BOOL swvp)
{
static const struct limits_entry
{
@@ -612,6 +612,19 @@ static void shader_set_limits(struct wined3d_shader *shader)
{WINED3D_SHADER_VERSION(4, 1), WINED3D_SHADER_VERSION(5, 0), {16, 0, 0, 0, 32, 0}},
{0}
},
+ vs_limits_swvp[] =
+ {
+ /* 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, 8192, 0, 12, 0}},
+ {WINED3D_SHADER_VERSION(2, 0), WINED3D_SHADER_VERSION(2, 255), { 0, 16, 8192, 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, 255), { 4, 16, 8192, 16, 12, 0}},
+ {0}
+ },
hs_limits[] =
{
/* min_version, max_version, sampler, constant_int, constant_float, constant_bool, packed_output, packet_input */
@@ -656,7 +669,7 @@ static void shader_set_limits(struct wined3d_shader *shader)
FIXME("Unexpected shader type %u found.\n", shader->reg_maps.shader_version.type);
/* Fall-through. */
case WINED3D_SHADER_TYPE_VERTEX:
- limits_array = vs_limits;
+ limits_array = swvp ? vs_limits_swvp : vs_limits;
break;
case WINED3D_SHADER_TYPE_HULL:
limits_array = hs_limits;
@@ -1024,7 +1037,7 @@ static HRESULT shader_scan_output_signature(struct wined3d_shader *shader)
}
/* Note that this does not count the loop register as an address register. */
-static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD constf_size)
+static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD constf_size, BOOL swvp)
{
struct wined3d_shader_signature_element input_signature_elements[max(MAX_ATTRIBS, MAX_REG_INPUT)];
struct wined3d_shader_signature_element output_signature_elements[MAX_REG_OUTPUT];
@@ -1050,7 +1063,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co
prev_ins = current_ins = ptr;
reg_maps->shader_version = shader_version;
- shader_set_limits(shader);
+ shader_set_limits(shader, swvp);
if (!(reg_maps->constf = heap_calloc(((min(shader->limits->constant_float, constf_size) + 31) / 32),
sizeof(*reg_maps->constf))))
@@ -3334,7 +3347,7 @@ static unsigned int shader_max_version_from_feature_level(enum wined3d_feature_l
}
static HRESULT shader_set_function(struct wined3d_shader *shader, struct wined3d_device *device,
- enum wined3d_shader_type type, unsigned int float_const_count)
+ enum wined3d_shader_type type, unsigned int float_const_count, BOOL swvp)
{
const struct wined3d_d3d_info *d3d_info = &shader->device->adapter->d3d_info;
struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
@@ -3359,7 +3372,7 @@ static HRESULT shader_set_function(struct wined3d_shader *shader, struct wined3d
shader_trace_init(fe, shader->frontend_data);
/* Second pass: figure out which registers are used, what the semantics are, etc. */
- if (FAILED(hr = shader_get_registers_used(shader, float_const_count)))
+ if (FAILED(hr = shader_get_registers_used(shader, float_const_count, swvp)))
return hr;
if (version->type != type)
@@ -3699,14 +3712,19 @@ static HRESULT vertex_shader_init(struct wined3d_shader *shader, struct wined3d_
const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
{
struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
+ unsigned int vs_uniform_count;
unsigned int i;
HRESULT hr;
+ BOOL swvp = device->create_parms.flags & (WINED3DCREATE_SOFTWARE_VERTEXPROCESSING
+ | WINED3DCREATE_MIXED_VERTEXPROCESSING);
if (FAILED(hr = shader_init(shader, device, desc, parent, parent_ops)))
return hr;
+ vs_uniform_count = swvp ? device->adapter->d3d_info.limits.vs_uniform_count_swvp
+ : device->adapter->d3d_info.limits.vs_uniform_count;
if (FAILED(hr = shader_set_function(shader, device,
- WINED3D_SHADER_TYPE_VERTEX, device->adapter->d3d_info.limits.vs_uniform_count)))
+ WINED3D_SHADER_TYPE_VERTEX, vs_uniform_count, swvp)))
{
shader_cleanup(shader);
return hr;
@@ -3810,7 +3828,7 @@ static HRESULT geometry_shader_init_stream_output(struct wined3d_shader *shader,
{
shader->reg_maps.shader_version = shader_version;
shader->reg_maps.shader_version.type = WINED3D_SHADER_TYPE_GEOMETRY;
- shader_set_limits(shader);
+ shader_set_limits(shader, 0);
if (FAILED(hr = shader_scan_output_signature(shader)))
return hr;
}
@@ -3863,7 +3881,7 @@ static HRESULT geometry_shader_init(struct wined3d_shader *shader, struct wined3
goto fail;
if (shader->function
- && FAILED(hr = shader_set_function(shader, device, WINED3D_SHADER_TYPE_GEOMETRY, 0)))
+ && FAILED(hr = shader_set_function(shader, device, WINED3D_SHADER_TYPE_GEOMETRY, 0, 0)))
goto fail;
return WINED3D_OK;
@@ -4164,7 +4182,7 @@ static HRESULT pixel_shader_init(struct wined3d_shader *shader, struct wined3d_d
return hr;
if (FAILED(hr = shader_set_function(shader, device,
- WINED3D_SHADER_TYPE_PIXEL, device->adapter->d3d_info.limits.ps_uniform_count)))
+ WINED3D_SHADER_TYPE_PIXEL, device->adapter->d3d_info.limits.ps_uniform_count, 0)))
{
shader_cleanup(shader);
return hr;
@@ -4264,7 +4282,7 @@ HRESULT CDECL wined3d_shader_create_cs(struct wined3d_device *device, const stru
return hr;
}
- if (FAILED(hr = shader_set_function(object, device, WINED3D_SHADER_TYPE_COMPUTE, 0)))
+ if (FAILED(hr = shader_set_function(object, device, WINED3D_SHADER_TYPE_COMPUTE, 0, 0)))
{
shader_cleanup(object);
heap_free(object);
@@ -4298,7 +4316,7 @@ HRESULT CDECL wined3d_shader_create_ds(struct wined3d_device *device, const stru
return hr;
}
- if (FAILED(hr = shader_set_function(object, device, WINED3D_SHADER_TYPE_DOMAIN, 0)))
+ if (FAILED(hr = shader_set_function(object, device, WINED3D_SHADER_TYPE_DOMAIN, 0, 0)))
{
shader_cleanup(object);
heap_free(object);
@@ -4360,7 +4378,7 @@ HRESULT CDECL wined3d_shader_create_hs(struct wined3d_device *device, const stru
return hr;
}
- if (FAILED(hr = shader_set_function(object, device, WINED3D_SHADER_TYPE_HULL, 0)))
+ if (FAILED(hr = shader_set_function(object, device, WINED3D_SHADER_TYPE_HULL, 0, 0)))
{
shader_cleanup(object);
heap_free(object);
diff --git a/dlls/wined3d/shader_sm1.c b/dlls/wined3d/shader_sm1.c
index 0c6bb93317..1051307e88 100644
--- a/dlls/wined3d/shader_sm1.c
+++ b/dlls/wined3d/shader_sm1.c
@@ -543,7 +543,7 @@ static void *shader_sm1_init(const DWORD *byte_code, size_t byte_code_size,
major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
minor = WINED3D_SM1_VERSION_MINOR(*byte_code);
- if (WINED3D_SHADER_VERSION(major, minor) > WINED3D_SHADER_VERSION(3, 0))
+ if (WINED3D_SHADER_VERSION(major, minor) > WINED3D_SHADER_VERSION(3, 255))
{
WARN("Invalid shader version %u.%u (%#x).\n", major, minor, *byte_code);
return NULL;
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 51214d89dc..7014e6760d 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -4415,6 +4415,13 @@ static inline BOOL shader_constant_is_local(const struct wined3d_shader *shader,
return FALSE;
}
+static inline BOOL device_is_swvp(const struct wined3d_device *device)
+{
+ return (device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING)
+ || ((device->create_parms.flags & WINED3DCREATE_MIXED_VERTEXPROCESSING)
+ && device->softwareVertexProcessing);
+}
+
void get_identity_matrix(struct wined3d_matrix *mat) DECLSPEC_HIDDEN;
void get_modelview_matrix(const struct wined3d_context *context, const struct wined3d_state *state,
unsigned int index, struct wined3d_matrix *mat) DECLSPEC_HIDDEN;
--
2.20.1

2
patches/wined3d-SWVP-shaders/definition Normal file
View File

@ -0,0 +1,2 @@
Fixes: [8051] Sims 2 demo exits prematurely
Depends: wined3d-WINED3D_RS_COLORWRITEENABLE