ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Move shader limits to wined3d_d3d_info.

This commit is contained in:
Stefan Dösinger 2013-04-25 15:20:27 +02:00 committed by Alexandre Julliard
parent f7580726b0
commit 768e8c098c
6 changed files with 66 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
dlls/wined3d/arb_program_shader.c
View File

@ -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)
{

23
dlls/wined3d/device.c
View File

@ -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;

5
dlls/wined3d/directx.c
View File

@ -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;

22
dlls/wined3d/shader.c
View File

@ -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))
{

36
dlls/wined3d/stateblock.c
View File

@ -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:

10
dlls/wined3d/wined3d_private.h
View File

@ -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 */