[PATCH 4/7] wined3d: Move shader limits to wined3d_d3d_info
Stefan Dösinger
stefan at codeweavers.com
Thu Apr 25 08:20:27 CDT 2013
---
dlls/wined3d/arb_program_shader.c | 18 ++++++++++--------
dlls/wined3d/device.c | 23 ++++++++++-------------
dlls/wined3d/directx.c | 5 +++++
dlls/wined3d/shader.c | 22 +++++++++++++---------
dlls/wined3d/stateblock.c | 36 ++++++++++++++++++++----------------
dlls/wined3d/wined3d_private.h | 10 ++++++++--
6 files changed, 66 insertions(+), 48 deletions(-)
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c
index 5d6bd1a..66282ff 100644
--- a/dlls/wined3d/arb_program_shader.c
+++ b/dlls/wined3d/arb_program_shader.c
@@ -657,6 +657,7 @@ static void shader_arb_load_constants_internal(const struct wined3d_context *con
const struct wined3d_stateblock *stateblock = device->stateBlock;
const struct wined3d_state *state = &stateblock->state;
const struct wined3d_gl_info *gl_info = context->gl_info;
+ const struct wined3d_d3d_info *d3d_info = context->d3d_info;
struct shader_arb_priv *priv = device->shader_priv;
if (!from_shader_select)
@@ -689,12 +690,12 @@ static void shader_arb_load_constants_internal(const struct wined3d_context *con
if (context != priv->last_context)
{
memset(priv->vshader_const_dirty, 1,
- sizeof(*priv->vshader_const_dirty) * device->d3d_vshader_constantF);
- priv->highest_dirty_vs_const = device->d3d_vshader_constantF;
+ sizeof(*priv->vshader_const_dirty) * d3d_info->limits.vs_uniform_count);
+ priv->highest_dirty_vs_const = d3d_info->limits.vs_uniform_count;
memset(priv->pshader_const_dirty, 1,
- sizeof(*priv->pshader_const_dirty) * device->d3d_pshader_constantF);
- priv->highest_dirty_ps_const = device->d3d_pshader_constantF;
+ sizeof(*priv->pshader_const_dirty) * d3d_info->limits.ps_uniform_count);
+ priv->highest_dirty_ps_const = d3d_info->limits.ps_uniform_count;
priv->last_context = context;
}
@@ -4850,6 +4851,7 @@ static HRESULT shader_arb_alloc(struct wined3d_device *device, const struct wine
struct shader_arb_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*priv));
struct fragment_caps fragment_caps;
void *vertex_priv, *fragment_priv;
+ const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
if (!(vertex_priv = vertex_pipe->vp_alloc(&arb_program_shader_backend, priv)))
{
@@ -4867,18 +4869,18 @@ static HRESULT shader_arb_alloc(struct wined3d_device *device, const struct wine
}
priv->vshader_const_dirty = HeapAlloc(GetProcessHeap(), 0,
- sizeof(*priv->vshader_const_dirty) * device->d3d_vshader_constantF);
+ sizeof(*priv->vshader_const_dirty) * d3d_info->limits.vs_uniform_count);
if (!priv->vshader_const_dirty)
goto fail;
memset(priv->vshader_const_dirty, 1,
- sizeof(*priv->vshader_const_dirty) * device->d3d_vshader_constantF);
+ sizeof(*priv->vshader_const_dirty) * d3d_info->limits.vs_uniform_count);
priv->pshader_const_dirty = HeapAlloc(GetProcessHeap(), 0,
- sizeof(*priv->pshader_const_dirty) * device->d3d_pshader_constantF);
+ sizeof(*priv->pshader_const_dirty) * d3d_info->limits.ps_uniform_count);
if (!priv->pshader_const_dirty)
goto fail;
memset(priv->pshader_const_dirty, 1,
- sizeof(*priv->pshader_const_dirty) * device->d3d_pshader_constantF);
+ sizeof(*priv->pshader_const_dirty) * d3d_info->limits.ps_uniform_count);
if(wine_rb_init(&priv->signature_tree, &sig_tree_functions) == -1)
{
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index b15d4c2..c999f65 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -2602,6 +2602,7 @@ HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
UINT start_register, const float *constants, UINT vector4f_count)
{
UINT i;
+ const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
device, start_register, constants, vector4f_count);
@@ -2609,8 +2610,8 @@ HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
/* Specifically test start_register > limit to catch MAX_UINT overflows
* when adding start_register + vector4f_count. */
if (!constants
- || start_register + vector4f_count > device->d3d_vshader_constantF
- || start_register > device->d3d_vshader_constantF)
+ || start_register + vector4f_count > d3d_info->limits.vs_uniform_count
+ || start_register > d3d_info->limits.vs_uniform_count)
return WINED3DERR_INVALIDCALL;
memcpy(&device->updateStateBlock->state.vs_consts_f[start_register * 4],
@@ -2638,7 +2639,8 @@ HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
HRESULT CDECL wined3d_device_get_vs_consts_f(const struct wined3d_device *device,
UINT start_register, float *constants, UINT vector4f_count)
{
- int count = min(vector4f_count, device->d3d_vshader_constantF - start_register);
+ const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
+ int count = min(vector4f_count, d3d_info->limits.vs_uniform_count - start_register);
TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
device, start_register, constants, vector4f_count);
@@ -3071,6 +3073,7 @@ HRESULT CDECL wined3d_device_set_ps_consts_f(struct wined3d_device *device,
UINT start_register, const float *constants, UINT vector4f_count)
{
UINT i;
+ const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
device, start_register, constants, vector4f_count);
@@ -3078,8 +3081,8 @@ HRESULT CDECL wined3d_device_set_ps_consts_f(struct wined3d_device *device,
/* Specifically test start_register > limit to catch MAX_UINT overflows
* when adding start_register + vector4f_count. */
if (!constants
- || start_register + vector4f_count > device->d3d_pshader_constantF
- || start_register > device->d3d_pshader_constantF)
+ || start_register + vector4f_count > d3d_info->limits.ps_uniform_count
+ || start_register > d3d_info->limits.ps_uniform_count)
return WINED3DERR_INVALIDCALL;
memcpy(&device->updateStateBlock->state.ps_consts_f[start_register * 4],
@@ -3107,7 +3110,8 @@ HRESULT CDECL wined3d_device_set_ps_consts_f(struct wined3d_device *device,
HRESULT CDECL wined3d_device_get_ps_consts_f(const struct wined3d_device *device,
UINT start_register, float *constants, UINT vector4f_count)
{
- int count = min(vector4f_count, device->d3d_pshader_constantF - start_register);
+ const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
+ int count = min(vector4f_count, d3d_info->limits.ps_uniform_count - start_register);
TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
device, start_register, constants, vector4f_count);
@@ -5408,7 +5412,6 @@ HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d,
struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
const struct fragment_pipeline *fragment_pipeline;
const struct wined3d_vertex_pipe_ops *vertex_pipeline;
- struct shader_caps shader_caps;
struct fragment_caps ffp_caps;
unsigned int i;
HRESULT hr;
@@ -5429,12 +5432,6 @@ HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d,
device->create_parms.flags = flags;
device->shader_backend = adapter->shader_backend;
- device->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
- device->vs_version = shader_caps.vs_version;
- device->gs_version = shader_caps.gs_version;
- device->ps_version = shader_caps.ps_version;
- device->d3d_vshader_constantF = shader_caps.vs_uniform_count;
- device->d3d_pshader_constantF = shader_caps.ps_uniform_count;
vertex_pipeline = adapter->vertex_pipe;
diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index cd96ac7..52afdee 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -2846,6 +2846,11 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter)
adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
adapter->d3d_info.vs_clipping = shader_caps.wined3d_caps & WINED3D_SHADER_CAP_VS_CLIPPING;
+ adapter->d3d_info.limits.vs_version = shader_caps.vs_version;
+ adapter->d3d_info.limits.gs_version = shader_caps.gs_version;
+ adapter->d3d_info.limits.ps_version = shader_caps.ps_version;
+ adapter->d3d_info.limits.vs_uniform_count = shader_caps.vs_uniform_count;
+ adapter->d3d_info.limits.ps_uniform_count = shader_caps.ps_uniform_count;
adapter->fragment_pipe->get_caps(gl_info, &fragment_caps);
gl_info->limits.texture_stages = fragment_caps.MaxTextureBlendStages;
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index c3534b3..d9528d2 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -1625,6 +1625,7 @@ static HRESULT shader_set_function(struct wined3d_shader *shader, const DWORD *b
const struct wined3d_shader_frontend *fe;
HRESULT hr;
unsigned int backend_version;
+ const struct wined3d_d3d_info *d3d_info = &shader->device->adapter->d3d_info;
TRACE("shader %p, byte_code %p, output_signature %p, float_const_count %u.\n",
shader, byte_code, output_signature, float_const_count);
@@ -1672,13 +1673,13 @@ static HRESULT shader_set_function(struct wined3d_shader *shader, const DWORD *b
switch (type)
{
case WINED3D_SHADER_TYPE_VERTEX:
- backend_version = shader->device->vs_version;
+ backend_version = d3d_info->limits.vs_version;
break;
case WINED3D_SHADER_TYPE_GEOMETRY:
- backend_version = shader->device->gs_version;
+ backend_version = d3d_info->limits.gs_version;
break;
case WINED3D_SHADER_TYPE_PIXEL:
- backend_version = shader->device->ps_version;
+ backend_version = d3d_info->limits.ps_version;
break;
default:
FIXME("No backend version-checking for this shader type\n");
@@ -1843,6 +1844,7 @@ static void vertexshader_set_limits(struct wined3d_shader *shader)
DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
shader->reg_maps.shader_version.minor);
struct wined3d_device *device = shader->device;
+ const DWORD vs_uniform_count = device->adapter->d3d_info.limits.vs_uniform_count;
shader->limits.packed_input = 0;
@@ -1857,7 +1859,7 @@ static void vertexshader_set_limits(struct wined3d_shader *shader)
/* TODO: vs_1_1 has a minimum of 96 constants. What happens when
* a vs_1_1 shader is used on a vs_3_0 capable card that has 256
* constants? */
- shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.constant_float = min(256, vs_uniform_count);
break;
case WINED3D_SHADER_VERSION(2, 0):
@@ -1866,7 +1868,7 @@ static void vertexshader_set_limits(struct wined3d_shader *shader)
shader->limits.constant_int = 16;
shader->limits.packed_output = 12;
shader->limits.sampler = 0;
- shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.constant_float = min(256, vs_uniform_count);
break;
case WINED3D_SHADER_VERSION(3, 0):
@@ -1879,7 +1881,7 @@ static void vertexshader_set_limits(struct wined3d_shader *shader)
* drivers advertise 1024). d3d9.dll and d3d8.dll clamp the
* wined3d-advertised maximum. Clamp the constant limit for <= 3.0
* shaders to 256. */
- shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.constant_float = min(256, vs_uniform_count);
break;
case WINED3D_SHADER_VERSION(4, 0):
@@ -1896,7 +1898,7 @@ static void vertexshader_set_limits(struct wined3d_shader *shader)
shader->limits.constant_int = 16;
shader->limits.packed_output = 12;
shader->limits.sampler = 0;
- shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.constant_float = min(256, vs_uniform_count);
FIXME("Unrecognized vertex shader version \"%u.%u\".\n",
shader->reg_maps.shader_version.major,
shader->reg_maps.shader_version.minor);
@@ -1911,11 +1913,12 @@ static HRESULT vertexshader_init(struct wined3d_shader *shader, struct wined3d_d
unsigned int i;
HRESULT hr;
WORD map;
+ const DWORD vs_uniform_count = device->adapter->d3d_info.limits.vs_uniform_count;
if (!byte_code) return WINED3DERR_INVALIDCALL;
shader_init(shader, device, parent, parent_ops);
- hr = shader_set_function(shader, byte_code, output_signature, device->d3d_vshader_constantF,
+ hr = shader_set_function(shader, byte_code, output_signature, vs_uniform_count,
WINED3D_SHADER_TYPE_VERTEX, max_version);
if (FAILED(hr))
{
@@ -2256,11 +2259,12 @@ static HRESULT pixelshader_init(struct wined3d_shader *shader, struct wined3d_de
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
unsigned int i, highest_reg_used = 0, num_regs_used = 0;
HRESULT hr;
+ const DWORD ps_uniform_count = device->adapter->d3d_info.limits.ps_uniform_count;
if (!byte_code) return WINED3DERR_INVALIDCALL;
shader_init(shader, device, parent, parent_ops);
- hr = shader_set_function(shader, byte_code, output_signature, device->d3d_pshader_constantF,
+ hr = shader_set_function(shader, byte_code, output_signature, ps_uniform_count,
WINED3D_SHADER_TYPE_PIXEL, max_version);
if (FAILED(hr))
{
diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c
index aaf425c..6d26f71 100644
--- a/dlls/wined3d/stateblock.c
+++ b/dlls/wined3d/stateblock.c
@@ -194,31 +194,31 @@ static const DWORD vertex_states_sampler[] =
*/
static HRESULT stateblock_allocate_shader_constants(struct wined3d_stateblock *object)
{
- struct wined3d_device *device = object->device;
+ const struct wined3d_d3d_info *d3d_info = &object->device->adapter->d3d_info;
/* Allocate space for floating point constants */
object->state.ps_consts_f = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(float) * device->d3d_pshader_constantF * 4);
+ sizeof(float) * d3d_info->limits.ps_uniform_count * 4);
if (!object->state.ps_consts_f) goto fail;
object->changed.pixelShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(BOOL) * device->d3d_pshader_constantF);
+ sizeof(BOOL) * d3d_info->limits.ps_uniform_count);
if (!object->changed.pixelShaderConstantsF) goto fail;
object->state.vs_consts_f = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(float) * device->d3d_vshader_constantF * 4);
+ sizeof(float) * d3d_info->limits.vs_uniform_count * 4);
if (!object->state.vs_consts_f) goto fail;
object->changed.vertexShaderConstantsF = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(BOOL) * device->d3d_vshader_constantF);
+ sizeof(BOOL) * d3d_info->limits.vs_uniform_count);
if (!object->changed.vertexShaderConstantsF) goto fail;
object->contained_vs_consts_f = HeapAlloc(GetProcessHeap(), 0,
- sizeof(DWORD) * device->d3d_vshader_constantF);
+ sizeof(DWORD) * d3d_info->limits.vs_uniform_count);
if (!object->contained_vs_consts_f) goto fail;
object->contained_ps_consts_f = HeapAlloc(GetProcessHeap(), 0,
- sizeof(DWORD) * device->d3d_pshader_constantF);
+ sizeof(DWORD) * d3d_info->limits.ps_uniform_count);
if (!object->contained_ps_consts_f) goto fail;
return WINED3D_OK;
@@ -330,7 +330,7 @@ static void stateblock_savedstates_set_vertex(struct wined3d_saved_states *state
void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
{
- struct wined3d_device *device = stateblock->device;
+ const struct wined3d_d3d_info *d3d_info = &stateblock->device->adapter->d3d_info;
unsigned int i, j;
for (i = 0; i <= WINEHIGHEST_RENDER_STATE >> 5; ++i)
@@ -357,7 +357,7 @@ void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
}
}
- for (i = 0; i < device->d3d_vshader_constantF; ++i)
+ for (i = 0; i < d3d_info->limits.vs_uniform_count; ++i)
{
if (stateblock->changed.vertexShaderConstantsF[i])
{
@@ -384,7 +384,7 @@ void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
}
}
- for (i = 0; i < device->d3d_pshader_constantF; ++i)
+ for (i = 0; i < d3d_info->limits.ps_uniform_count; ++i)
{
if (stateblock->changed.pixelShaderConstantsF[i])
{
@@ -1148,6 +1148,7 @@ void stateblock_init_default_state(struct wined3d_stateblock *stateblock)
{
struct wined3d_device *device = stateblock->device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
+ const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
struct wined3d_state *state = &stateblock->state;
union
{
@@ -1171,8 +1172,8 @@ void stateblock_init_default_state(struct wined3d_stateblock *stateblock)
TRACE("stateblock %p.\n", stateblock);
- memset(stateblock->changed.pixelShaderConstantsF, 0, device->d3d_pshader_constantF * sizeof(BOOL));
- memset(stateblock->changed.vertexShaderConstantsF, 0, device->d3d_vshader_constantF * sizeof(BOOL));
+ memset(stateblock->changed.pixelShaderConstantsF, 0, d3d_info->limits.ps_uniform_count * sizeof(BOOL));
+ memset(stateblock->changed.vertexShaderConstantsF, 0, d3d_info->limits.vs_uniform_count * sizeof(BOOL));
/* Set some of the defaults for lights, transforms etc */
state->transforms[WINED3D_TS_PROJECTION] = identity;
@@ -1400,6 +1401,7 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock,
{
unsigned int i;
HRESULT hr;
+ const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
stateblock->ref = 1;
stateblock->device = device;
@@ -1423,17 +1425,19 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock,
{
case WINED3D_SBT_ALL:
stateblock_init_lights(stateblock, device->stateBlock->state.light_map);
- stateblock_savedstates_set_all(&stateblock->changed, device->d3d_vshader_constantF,
- device->d3d_pshader_constantF);
+ stateblock_savedstates_set_all(&stateblock->changed,
+ d3d_info->limits.vs_uniform_count, d3d_info->limits.ps_uniform_count);
break;
case WINED3D_SBT_PIXEL_STATE:
- stateblock_savedstates_set_pixel(&stateblock->changed, device->d3d_pshader_constantF);
+ stateblock_savedstates_set_pixel(&stateblock->changed,
+ d3d_info->limits.ps_uniform_count);
break;
case WINED3D_SBT_VERTEX_STATE:
stateblock_init_lights(stateblock, device->stateBlock->state.light_map);
- stateblock_savedstates_set_vertex(&stateblock->changed, device->d3d_vshader_constantF);
+ stateblock_savedstates_set_vertex(&stateblock->changed,
+ d3d_info->limits.vs_uniform_count);
break;
default:
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 6863116..991fab7 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -1587,8 +1587,16 @@ struct wined3d_driver_info
DWORD version_low;
};
+struct wined3d_d3d_limits
+{
+ UINT vs_version, gs_version, ps_version;
+ DWORD vs_uniform_count;
+ DWORD ps_uniform_count;
+};
+
struct wined3d_d3d_info
{
+ struct wined3d_d3d_limits limits;
BOOL vs_clipping;
};
@@ -1729,8 +1737,6 @@ struct wined3d_device
const struct blit_shader *blitter;
unsigned int max_ffp_textures;
- UINT vs_version, gs_version, ps_version;
- DWORD d3d_vshader_constantF, d3d_pshader_constantF; /* Advertised d3d caps, not GL ones */
UINT instance_count;
WORD vertexBlendUsed : 1; /* To avoid needless setting of the blend matrices */
--
1.8.1.5
More information about the wine-patches
mailing list