[PATCH 2/5] wined3d: Get rid of IWineD3DBaseShaderClass.
Henri Verbeet
hverbeet at codeweavers.com
Wed Mar 30 13:49:24 CDT 2011
---
dlls/wined3d/arb_program_shader.c | 185 +++++++++++----------
dlls/wined3d/device.c | 12 +-
dlls/wined3d/glsl_shader.c | 169 ++++++++++----------
dlls/wined3d/shader.c | 319 +++++++++++++++++++------------------
dlls/wined3d/state.c | 4 +-
dlls/wined3d/wined3d_private.h | 81 +++++-----
6 files changed, 388 insertions(+), 382 deletions(-)
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c
index 10d235c..8264872 100644
--- a/dlls/wined3d/arb_program_shader.c
+++ b/dlls/wined3d/arb_program_shader.c
@@ -362,7 +362,7 @@ static unsigned int reserved_vs_const(const struct arb_vshader_private *shader_d
* or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
*/
/* GL locking is done by the caller */
-static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl *This, const struct wined3d_gl_info *gl_info,
+static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl *shader, const struct wined3d_gl_info *gl_info,
GLuint target_type, unsigned int max_constants, const float *constants, char *dirty_consts)
{
local_constant* lconst;
@@ -382,7 +382,7 @@ static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl *This, con
i = 0;
/* In 1.X pixel shaders constants are implicitly clamped in the range [-1;1] */
- if (target_type == GL_FRAGMENT_PROGRAM_ARB && This->baseShader.reg_maps.shader_version.major == 1)
+ if (target_type == GL_FRAGMENT_PROGRAM_ARB && shader->reg_maps.shader_version.major == 1)
{
float lcl_const[4];
/* ps 1.x supports only 8 constants, clamp only those. When switching between 1.x and higher
@@ -451,9 +451,12 @@ static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl *This, con
checkGLcall("glProgramEnvParameter4fvARB()");
/* Load immediate constants */
- if(This->baseShader.load_local_constsF) {
- if (TRACE_ON(d3d_shader)) {
- LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
+ if (shader->load_local_constsF)
+ {
+ if (TRACE_ON(d3d_shader))
+ {
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
+ {
GLfloat* values = (GLfloat*)lconst->value;
TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
values[0], values[1], values[2], values[3]);
@@ -461,7 +464,8 @@ static unsigned int shader_arb_load_constantsF(IWineD3DBaseShaderImpl *This, con
}
/* Immediate constants are clamped for 1.X shaders at loading times */
ret = 0;
- LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
+ {
dirty_consts[lconst->idx] = 1; /* Dirtify so the non-immediate constant overwrites it next time */
ret = max(ret, lconst->idx + 1);
GL_EXTCALL(glProgramEnvParameter4fvARB(target_type, lconst->idx, (GLfloat*)lconst->value));
@@ -678,21 +682,24 @@ static void shader_arb_update_float_pixel_constants(IWineD3DDeviceImpl *device,
device->highest_dirty_ps_const = max(device->highest_dirty_ps_const, start + count);
}
-static DWORD *local_const_mapping(IWineD3DBaseShaderImpl *This)
+static DWORD *local_const_mapping(IWineD3DBaseShaderImpl *shader)
{
DWORD *ret;
DWORD idx = 0;
const local_constant *lconst;
- if(This->baseShader.load_local_constsF || list_empty(&This->baseShader.constantsF)) return NULL;
+ if (shader->load_local_constsF || list_empty(&shader->constantsF))
+ return NULL;
- ret = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) * This->baseShader.limits.constant_float);
- if(!ret) {
+ ret = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) * shader->limits.constant_float);
+ if (!ret)
+ {
ERR("Out of memory\n");
return NULL;
}
- LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
+ {
ret[lconst->idx] = idx++;
}
return ret;
@@ -729,7 +736,7 @@ static DWORD shader_generate_arb_declarations(IWineD3DBaseShaderImpl *shader,
}
else
{
- const struct arb_vshader_private *shader_data = shader->baseShader.backend_data;
+ const struct arb_vshader_private *shader_data = shader->backend_data;
max_constantsF = gl_info->limits.arb_vs_native_constants;
/* 96 is the minimum MAX_PROGRAM_ENV_PARAMETERS_ARB value.
* Also prevents max_constantsF from becoming less than 0 and
@@ -744,7 +751,7 @@ static DWORD shader_generate_arb_declarations(IWineD3DBaseShaderImpl *shader,
max_constantsF -= reserved_vs_const(shader_data, reg_maps, gl_info);
max_constantsF -= count_bits(reg_maps->integer_constants);
- for (i = 0; i < shader->baseShader.limits.constant_float; ++i)
+ for (i = 0; i < shader->limits.constant_float; ++i)
{
DWORD idx = i >> 5;
DWORD shift = i & 0x1f;
@@ -800,7 +807,7 @@ static DWORD shader_generate_arb_declarations(IWineD3DBaseShaderImpl *shader,
*/
if (lconst_map)
{
- LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
{
shader_addline(buffer, "PARAM C%u = program.local[%u];\n", lconst->idx,
lconst_map[lconst->idx]);
@@ -821,7 +828,7 @@ static DWORD shader_generate_arb_declarations(IWineD3DBaseShaderImpl *shader,
}
/* Avoid declaring more constants than needed */
- max_constantsF = min(max_constantsF, shader->baseShader.limits.constant_float);
+ max_constantsF = min(max_constantsF, shader->limits.constant_float);
/* we use the array-based constants array if the local constants are marked for loading,
* because then we use indirect addressing, or when the local constant list is empty,
@@ -1039,7 +1046,7 @@ static void shader_arb_get_register_name(const struct wined3d_shader_instruction
case WINED3DSPR_CONST:
if (!pshader && reg->rel_addr)
{
- const struct arb_vshader_private *shader_data = shader->baseShader.backend_data;
+ const struct arb_vshader_private *shader_data = shader->backend_data;
UINT rel_offset = shader_data->rel_offset;
BOOL aL = FALSE;
char rel_reg[50];
@@ -1334,7 +1341,7 @@ static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD
const char *tex_type;
BOOL np2_fixup = FALSE;
struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
const char *mod;
BOOL pshader = shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type);
@@ -1762,7 +1769,7 @@ static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
if (ins->handler_idx == WINED3DSIH_MOVA)
{
- const struct arb_vshader_private *shader_data = shader->baseShader.backend_data;
+ const struct arb_vshader_private *shader_data = shader->backend_data;
char write_mask[6];
const char *offset = arb_get_helper_value(WINED3D_SHADER_TYPE_VERTEX, ARB_VS_REL_OFFSET);
@@ -1801,7 +1808,7 @@ static void shader_hw_mov(const struct wined3d_shader_instruction *ins)
&& !shader_is_pshader_version(reg_maps->shader_version.type)
&& ins->dst[0].reg.type == WINED3DSPR_ADDR)
{
- const struct arb_vshader_private *shader_data = shader->baseShader.backend_data;
+ const struct arb_vshader_private *shader_data = shader->backend_data;
src0_param[0] = '\0';
if (shader_data->rel_offset)
@@ -3206,7 +3213,7 @@ static void shader_hw_ret(const struct wined3d_shader_instruction *ins)
if(vshader)
{
- if (priv->in_main_func) vshader_add_footer(priv, shader->baseShader.backend_data,
+ if (priv->in_main_func) vshader_add_footer(priv, shader->backend_data,
priv->cur_vs_args, ins->ctx->reg_maps, ins->ctx->gl_info, buffer);
}
@@ -3406,11 +3413,11 @@ static void arbfp_add_sRGB_correction(struct wined3d_shader_buffer *buffer, cons
/* [0.0;1.0] clamping. Not needed, this is done implicitly */
}
-static const DWORD *find_loop_control_values(IWineD3DBaseShaderImpl *This, DWORD idx)
+static const DWORD *find_loop_control_values(IWineD3DBaseShaderImpl *shader, DWORD idx)
{
const local_constant *constant;
- LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsI, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(constant, &shader->constantsI, local_constant, entry)
{
if (constant->idx == idx)
{
@@ -3429,7 +3436,7 @@ static void init_ps_input(const IWineD3DBaseShaderImpl *shader,
"fragment.texcoord[4]", "fragment.texcoord[5]", "fragment.texcoord[6]", "fragment.texcoord[7]"
};
unsigned int i;
- const struct wined3d_shader_signature_element *sig = shader->baseShader.input_signature;
+ const struct wined3d_shader_signature_element *sig = shader->input_signature;
const char *semantic_name;
DWORD semantic_idx;
@@ -3499,8 +3506,8 @@ static GLuint shader_arb_generate_pshader(IWineD3DBaseShaderImpl *shader,
const struct wined3d_gl_info *gl_info, struct wined3d_shader_buffer *buffer,
const struct arb_ps_compile_args *args, struct arb_ps_compiled_shader *compiled)
{
- const struct wined3d_shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
- const DWORD *function = shader->baseShader.function;
+ const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
+ const DWORD *function = shader->function;
const local_constant *lconst;
GLuint retval;
char fragcolor[16];
@@ -3508,7 +3515,7 @@ static GLuint shader_arb_generate_pshader(IWineD3DBaseShaderImpl *shader,
struct shader_arb_ctx_priv priv_ctx;
BOOL dcl_td = FALSE;
BOOL want_nv_prog = FALSE;
- struct arb_pshader_private *shader_priv = shader->baseShader.backend_data;
+ struct arb_pshader_private *shader_priv = shader->backend_data;
GLint errPos;
DWORD map;
@@ -3827,7 +3834,7 @@ static GLuint shader_arb_generate_pshader(IWineD3DBaseShaderImpl *shader,
/* Load immediate constants */
if (lconst_map)
{
- LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
{
const float *value = (const float *)lconst->value;
GL_EXTCALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, lconst_map[lconst->idx], value));
@@ -3914,8 +3921,7 @@ static void init_output_registers(IWineD3DBaseShaderImpl *shader, DWORD sig_num,
"result.texcoord[0]", "result.texcoord[1]", "result.texcoord[2]", "result.texcoord[3]",
"result.texcoord[4]", "result.texcoord[5]", "result.texcoord[6]", "result.texcoord[7]"
};
- IWineD3DDeviceImpl *device = shader->baseShader.device;
- IWineD3DBaseShaderClass *baseshader = &shader->baseShader;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_shader_signature_element *sig;
const char *semantic_name;
DWORD semantic_idx, reg_idx;
@@ -3943,42 +3949,42 @@ static void init_output_registers(IWineD3DBaseShaderImpl *shader, DWORD sig_num,
priv_ctx->fog_output = "result.fogcoord";
/* Map declared regs to builtins. Use "TA" to /dev/null unread output */
- for (i = 0; i < (sizeof(baseshader->output_signature) / sizeof(*baseshader->output_signature)); ++i)
+ for (i = 0; i < (sizeof(shader->output_signature) / sizeof(*shader->output_signature)); ++i)
{
- semantic_name = baseshader->output_signature[i].semantic_name;
+ semantic_name = shader->output_signature[i].semantic_name;
if (!semantic_name) continue;
if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_POSITION))
{
TRACE("o%u is TMP_OUT\n", i);
- if (!baseshader->output_signature[i].semantic_idx) priv_ctx->vs_output[i] = "TMP_OUT";
+ if (!shader->output_signature[i].semantic_idx) priv_ctx->vs_output[i] = "TMP_OUT";
else priv_ctx->vs_output[i] = "TA";
}
else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_PSIZE))
{
TRACE("o%u is result.pointsize\n", i);
- if (!baseshader->output_signature[i].semantic_idx) priv_ctx->vs_output[i] = "result.pointsize";
+ if (!shader->output_signature[i].semantic_idx) priv_ctx->vs_output[i] = "result.pointsize";
else priv_ctx->vs_output[i] = "TA";
}
else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_COLOR))
{
- TRACE("o%u is result.color.?, idx %u\n", i, baseshader->output_signature[i].semantic_idx);
- if (!baseshader->output_signature[i].semantic_idx)
+ TRACE("o%u is result.color.?, idx %u\n", i, shader->output_signature[i].semantic_idx);
+ if (!shader->output_signature[i].semantic_idx)
priv_ctx->vs_output[i] = "result.color.primary";
- else if (baseshader->output_signature[i].semantic_idx == 1)
+ else if (shader->output_signature[i].semantic_idx == 1)
priv_ctx->vs_output[i] = "result.color.secondary";
else priv_ctx->vs_output[i] = "TA";
}
else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_TEXCOORD))
{
- TRACE("o%u is %s\n", i, texcoords[baseshader->output_signature[i].semantic_idx]);
- if (baseshader->output_signature[i].semantic_idx >= 8) priv_ctx->vs_output[i] = "TA";
- else priv_ctx->vs_output[i] = texcoords[baseshader->output_signature[i].semantic_idx];
+ TRACE("o%u is %s\n", i, texcoords[shader->output_signature[i].semantic_idx]);
+ if (shader->output_signature[i].semantic_idx >= 8) priv_ctx->vs_output[i] = "TA";
+ else priv_ctx->vs_output[i] = texcoords[shader->output_signature[i].semantic_idx];
}
else if(shader_match_semantic(semantic_name, WINED3DDECLUSAGE_FOG))
{
TRACE("o%u is result.fogcoord\n", i);
- if (baseshader->output_signature[i].semantic_idx > 0) priv_ctx->vs_output[i] = "TA";
+ if (shader->output_signature[i].semantic_idx > 0) priv_ctx->vs_output[i] = "TA";
else priv_ctx->vs_output[i] = "result.fogcoord";
}
else
@@ -3992,7 +3998,7 @@ static void init_output_registers(IWineD3DBaseShaderImpl *shader, DWORD sig_num,
/* Instead of searching for the signature in the signature list, read the one from the current pixel shader.
* Its maybe not the shader where the signature came from, but it is the same signature and faster to find
*/
- sig = device->stateBlock->state.pixel_shader->baseShader.input_signature;
+ sig = device->stateBlock->state.pixel_shader->input_signature;
TRACE("Pixel shader uses declared varyings\n");
/* Map builtin to declared. /dev/null the results by default to the TA temp reg */
@@ -4042,21 +4048,21 @@ static void init_output_registers(IWineD3DBaseShaderImpl *shader, DWORD sig_num,
}
/* Map declared to declared */
- for (i = 0; i < (sizeof(baseshader->output_signature) / sizeof(*baseshader->output_signature)); ++i)
+ for (i = 0; i < (sizeof(shader->output_signature) / sizeof(*shader->output_signature)); ++i)
{
/* Write unread output to TA to throw them away */
priv_ctx->vs_output[i] = "TA";
- semantic_name = baseshader->output_signature[i].semantic_name;
+ semantic_name = shader->output_signature[i].semantic_name;
if (!semantic_name) continue;
if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_POSITION)
- && !baseshader->output_signature[i].semantic_idx)
+ && !shader->output_signature[i].semantic_idx)
{
priv_ctx->vs_output[i] = "TMP_OUT";
continue;
}
else if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_PSIZE)
- && !baseshader->output_signature[i].semantic_idx)
+ && !shader->output_signature[i].semantic_idx)
{
priv_ctx->vs_output[i] = "result.pointsize";
continue;
@@ -4067,7 +4073,7 @@ static void init_output_registers(IWineD3DBaseShaderImpl *shader, DWORD sig_num,
if (!sig[j].semantic_name) continue;
if (!strcmp(sig[j].semantic_name, semantic_name)
- && sig[j].semantic_idx == baseshader->output_signature[i].semantic_idx)
+ && sig[j].semantic_idx == shader->output_signature[i].semantic_idx)
{
priv_ctx->vs_output[i] = decl_idx_to_string[sig[j].register_idx];
@@ -4086,9 +4092,9 @@ static GLuint shader_arb_generate_vshader(IWineD3DBaseShaderImpl *shader,
const struct wined3d_gl_info *gl_info, struct wined3d_shader_buffer *buffer,
const struct arb_vs_compile_args *args, struct arb_vs_compiled_shader *compiled)
{
- const struct arb_vshader_private *shader_data = shader->baseShader.backend_data;
- const struct wined3d_shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
- const DWORD *function = shader->baseShader.function;
+ const struct arb_vshader_private *shader_data = shader->backend_data;
+ const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
+ const DWORD *function = shader->function;
const local_constant *lconst;
GLuint ret;
DWORD next_local, *lconst_map = local_const_mapping(shader);
@@ -4177,7 +4183,7 @@ static GLuint shader_arb_generate_vshader(IWineD3DBaseShaderImpl *shader,
*/
if (!gl_info->supported[NV_VERTEX_PROGRAM])
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const char *color_init = arb_get_helper_value(WINED3D_SHADER_TYPE_VERTEX, ARB_0001);
shader_addline(buffer, "MOV result.color.secondary, %s;\n", color_init);
@@ -4234,7 +4240,7 @@ static GLuint shader_arb_generate_vshader(IWineD3DBaseShaderImpl *shader,
/* Load immediate constants */
if (lconst_map)
{
- LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
{
const float *value = (const float *)lconst->value;
GL_EXTCALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, lconst_map[lconst->idx], value));
@@ -4250,7 +4256,7 @@ static GLuint shader_arb_generate_vshader(IWineD3DBaseShaderImpl *shader,
static struct arb_ps_compiled_shader *find_arb_pshader(IWineD3DBaseShaderImpl *shader,
const struct arb_ps_compile_args *args)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
UINT i;
DWORD new_size;
@@ -4259,27 +4265,29 @@ static struct arb_ps_compiled_shader *find_arb_pshader(IWineD3DBaseShaderImpl *s
struct arb_pshader_private *shader_data;
GLuint ret;
- if (!shader->baseShader.backend_data)
+ if (!shader->backend_data)
{
struct shader_arb_priv *priv = device->shader_priv;
- shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
- shader_data = shader->baseShader.backend_data;
- shader_data->clamp_consts = shader->baseShader.reg_maps.shader_version.major == 1;
+ shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
+ shader_data = shader->backend_data;
+ shader_data->clamp_consts = shader->reg_maps.shader_version.major == 1;
- if(shader->baseShader.reg_maps.shader_version.major < 3) shader_data->input_signature_idx = ~0;
- else shader_data->input_signature_idx = find_input_signature(priv, shader->baseShader.input_signature);
+ if (shader->reg_maps.shader_version.major < 3)
+ shader_data->input_signature_idx = ~0;
+ else
+ shader_data->input_signature_idx = find_input_signature(priv, shader->input_signature);
shader_data->has_signature_idx = TRUE;
TRACE("Shader got assigned input signature index %u\n", shader_data->input_signature_idx);
if (!device->vs_clipping)
- shader_data->clipplane_emulation = shader_find_free_input_register(&shader->baseShader.reg_maps,
+ shader_data->clipplane_emulation = shader_find_free_input_register(&shader->reg_maps,
gl_info->limits.texture_stages - 1);
else
shader_data->clipplane_emulation = ~0U;
}
- shader_data = shader->baseShader.backend_data;
+ shader_data = shader->backend_data;
/* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
* so a linear search is more performant than a hashmap or a binary search
@@ -4313,7 +4321,7 @@ static struct arb_ps_compiled_shader *find_arb_pshader(IWineD3DBaseShaderImpl *s
shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
- pixelshader_update_samplers(&shader->baseShader.reg_maps, device->stateBlock->state.textures);
+ pixelshader_update_samplers(&shader->reg_maps, device->stateBlock->state.textures);
if (!shader_buffer_init(&buffer))
{
@@ -4345,7 +4353,7 @@ static inline BOOL vs_args_equal(const struct arb_vs_compile_args *stored, const
static struct arb_vs_compiled_shader *find_arb_vshader(IWineD3DBaseShaderImpl *shader,
const struct arb_vs_compile_args *args)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
DWORD use_map = device->strided_streams.use_map;
UINT i;
@@ -4355,12 +4363,12 @@ static struct arb_vs_compiled_shader *find_arb_vshader(IWineD3DBaseShaderImpl *s
struct arb_vshader_private *shader_data;
GLuint ret;
- if (!shader->baseShader.backend_data)
+ if (!shader->backend_data)
{
- const struct wined3d_shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
+ const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
- shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
- shader_data = shader->baseShader.backend_data;
+ shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
+ shader_data = shader->backend_data;
if ((gl_info->quirks & WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT)
&& reg_maps->min_rel_offset <= reg_maps->max_rel_offset)
@@ -4377,7 +4385,7 @@ static struct arb_vs_compiled_shader *find_arb_vshader(IWineD3DBaseShaderImpl *s
shader_data->rel_offset = reg_maps->min_rel_offset;
}
}
- shader_data = shader->baseShader.backend_data;
+ shader_data = shader->backend_data;
/* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
* so a linear search is more performant than a hashmap or a binary search
@@ -4431,7 +4439,7 @@ static struct arb_vs_compiled_shader *find_arb_vshader(IWineD3DBaseShaderImpl *s
static void find_arb_ps_compile_args(const struct wined3d_state *state,
IWineD3DBaseShaderImpl *shader, struct arb_ps_compile_args *args)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
int i;
WORD int_skip;
@@ -4439,7 +4447,7 @@ static void find_arb_ps_compile_args(const struct wined3d_state *state,
find_ps_compile_args(state, shader, &args->super);
/* This forces all local boolean constants to 1 to make them stateblock independent */
- args->bools = shader->baseShader.reg_maps.local_bool_consts;
+ args->bools = shader->reg_maps.local_bool_consts;
for(i = 0; i < MAX_CONST_B; i++)
{
@@ -4459,7 +4467,7 @@ static void find_arb_ps_compile_args(const struct wined3d_state *state,
args->clip = 0;
/* Skip if unused or local, or supported natively */
- int_skip = ~shader->baseShader.reg_maps.integer_constants | shader->baseShader.reg_maps.local_int_consts;
+ int_skip = ~shader->reg_maps.integer_constants | shader->reg_maps.local_int_consts;
if (int_skip == 0xffff || gl_info->supported[NV_FRAGMENT_PROGRAM_OPTION])
{
memset(&args->loop_ctrl, 0, sizeof(args->loop_ctrl));
@@ -4486,7 +4494,7 @@ static void find_arb_ps_compile_args(const struct wined3d_state *state,
static void find_arb_vs_compile_args(const struct wined3d_state *state,
IWineD3DBaseShaderImpl *shader, struct arb_vs_compile_args *args)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
int i;
WORD int_skip;
@@ -4497,7 +4505,7 @@ static void find_arb_vs_compile_args(const struct wined3d_state *state,
if (use_ps(state))
{
IWineD3DBaseShaderImpl *ps = state->pixel_shader;
- struct arb_pshader_private *shader_priv = ps->baseShader.backend_data;
+ struct arb_pshader_private *shader_priv = ps->backend_data;
args->ps_signature = shader_priv->input_signature_idx;
args->clip.boolclip.clip_texcoord = shader_priv->clipplane_emulation + 1;
@@ -4520,7 +4528,7 @@ static void find_arb_vs_compile_args(const struct wined3d_state *state,
}
/* This forces all local boolean constants to 1 to make them stateblock independent */
- args->clip.boolclip.bools = shader->baseShader.reg_maps.local_bool_consts;
+ args->clip.boolclip.bools = shader->reg_maps.local_bool_consts;
/* TODO: Figure out if it would be better to store bool constants as bitmasks in the stateblock */
for(i = 0; i < MAX_CONST_B; i++)
{
@@ -4534,7 +4542,7 @@ static void find_arb_vs_compile_args(const struct wined3d_state *state,
args->vertex.samplers[3] = 0;
/* Skip if unused or local */
- int_skip = ~shader->baseShader.reg_maps.integer_constants | shader->baseShader.reg_maps.local_int_consts;
+ int_skip = ~shader->reg_maps.integer_constants | shader->reg_maps.local_int_consts;
/* This is about flow control, not clipping. */
if (int_skip == 0xffff || gl_info->supported[NV_VERTEX_PROGRAM2_OPTION])
{
@@ -4595,9 +4603,9 @@ static void shader_arb_select(const struct wined3d_context *context, BOOL usePS,
/* Pixel Shader 1.x constants are clamped to [-1;1], Pixel Shader 2.0 constants are not. If switching between
* a 1.x and newer shader, reload the first 8 constants
*/
- if(priv->last_ps_const_clamped != ((struct arb_pshader_private *)ps->baseShader.backend_data)->clamp_consts)
+ if (priv->last_ps_const_clamped != ((struct arb_pshader_private *)ps->backend_data)->clamp_consts)
{
- priv->last_ps_const_clamped = ((struct arb_pshader_private *)ps->baseShader.backend_data)->clamp_consts;
+ priv->last_ps_const_clamped = ((struct arb_pshader_private *)ps->backend_data)->clamp_consts;
This->highest_dirty_ps_const = max(This->highest_dirty_ps_const, 8);
for(i = 0; i < 8; i++)
{
@@ -4721,12 +4729,12 @@ static void shader_arb_deselect_depth_blt(void *shader_priv, const struct wined3
static void shader_arb_destroy(IWineD3DBaseShaderImpl *shader)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
- if (shader_is_pshader_version(shader->baseShader.reg_maps.shader_version.type))
+ if (shader_is_pshader_version(shader->reg_maps.shader_version.type))
{
- struct arb_pshader_private *shader_data = shader->baseShader.backend_data;
+ struct arb_pshader_private *shader_data = shader->backend_data;
UINT i;
if(!shader_data) return; /* This can happen if a shader was never compiled */
@@ -4748,11 +4756,11 @@ static void shader_arb_destroy(IWineD3DBaseShaderImpl *shader)
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
HeapFree(GetProcessHeap(), 0, shader_data);
- shader->baseShader.backend_data = NULL;
+ shader->backend_data = NULL;
}
else
{
- struct arb_vshader_private *shader_data = shader->baseShader.backend_data;
+ struct arb_vshader_private *shader_data = shader->backend_data;
UINT i;
if(!shader_data) return; /* This can happen if a shader was never compiled */
@@ -4774,7 +4782,7 @@ static void shader_arb_destroy(IWineD3DBaseShaderImpl *shader)
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
HeapFree(GetProcessHeap(), 0, shader_data);
- shader->baseShader.backend_data = NULL;
+ shader->backend_data = NULL;
}
}
@@ -5077,7 +5085,8 @@ static const SHADER_HANDLER shader_arb_instruction_handler_table[WINED3DSIH_TABL
/* WINED3DSIH_UTOF */ NULL,
};
-static inline BOOL get_bool_const(const struct wined3d_shader_instruction *ins, IWineD3DBaseShaderImpl *This, DWORD idx)
+static BOOL get_bool_const(const struct wined3d_shader_instruction *ins,
+ IWineD3DBaseShaderImpl *shader, DWORD idx)
{
const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
BOOL vshader = shader_is_vshader_version(reg_maps->shader_version.type);
@@ -5089,7 +5098,7 @@ static inline BOOL get_bool_const(const struct wined3d_shader_instruction *ins,
if (reg_maps->local_bool_consts & flag)
{
/* What good is a if(bool) with a hardcoded local constant? I don't know, but handle it */
- LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsB, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(constant, &shader->constantsB, local_constant, entry)
{
if (constant->idx == idx)
{
@@ -5108,7 +5117,7 @@ static inline BOOL get_bool_const(const struct wined3d_shader_instruction *ins,
}
static void get_loop_control_const(const struct wined3d_shader_instruction *ins,
- IWineD3DBaseShaderImpl *This, UINT idx, struct wined3d_shader_loop_control *loop_control)
+ IWineD3DBaseShaderImpl *shader, UINT idx, struct wined3d_shader_loop_control *loop_control)
{
const struct wined3d_shader_reg_maps *reg_maps = ins->ctx->reg_maps;
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
@@ -5119,7 +5128,7 @@ static void get_loop_control_const(const struct wined3d_shader_instruction *ins,
{
const local_constant *constant;
- LIST_FOR_EACH_ENTRY(constant, &This->baseShader.constantsI, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(constant, &shader->constantsI, local_constant, entry)
{
if (constant->idx == idx)
{
@@ -5665,7 +5674,7 @@ static void set_bumpmat_arbfp(DWORD state_id, struct wined3d_stateblock *statebl
if (use_ps(state))
{
IWineD3DBaseShaderImpl *ps = state->pixel_shader;
- if (stage && (ps->baseShader.reg_maps.bumpmat & (1 << stage)))
+ if (stage && (ps->reg_maps.bumpmat & (1 << stage)))
{
/* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
* anyway
@@ -5704,7 +5713,7 @@ static void tex_bumpenvlum_arbfp(DWORD state_id,
if (use_ps(state))
{
IWineD3DBaseShaderImpl *ps = state->pixel_shader;
- if (stage && (ps->baseShader.reg_maps.luminanceparams & (1 << stage)))
+ if (stage && (ps->reg_maps.luminanceparams & (1 << stage)))
{
/* The pixel shader has to know the luminance offset. Do a constants update if it
* isn't scheduled anyway
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 7113056..74a4ac3 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -472,7 +472,7 @@ void device_preload_textures(IWineD3DDeviceImpl *device)
{
for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i)
{
- if (state->vertex_shader->baseShader.reg_maps.sampler_type[i])
+ if (state->vertex_shader->reg_maps.sampler_type[i])
device_preload_texture(state, MAX_FRAGMENT_SAMPLERS + i);
}
}
@@ -481,7 +481,7 @@ void device_preload_textures(IWineD3DDeviceImpl *device)
{
for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
{
- if (state->pixel_shader->baseShader.reg_maps.sampler_type[i])
+ if (state->pixel_shader->reg_maps.sampler_type[i])
device_preload_texture(state, i);
}
}
@@ -3641,7 +3641,7 @@ static void device_map_fixed_function_samplers(IWineD3DDeviceImpl *This, const s
static void device_map_psamplers(IWineD3DDeviceImpl *This, const struct wined3d_gl_info *gl_info)
{
const WINED3DSAMPLER_TEXTURE_TYPE *sampler_type =
- This->stateBlock->state.pixel_shader->baseShader.reg_maps.sampler_type;
+ This->stateBlock->state.pixel_shader->reg_maps.sampler_type;
unsigned int i;
for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
@@ -3684,7 +3684,7 @@ static BOOL device_unit_free_for_vs(IWineD3DDeviceImpl *This, const WINED3DSAMPL
static void device_map_vsamplers(IWineD3DDeviceImpl *This, BOOL ps, const struct wined3d_gl_info *gl_info)
{
const WINED3DSAMPLER_TEXTURE_TYPE *vshader_sampler_type =
- This->stateBlock->state.vertex_shader->baseShader.reg_maps.sampler_type;
+ This->stateBlock->state.vertex_shader->reg_maps.sampler_type;
const WINED3DSAMPLER_TEXTURE_TYPE *pshader_sampler_type = NULL;
int start = min(MAX_COMBINED_SAMPLERS, gl_info->limits.combined_samplers) - 1;
int i;
@@ -3695,7 +3695,7 @@ static void device_map_vsamplers(IWineD3DDeviceImpl *This, BOOL ps, const struct
/* Note that we only care if a sampler is sampled or not, not the sampler's specific type.
* Otherwise we'd need to call shader_update_samplers() here for 1.x pixelshaders. */
- pshader_sampler_type = pshader->baseShader.reg_maps.sampler_type;
+ pshader_sampler_type = pshader->reg_maps.sampler_type;
}
for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
@@ -6258,7 +6258,7 @@ static void delete_opengl_contexts(IWineD3DDeviceImpl *device, IWineD3DSwapChain
gl_info = context->gl_info;
IWineD3DDevice_EnumResources((IWineD3DDevice *)device, device_unload_resource, NULL);
- LIST_FOR_EACH_ENTRY(shader, &device->shaders, IWineD3DBaseShaderImpl, baseShader.shader_list_entry)
+ LIST_FOR_EACH_ENTRY(shader, &device->shaders, IWineD3DBaseShaderImpl, shader_list_entry)
{
device->shader_backend->shader_destroy(shader);
}
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index b8dd152..a211106 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -4,7 +4,7 @@
* Copyright 2006 Jason Green
* Copyright 2006-2007 Henri Verbeet
* Copyright 2007-2008 Stefan Dösinger for CodeWeavers
- * Copyright 2009-2010 Henri Verbeet for CodeWeavers
+ * Copyright 2009-2011 Henri Verbeet for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -534,27 +534,27 @@ static inline void walk_constant_heap_clamped(const struct wined3d_gl_info *gl_i
/* Loads floating point constants (aka uniforms) into the currently set GLSL program. */
/* GL locking is done by the caller */
-static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl *This, const struct wined3d_gl_info *gl_info,
+static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl *shader, const struct wined3d_gl_info *gl_info,
const float *constants, const GLint *constant_locations, const struct constant_heap *heap,
unsigned char *stack, UINT version)
{
const local_constant *lconst;
/* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
- if (This->baseShader.reg_maps.shader_version.major == 1
- && shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type))
+ if (shader->reg_maps.shader_version.major == 1
+ && shader_is_pshader_version(shader->reg_maps.shader_version.type))
walk_constant_heap_clamped(gl_info, constants, constant_locations, heap, stack, version);
else
walk_constant_heap(gl_info, constants, constant_locations, heap, stack, version);
- if (!This->baseShader.load_local_constsF)
+ if (!shader->load_local_constsF)
{
TRACE("No need to load local float constants for this shader\n");
return;
}
/* Immediate constants are clamped to [-1;1] at shader creation time if needed */
- LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
{
GLint location = constant_locations[lconst->idx];
/* We found this uniform name in the program - go ahead and send the data */
@@ -565,7 +565,7 @@ static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl *This, const stru
/* Loads integer constants (aka uniforms) into the currently set GLSL program. */
/* GL locking is done by the caller */
-static void shader_glsl_load_constantsI(IWineD3DBaseShaderImpl *This, const struct wined3d_gl_info *gl_info,
+static void shader_glsl_load_constantsI(IWineD3DBaseShaderImpl *shader, const struct wined3d_gl_info *gl_info,
const GLint locations[MAX_CONST_I], const int *constants, WORD constants_set)
{
unsigned int i;
@@ -584,8 +584,9 @@ static void shader_glsl_load_constantsI(IWineD3DBaseShaderImpl *This, const stru
}
/* Load immediate constants */
- ptr = list_head(&This->baseShader.constantsI);
- while (ptr) {
+ ptr = list_head(&shader->constantsI);
+ while (ptr)
+ {
const struct local_constant *lconst = LIST_ENTRY(ptr, const struct local_constant, entry);
unsigned int idx = lconst->idx;
const GLint *values = (const GLint *)lconst->value;
@@ -596,13 +597,13 @@ static void shader_glsl_load_constantsI(IWineD3DBaseShaderImpl *This, const stru
/* We found this uniform name in the program - go ahead and send the data */
GL_EXTCALL(glUniform4ivARB(locations[idx], 1, values));
checkGLcall("glUniform4ivARB");
- ptr = list_next(&This->baseShader.constantsI, ptr);
+ ptr = list_next(&shader->constantsI, ptr);
}
}
/* Loads boolean constants (aka uniforms) into the currently set GLSL program. */
/* GL locking is done by the caller */
-static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const struct wined3d_gl_info *gl_info,
+static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *shader, const struct wined3d_gl_info *gl_info,
GLhandleARB programId, const BOOL *constants, WORD constants_set)
{
GLint tmp_loc;
@@ -611,7 +612,7 @@ static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const stru
const char *prefix;
struct list* ptr;
- switch (This->baseShader.reg_maps.shader_version.type)
+ switch (shader->reg_maps.shader_version.type)
{
case WINED3D_SHADER_TYPE_VERTEX:
prefix = "VB";
@@ -627,7 +628,7 @@ static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const stru
default:
FIXME("Unknown shader type %#x.\n",
- This->baseShader.reg_maps.shader_version.type);
+ shader->reg_maps.shader_version.type);
prefix = "UB";
break;
}
@@ -653,8 +654,9 @@ static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const stru
}
/* Load immediate constants */
- ptr = list_head(&This->baseShader.constantsB);
- while (ptr) {
+ ptr = list_head(&shader->constantsB);
+ while (ptr)
+ {
const struct local_constant *lconst = LIST_ENTRY(ptr, const struct local_constant, entry);
unsigned int idx = lconst->idx;
const GLint *values = (const GLint *)lconst->value;
@@ -668,7 +670,7 @@ static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const stru
GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, values));
checkGLcall("glUniform1ivARB");
}
- ptr = list_next(&This->baseShader.constantsB, ptr);
+ ptr = list_next(&shader->constantsB, ptr);
}
}
@@ -762,11 +764,11 @@ static void shader_glsl_load_constants(const struct wined3d_context *context,
/* Load DirectX 9 integer constants/uniforms for vertex shader */
shader_glsl_load_constantsI(vshader, gl_info, prog->vuniformI_locations, stateBlock->state.vs_consts_i,
- stateBlock->changed.vertexShaderConstantsI & vshader->baseShader.reg_maps.integer_constants);
+ stateBlock->changed.vertexShaderConstantsI & vshader->reg_maps.integer_constants);
/* Load DirectX 9 boolean constants/uniforms for vertex shader */
shader_glsl_load_constantsB(vshader, gl_info, programId, stateBlock->state.vs_consts_b,
- stateBlock->changed.vertexShaderConstantsB & vshader->baseShader.reg_maps.boolean_constants);
+ stateBlock->changed.vertexShaderConstantsB & vshader->reg_maps.boolean_constants);
/* Upload the position fixup params */
shader_get_position_fixup(context, &stateBlock->state, position_fixup);
@@ -784,11 +786,11 @@ static void shader_glsl_load_constants(const struct wined3d_context *context,
/* Load DirectX 9 integer constants/uniforms for pixel shader */
shader_glsl_load_constantsI(pshader, gl_info, prog->puniformI_locations, stateBlock->state.ps_consts_i,
- stateBlock->changed.pixelShaderConstantsI & pshader->baseShader.reg_maps.integer_constants);
+ stateBlock->changed.pixelShaderConstantsI & pshader->reg_maps.integer_constants);
/* Load DirectX 9 boolean constants/uniforms for pixel shader */
shader_glsl_load_constantsB(pshader, gl_info, programId, stateBlock->state.ps_consts_b,
- stateBlock->changed.pixelShaderConstantsB & pshader->baseShader.reg_maps.boolean_constants);
+ stateBlock->changed.pixelShaderConstantsB & pshader->reg_maps.boolean_constants);
/* Upload the environment bump map matrix if needed. The needsbumpmat member specifies the texture stage to load the matrix from.
* It can't be 0 for a valid texbem instruction.
@@ -915,7 +917,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
struct wined3d_shader_buffer *buffer, IWineD3DBaseShaderImpl *shader,
const struct wined3d_shader_reg_maps *reg_maps, struct shader_glsl_ctx_priv *ctx_priv)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_state *state = &device->stateBlock->state;
const struct ps_compile_args *ps_args = ctx_priv->cur_ps_args;
const struct wined3d_gl_info *gl_info = context->gl_info;
@@ -934,7 +936,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
}
/* Declare the constants (aka uniforms) */
- if (shader->baseShader.limits.constant_float > 0)
+ if (shader->limits.constant_float > 0)
{
unsigned max_constantsF;
/* Unless the shader uses indirect addressing, always declare the maximum array size and ignore that we need some
@@ -988,18 +990,18 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
max_constantsF = gl_info->limits.glsl_vs_float_constants;
}
}
- max_constantsF = min(shader->baseShader.limits.constant_float, max_constantsF);
+ max_constantsF = min(shader->limits.constant_float, max_constantsF);
shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
}
/* Always declare the full set of constants, the compiler can remove the
* unused ones because d3d doesn't (yet) support indirect int and bool
* constant addressing. This avoids problems if the app uses e.g. i0 and i9. */
- if (shader->baseShader.limits.constant_int > 0 && reg_maps->integer_constants)
- shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, shader->baseShader.limits.constant_int);
+ if (shader->limits.constant_int > 0 && reg_maps->integer_constants)
+ shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, shader->limits.constant_int);
- if (shader->baseShader.limits.constant_bool > 0 && reg_maps->boolean_constants)
- shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, shader->baseShader.limits.constant_bool);
+ if (shader->limits.constant_bool > 0 && reg_maps->boolean_constants)
+ shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, shader->limits.constant_bool);
if (!pshader)
{
@@ -1033,7 +1035,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
}
if (reg_maps->vpos || reg_maps->usesdsy)
{
- if (shader->baseShader.limits.constant_float + extra_constants_needed
+ if (shader->limits.constant_float + extra_constants_needed
+ 1 < gl_info->limits.glsl_ps_float_constants)
{
shader_addline(buffer, "uniform vec4 ycorrection;\n");
@@ -1055,7 +1057,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
}
/* Declare texture samplers */
- for (i = 0; i < shader->baseShader.limits.sampler; ++i)
+ for (i = 0; i < shader->limits.sampler; ++i)
{
if (reg_maps->sampler_type[i])
{
@@ -1116,7 +1118,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
* samplerNP2Fixup stores texture dimensions and is updated through
* shader_glsl_load_np2fixup_constants when the sampler changes. */
- for (i = 0; i < shader->baseShader.limits.sampler; ++i)
+ for (i = 0; i < shader->limits.sampler; ++i)
{
if (reg_maps->sampler_type[i])
{
@@ -1165,8 +1167,8 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
}
/* Declare output register temporaries */
- if (shader->baseShader.limits.packed_output)
- shader_addline(buffer, "vec4 OUT[%u];\n", shader->baseShader.limits.packed_output);
+ if (shader->limits.packed_output)
+ shader_addline(buffer, "vec4 OUT[%u];\n", shader->limits.packed_output);
/* Declare temporary variables */
for (i = 0, map = reg_maps->temporary; map; map >>= 1, ++i)
@@ -1197,9 +1199,9 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
* They can't be hardcoded into the shader text via LC = {x, y, z, w}; because the
* float -> string conversion can cause precision loss.
*/
- if (!shader->baseShader.load_local_constsF)
+ if (!shader->load_local_constsF)
{
- LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
{
shader_addline(buffer, "uniform vec4 %cLC%u;\n", prefix, lconst->idx);
}
@@ -2853,7 +2855,8 @@ static void shader_glsl_loop(const struct wined3d_shader_instruction *ins)
*/
if (ins->src[1].reg.type == WINED3DSPR_CONSTINT)
{
- LIST_FOR_EACH_ENTRY(constant, &shader->baseShader.constantsI, local_constant, entry) {
+ LIST_FOR_EACH_ENTRY(constant, &shader->constantsI, local_constant, entry)
+ {
if (constant->idx == ins->src[1].reg.idx)
{
control_values = constant->value;
@@ -2931,7 +2934,7 @@ static void shader_glsl_rep(const struct wined3d_shader_instruction *ins)
/* Try to hardcode local values to help the GLSL compiler to unroll and optimize the loop */
if (ins->src[0].reg.type == WINED3DSPR_CONSTINT)
{
- LIST_FOR_EACH_ENTRY(constant, &shader->baseShader.constantsI, local_constant, entry)
+ LIST_FOR_EACH_ENTRY(constant, &shader->constantsI, local_constant, entry)
{
if (constant->idx == ins->src[0].reg.idx)
{
@@ -3033,7 +3036,7 @@ static void shader_glsl_ret(const struct wined3d_shader_instruction *ins)
static void shader_glsl_tex(const struct wined3d_shader_instruction *ins)
{
struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
ins->ctx->reg_maps->shader_version.minor);
glsl_sample_function_t sample_function;
@@ -3123,7 +3126,7 @@ static void shader_glsl_tex(const struct wined3d_shader_instruction *ins)
static void shader_glsl_texldd(const struct wined3d_shader_instruction *ins)
{
struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
glsl_sample_function_t sample_function;
glsl_src_param_t coord_param, dx_param, dy_param;
@@ -3156,7 +3159,7 @@ static void shader_glsl_texldd(const struct wined3d_shader_instruction *ins)
static void shader_glsl_texldl(const struct wined3d_shader_instruction *ins)
{
struct IWineD3DBaseShaderImpl *shader = ins->ctx->shader;
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
glsl_sample_function_t sample_function;
glsl_src_param_t coord_param, lod_param;
@@ -3844,13 +3847,13 @@ static GLhandleARB generate_param_reorder_function(struct wined3d_shader_buffer
IWineD3DBaseShaderImpl *vs, IWineD3DBaseShaderImpl *ps, const struct wined3d_gl_info *gl_info)
{
GLhandleARB ret = 0;
- DWORD ps_major = ps ? ps->baseShader.reg_maps.shader_version.major : 0;
+ DWORD ps_major = ps ? ps->reg_maps.shader_version.major : 0;
unsigned int i;
const char *semantic_name;
UINT semantic_idx;
char reg_mask[6];
- const struct wined3d_shader_signature_element *output_signature = vs->baseShader.output_signature;
- WORD map = vs->baseShader.reg_maps.output_registers;
+ const struct wined3d_shader_signature_element *output_signature = vs->output_signature;
+ WORD map = vs->reg_maps.output_registers;
shader_buffer_clear(buffer);
@@ -3936,8 +3939,8 @@ static GLhandleARB generate_param_reorder_function(struct wined3d_shader_buffer
}
/* Then, fix the pixel shader input */
- handle_ps3_input(buffer, gl_info, ps->u.ps.input_reg_map, ps->baseShader.input_signature,
- &ps->baseShader.reg_maps, output_signature, &vs->baseShader.reg_maps);
+ handle_ps3_input(buffer, gl_info, ps->u.ps.input_reg_map, ps->input_signature,
+ &ps->reg_maps, output_signature, &vs->reg_maps);
shader_addline(buffer, "}\n");
}
@@ -3958,7 +3961,8 @@ static void hardcode_local_constants(IWineD3DBaseShaderImpl *shader, const struc
const float *value;
char glsl_name[8];
- LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry) {
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
+ {
value = (const float *)lconst->value;
snprintf(glsl_name, sizeof(glsl_name), "%cLC%u", prefix, lconst->idx);
tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
@@ -3972,9 +3976,9 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context
struct wined3d_shader_buffer *buffer, IWineD3DBaseShaderImpl *shader,
const struct ps_compile_args *args, struct ps_np2fixup_info *np2fixup_info)
{
- const struct wined3d_shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
+ const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
const struct wined3d_gl_info *gl_info = context->gl_info;
- const DWORD *function = shader->baseShader.function;
+ const DWORD *function = shader->function;
struct shader_glsl_ctx_priv priv_ctx;
/* Create the hw GLSL shader object and assign it as the shader->prgId */
@@ -4007,7 +4011,7 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context
/* Pack 3.0 inputs */
if (reg_maps->shader_version.major >= 3 && args->vp_mode != vertexshader)
- shader_glsl_input_pack(shader, buffer, shader->baseShader.input_signature, reg_maps, args->vp_mode);
+ shader_glsl_input_pack(shader, buffer, shader->input_signature, reg_maps, args->vp_mode);
/* Base Shader Body */
shader_generate_main(shader, buffer, reg_maps, function, &priv_ctx);
@@ -4073,9 +4077,9 @@ static GLuint shader_glsl_generate_vshader(const struct wined3d_context *context
struct wined3d_shader_buffer *buffer, IWineD3DBaseShaderImpl *shader,
const struct vs_compile_args *args)
{
- const struct wined3d_shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
+ const struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
const struct wined3d_gl_info *gl_info = context->gl_info;
- const DWORD *function = shader->baseShader.function;
+ const DWORD *function = shader->function;
struct shader_glsl_ctx_priv priv_ctx;
/* Create the hw GLSL shader program and assign it as the shader->prgId */
@@ -4142,7 +4146,7 @@ static GLhandleARB find_glsl_pshader(const struct wined3d_context *context,
struct wined3d_shader_buffer *buffer, IWineD3DBaseShaderImpl *shader,
const struct ps_compile_args *args, const struct ps_np2fixup_info **np2fixup_info)
{
- struct wined3d_state *state = &shader->baseShader.device->stateBlock->state;
+ struct wined3d_state *state = &shader->device->stateBlock->state;
UINT i;
DWORD new_size;
struct glsl_ps_compiled_shader *new_array;
@@ -4150,16 +4154,16 @@ static GLhandleARB find_glsl_pshader(const struct wined3d_context *context,
struct ps_np2fixup_info *np2fixup = NULL;
GLhandleARB ret;
- if (!shader->baseShader.backend_data)
+ if (!shader->backend_data)
{
- shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
- if (!shader->baseShader.backend_data)
+ shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
+ if (!shader->backend_data)
{
ERR("Failed to allocate backend data.\n");
return 0;
}
}
- shader_data = shader->baseShader.backend_data;
+ shader_data = shader->backend_data;
/* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
* so a linear search is more performant than a hashmap or a binary search
@@ -4199,7 +4203,7 @@ static GLhandleARB find_glsl_pshader(const struct wined3d_context *context,
memset(&shader_data->gl_shaders[shader_data->num_gl_shaders].np2fixup, 0, sizeof(struct ps_np2fixup_info));
if (args->np2_fixup) np2fixup = &shader_data->gl_shaders[shader_data->num_gl_shaders].np2fixup;
- pixelshader_update_samplers(&shader->baseShader.reg_maps, state->textures);
+ pixelshader_update_samplers(&shader->reg_maps, state->textures);
shader_buffer_clear(buffer);
ret = shader_glsl_generate_pshader(context, buffer, shader, args, np2fixup);
@@ -4223,20 +4227,20 @@ static GLhandleARB find_glsl_vshader(const struct wined3d_context *context,
UINT i;
DWORD new_size;
struct glsl_vs_compiled_shader *new_array;
- DWORD use_map = shader->baseShader.device->strided_streams.use_map;
+ DWORD use_map = shader->device->strided_streams.use_map;
struct glsl_vshader_private *shader_data;
GLhandleARB ret;
- if (!shader->baseShader.backend_data)
+ if (!shader->backend_data)
{
- shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
- if (!shader->baseShader.backend_data)
+ shader->backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
+ if (!shader->backend_data)
{
ERR("Failed to allocate backend data.\n");
return 0;
}
}
- shader_data = shader->baseShader.backend_data;
+ shader_data = shader->backend_data;
/* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
* so a linear search is more performant than a hashmap or a binary search
@@ -4337,7 +4341,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context,
if (vshader)
{
GLhandleARB vshader_id = find_glsl_vshader(context, &priv->shader_buffer, vshader, &vs_compile_args);
- WORD map = vshader->baseShader.reg_maps.input_registers;
+ WORD map = vshader->reg_maps.input_registers;
char tmp_name[10];
reorder_shader_id = generate_param_reorder_function(&priv->shader_buffer, vshader, pshader, gl_info);
@@ -4371,7 +4375,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context,
}
checkGLcall("glBindAttribLocationARB");
- list_add_head(&vshader->baseShader.linked_programs, &entry->vshader_entry);
+ list_add_head(&vshader->linked_programs, &entry->vshader_entry);
}
/* Attach GLSL pshader */
@@ -4383,7 +4387,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context,
GL_EXTCALL(glAttachObjectARB(programId, pshader_id));
checkGLcall("glAttachObjectARB");
- list_add_head(&pshader->baseShader.linked_programs, &entry->pshader_entry);
+ list_add_head(&pshader->linked_programs, &entry->pshader_entry);
}
/* Link the program */
@@ -4441,8 +4445,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context,
entry->ycorrection_location = GL_EXTCALL(glGetUniformLocationARB(programId, "ycorrection"));
checkGLcall("Find glsl program uniform locations");
- if (pshader
- && pshader->baseShader.reg_maps.shader_version.major >= 3
+ if (pshader && pshader->reg_maps.shader_version.major >= 3
&& pshader->u.ps.declared_in_count > vec4_varyings(3, gl_info))
{
TRACE("Shader %d needs vertex color clamping disabled\n", programId);
@@ -4470,14 +4473,10 @@ static void set_glsl_shader_program(const struct wined3d_context *context,
* load them now to have them hardcoded in the GLSL program. This saves some CPU cycles
* later
*/
- if (pshader && !pshader->baseShader.load_local_constsF)
- {
- hardcode_local_constants((IWineD3DBaseShaderImpl *) pshader, gl_info, programId, 'P');
- }
- if (vshader && !vshader->baseShader.load_local_constsF)
- {
- hardcode_local_constants((IWineD3DBaseShaderImpl *) vshader, gl_info, programId, 'V');
- }
+ if (pshader && !pshader->load_local_constsF)
+ hardcode_local_constants(pshader, gl_info, programId, 'P');
+ if (vshader && !vshader->load_local_constsF)
+ hardcode_local_constants(vshader, gl_info, programId, 'V');
}
/* GL locking is done by the caller */
@@ -4678,7 +4677,7 @@ static void shader_glsl_deselect_depth_blt(void *shader_priv, const struct wined
static void shader_glsl_destroy(IWineD3DBaseShaderImpl *shader)
{
const struct list *linked_programs;
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
struct shader_glsl_priv *priv = device->shader_priv;
const struct wined3d_gl_info *gl_info;
struct wined3d_context *context;
@@ -4686,16 +4685,16 @@ static void shader_glsl_destroy(IWineD3DBaseShaderImpl *shader)
/* Note: Do not use QueryInterface here to find out which shader type this is because this code
* can be called from IWineD3DBaseShader::Release
*/
- char pshader = shader_is_pshader_version(shader->baseShader.reg_maps.shader_version.type);
+ char pshader = shader_is_pshader_version(shader->reg_maps.shader_version.type);
if (pshader)
{
- struct glsl_pshader_private *shader_data = shader->baseShader.backend_data;
+ struct glsl_pshader_private *shader_data = shader->backend_data;
if (!shader_data || !shader_data->num_gl_shaders)
{
HeapFree(GetProcessHeap(), 0, shader_data);
- shader->baseShader.backend_data = NULL;
+ shader->backend_data = NULL;
return;
}
@@ -4711,12 +4710,12 @@ static void shader_glsl_destroy(IWineD3DBaseShaderImpl *shader)
}
else
{
- struct glsl_vshader_private *shader_data = shader->baseShader.backend_data;
+ struct glsl_vshader_private *shader_data = shader->backend_data;
if (!shader_data || !shader_data->num_gl_shaders)
{
HeapFree(GetProcessHeap(), 0, shader_data);
- shader->baseShader.backend_data = NULL;
+ shader->backend_data = NULL;
return;
}
@@ -4731,7 +4730,7 @@ static void shader_glsl_destroy(IWineD3DBaseShaderImpl *shader)
}
}
- linked_programs = &shader->baseShader.linked_programs;
+ linked_programs = &shader->linked_programs;
TRACE("Deleting linked programs\n");
if (linked_programs->next) {
@@ -4752,7 +4751,7 @@ static void shader_glsl_destroy(IWineD3DBaseShaderImpl *shader)
if (pshader)
{
- struct glsl_pshader_private *shader_data = shader->baseShader.backend_data;
+ struct glsl_pshader_private *shader_data = shader->backend_data;
UINT i;
ENTER_GL();
@@ -4766,7 +4765,7 @@ static void shader_glsl_destroy(IWineD3DBaseShaderImpl *shader)
}
else
{
- struct glsl_vshader_private *shader_data = shader->baseShader.backend_data;
+ struct glsl_vshader_private *shader_data = shader->backend_data;
UINT i;
ENTER_GL();
@@ -4779,8 +4778,8 @@ static void shader_glsl_destroy(IWineD3DBaseShaderImpl *shader)
HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
}
- HeapFree(GetProcessHeap(), 0, shader->baseShader.backend_data);
- shader->baseShader.backend_data = NULL;
+ HeapFree(GetProcessHeap(), 0, shader->backend_data);
+ shader->backend_data = NULL;
context_release(context);
}
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index b5a2d08..5829836 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -5,7 +5,7 @@
* Copyright 2005 Oliver Stieber
* Copyright 2006 Ivan Gyurdiev
* Copyright 2007-2008 Stefan Dösinger for CodeWeavers
- * Copyright 2009-2010 Henri Verbeet for CodeWeavers
+ * Copyright 2009-2011 Henri Verbeet for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -298,7 +298,7 @@ int shader_addline(struct wined3d_shader_buffer *buffer, const char *format, ...
return ret;
}
-static void shader_init(struct IWineD3DBaseShaderClass *shader, IWineD3DDeviceImpl *device,
+static void shader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *device,
void *parent, const struct wined3d_parent_ops *parent_ops)
{
shader->ref = 1;
@@ -453,7 +453,7 @@ static HRESULT shader_get_registers_used(IWineD3DBaseShaderImpl *shader, const s
struct wined3d_shader_signature_element *output_signature, const DWORD *byte_code, DWORD constf_size)
{
unsigned int cur_loop_depth = 0, max_loop_depth = 0;
- void *fe_data = shader->baseShader.frontend_data;
+ void *fe_data = shader->frontend_data;
struct wined3d_shader_version shader_version;
const DWORD *ptr = byte_code;
@@ -553,7 +553,7 @@ static HRESULT shader_get_registers_used(IWineD3DBaseShaderImpl *shader, const s
else if (value[3] > 1.0f) value[3] = 1.0f;
}
- list_add_head(&shader->baseShader.constantsF, &lconst->entry);
+ list_add_head(&shader->constantsF, &lconst->entry);
}
else if (ins.handler_idx == WINED3DSIH_DEFI)
{
@@ -569,7 +569,7 @@ static HRESULT shader_get_registers_used(IWineD3DBaseShaderImpl *shader, const s
memcpy(lconst->value, ptr, 4 * sizeof(DWORD));
ptr += 4;
- list_add_head(&shader->baseShader.constantsI, &lconst->entry);
+ list_add_head(&shader->constantsI, &lconst->entry);
reg_maps->local_int_consts |= (1 << dst.reg.idx);
}
else if (ins.handler_idx == WINED3DSIH_DEFB)
@@ -586,7 +586,7 @@ static HRESULT shader_get_registers_used(IWineD3DBaseShaderImpl *shader, const s
memcpy(lconst->value, ptr, sizeof(DWORD));
++ptr;
- list_add_head(&shader->baseShader.constantsB, &lconst->entry);
+ list_add_head(&shader->constantsB, &lconst->entry);
reg_maps->local_bool_consts |= (1 << dst.reg.idx);
}
/* If there's a loop in the shader. */
@@ -821,7 +821,7 @@ static HRESULT shader_get_registers_used(IWineD3DBaseShaderImpl *shader, const s
}
reg_maps->loop_depth = max_loop_depth;
- shader->baseShader.functionLength = ((const char *)ptr - (const char *)byte_code);
+ shader->functionLength = ((const char *)ptr - (const char *)byte_code);
return WINED3D_OK;
}
@@ -1162,9 +1162,9 @@ void shader_dump_src_param(const struct wined3d_shader_src_param *param,
void shader_generate_main(IWineD3DBaseShaderImpl *shader, struct wined3d_shader_buffer *buffer,
const struct wined3d_shader_reg_maps *reg_maps, const DWORD *byte_code, void *backend_ctx)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
- const struct wined3d_shader_frontend *fe = shader->baseShader.frontend;
- void *fe_data = shader->baseShader.frontend_data;
+ IWineD3DDeviceImpl *device = shader->device;
+ const struct wined3d_shader_frontend *fe = shader->frontend;
+ void *fe_data = shader->frontend_data;
struct wined3d_shader_src_param dst_rel_addr[2];
struct wined3d_shader_src_param src_rel_addr[4];
struct wined3d_shader_dst_param dst_param[2];
@@ -1472,18 +1472,16 @@ static void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe
static void shader_cleanup(IWineD3DBaseShaderImpl *shader)
{
- shader->baseShader.device->shader_backend->shader_destroy(shader);
- HeapFree(GetProcessHeap(), 0, shader->baseShader.reg_maps.constf);
- HeapFree(GetProcessHeap(), 0, shader->baseShader.function);
- shader_delete_constant_list(&shader->baseShader.constantsF);
- shader_delete_constant_list(&shader->baseShader.constantsB);
- shader_delete_constant_list(&shader->baseShader.constantsI);
- list_remove(&shader->baseShader.shader_list_entry);
-
- if (shader->baseShader.frontend && shader->baseShader.frontend_data)
- {
- shader->baseShader.frontend->shader_free(shader->baseShader.frontend_data);
- }
+ shader->device->shader_backend->shader_destroy(shader);
+ HeapFree(GetProcessHeap(), 0, shader->reg_maps.constf);
+ HeapFree(GetProcessHeap(), 0, shader->function);
+ shader_delete_constant_list(&shader->constantsF);
+ shader_delete_constant_list(&shader->constantsB);
+ shader_delete_constant_list(&shader->constantsI);
+ list_remove(&shader->shader_list_entry);
+
+ if (shader->frontend && shader->frontend_data)
+ shader->frontend->shader_free(shader->frontend_data);
}
static void shader_none_handle_instruction(const struct wined3d_shader_instruction *ins) {}
@@ -1552,11 +1550,11 @@ static HRESULT shader_get_function(IWineD3DBaseShaderImpl *shader, void *data, U
{
if (!data)
{
- *data_size = shader->baseShader.functionLength;
+ *data_size = shader->functionLength;
return WINED3D_OK;
}
- if (*data_size < shader->baseShader.functionLength)
+ if (*data_size < shader->functionLength)
{
/* MSDN claims (for d3d8 at least) that if *pSizeOfData is smaller
* than the required size we should write the required size and
@@ -1564,7 +1562,7 @@ static HRESULT shader_get_function(IWineD3DBaseShaderImpl *shader, void *data, U
return WINED3DERR_INVALIDCALL;
}
- memcpy(data, shader->baseShader.function, shader->baseShader.functionLength);
+ memcpy(data, shader->function, shader->functionLength);
return WINED3D_OK;
}
@@ -1576,11 +1574,11 @@ static HRESULT shader_set_local_constants_float(IWineD3DBaseShaderImpl *shader,
UINT end_idx = start_idx + count;
UINT i;
- if (end_idx > shader->baseShader.limits.constant_float)
+ if (end_idx > shader->limits.constant_float)
{
WARN("end_idx %u > float constants limit %u.\n",
- end_idx, shader->baseShader.limits.constant_float);
- end_idx = shader->baseShader.limits.constant_float;
+ end_idx, shader->limits.constant_float);
+ end_idx = shader->limits.constant_float;
}
for (i = start_idx; i < end_idx; ++i)
@@ -1590,7 +1588,7 @@ static HRESULT shader_set_local_constants_float(IWineD3DBaseShaderImpl *shader,
lconst->idx = i;
memcpy(lconst->value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
- list_add_head(&shader->baseShader.constantsF, &lconst->entry);
+ list_add_head(&shader->constantsF, &lconst->entry);
}
return WINED3D_OK;
@@ -1599,7 +1597,7 @@ static HRESULT shader_set_local_constants_float(IWineD3DBaseShaderImpl *shader,
static HRESULT shader_set_function(IWineD3DBaseShaderImpl *shader, const DWORD *byte_code,
const struct wined3d_shader_signature *output_signature, DWORD float_const_count)
{
- struct wined3d_shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
+ struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
const struct wined3d_shader_frontend *fe;
HRESULT hr;
@@ -1612,31 +1610,33 @@ static HRESULT shader_set_function(IWineD3DBaseShaderImpl *shader, const DWORD *
FIXME("Unable to find frontend for shader.\n");
return WINED3DERR_INVALIDCALL;
}
- shader->baseShader.frontend = fe;
- shader->baseShader.frontend_data = fe->shader_init(byte_code, output_signature);
- if (!shader->baseShader.frontend_data)
+ shader->frontend = fe;
+ shader->frontend_data = fe->shader_init(byte_code, output_signature);
+ if (!shader->frontend_data)
{
FIXME("Failed to initialize frontend.\n");
return WINED3DERR_INVALIDCALL;
}
/* First pass: trace shader. */
- if (TRACE_ON(d3d_shader)) shader_trace_init(fe, shader->baseShader.frontend_data, byte_code);
+ if (TRACE_ON(d3d_shader))
+ shader_trace_init(fe, shader->frontend_data, byte_code);
/* Initialize immediate constant lists. */
- list_init(&shader->baseShader.constantsF);
- list_init(&shader->baseShader.constantsB);
- list_init(&shader->baseShader.constantsI);
+ list_init(&shader->constantsF);
+ list_init(&shader->constantsB);
+ list_init(&shader->constantsI);
/* Second pass: figure out which registers are used, what the semantics are, etc. */
hr = shader_get_registers_used(shader, fe,
- reg_maps, shader->baseShader.input_signature, shader->baseShader.output_signature,
+ reg_maps, shader->input_signature, shader->output_signature,
byte_code, float_const_count);
if (FAILED(hr)) return hr;
- shader->baseShader.function = HeapAlloc(GetProcessHeap(), 0, shader->baseShader.functionLength);
- if (!shader->baseShader.function) return E_OUTOFMEMORY;
- memcpy(shader->baseShader.function, byte_code, shader->baseShader.functionLength);
+ shader->function = HeapAlloc(GetProcessHeap(), 0, shader->functionLength);
+ if (!shader->function)
+ return E_OUTOFMEMORY;
+ memcpy(shader->function, byte_code, shader->functionLength);
return WINED3D_OK;
}
@@ -1664,7 +1664,7 @@ static HRESULT STDMETHODCALLTYPE wined3d_shader_QueryInterface(IWineD3DBaseShade
static ULONG STDMETHODCALLTYPE wined3d_shader_AddRef(IWineD3DBaseShader *iface)
{
IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)iface;
- ULONG refcount = InterlockedIncrement(&shader->baseShader.ref);
+ ULONG refcount = InterlockedIncrement(&shader->ref);
TRACE("%p increasing refcount to %u.\n", shader, refcount);
@@ -1675,14 +1675,14 @@ static ULONG STDMETHODCALLTYPE wined3d_shader_AddRef(IWineD3DBaseShader *iface)
static ULONG STDMETHODCALLTYPE wined3d_shader_Release(IWineD3DBaseShader *iface)
{
IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)iface;
- ULONG refcount = InterlockedDecrement(&shader->baseShader.ref);
+ ULONG refcount = InterlockedDecrement(&shader->ref);
TRACE("%p decreasing refcount to %u.\n", shader, refcount);
if (!refcount)
{
shader_cleanup(shader);
- shader->baseShader.parent_ops->wined3d_object_destroyed(shader->baseShader.parent);
+ shader->parent_ops->wined3d_object_destroyed(shader->parent);
HeapFree(GetProcessHeap(), 0, shader);
}
@@ -1693,7 +1693,7 @@ static void * STDMETHODCALLTYPE wined3d_shader_GetParent(IWineD3DBaseShader *ifa
{
TRACE("iface %p.\n", iface);
- return ((IWineD3DBaseShaderImpl *)iface)->baseShader.parent;
+ return ((IWineD3DBaseShaderImpl *)iface)->parent;
}
static HRESULT STDMETHODCALLTYPE wined3d_shader_GetFunction(IWineD3DBaseShader *iface, void *data, UINT *data_size)
@@ -1729,7 +1729,7 @@ void find_vs_compile_args(const struct wined3d_state *state,
== WINED3DFOG_NONE ? VS_FOG_COORD : VS_FOG_Z;
args->clip_enabled = state->render_states[WINED3DRS_CLIPPING]
&& state->render_states[WINED3DRS_CLIPPLANEENABLE];
- args->swizzle_map = shader->baseShader.device->strided_streams.swizzle_map;
+ args->swizzle_map = shader->device->strided_streams.swizzle_map;
}
static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2)
@@ -1745,7 +1745,7 @@ static BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_id
BOOL vshader_get_input(struct IWineD3DBaseShaderImpl *shader,
BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum)
{
- WORD map = shader->baseShader.reg_maps.input_registers;
+ WORD map = shader->reg_maps.input_registers;
unsigned int i;
for (i = 0; map; map >>= 1, ++i)
@@ -1764,41 +1764,41 @@ BOOL vshader_get_input(struct IWineD3DBaseShaderImpl *shader,
static void vertexshader_set_limits(IWineD3DBaseShaderImpl *shader)
{
- DWORD shader_version = WINED3D_SHADER_VERSION(shader->baseShader.reg_maps.shader_version.major,
- shader->baseShader.reg_maps.shader_version.minor);
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
+ shader->reg_maps.shader_version.minor);
+ IWineD3DDeviceImpl *device = shader->device;
- shader->baseShader.limits.texcoord = 0;
- shader->baseShader.limits.attributes = 16;
- shader->baseShader.limits.packed_input = 0;
+ shader->limits.texcoord = 0;
+ shader->limits.attributes = 16;
+ shader->limits.packed_input = 0;
switch (shader_version)
{
case WINED3D_SHADER_VERSION(1, 0):
case WINED3D_SHADER_VERSION(1, 1):
- shader->baseShader.limits.temporary = 12;
- shader->baseShader.limits.constant_bool = 0;
- shader->baseShader.limits.constant_int = 0;
- shader->baseShader.limits.address = 1;
- shader->baseShader.limits.packed_output = 12;
- shader->baseShader.limits.sampler = 0;
- shader->baseShader.limits.label = 0;
+ shader->limits.temporary = 12;
+ shader->limits.constant_bool = 0;
+ shader->limits.constant_int = 0;
+ shader->limits.address = 1;
+ shader->limits.packed_output = 12;
+ shader->limits.sampler = 0;
+ shader->limits.label = 0;
/* 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->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
break;
case WINED3D_SHADER_VERSION(2, 0):
case WINED3D_SHADER_VERSION(2, 1):
- shader->baseShader.limits.temporary = 12;
- shader->baseShader.limits.constant_bool = 16;
- shader->baseShader.limits.constant_int = 16;
- shader->baseShader.limits.address = 1;
- shader->baseShader.limits.packed_output = 12;
- shader->baseShader.limits.sampler = 0;
- shader->baseShader.limits.label = 16;
- shader->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.temporary = 12;
+ shader->limits.constant_bool = 16;
+ shader->limits.constant_int = 16;
+ shader->limits.address = 1;
+ shader->limits.packed_output = 12;
+ shader->limits.sampler = 0;
+ shader->limits.label = 16;
+ shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
break;
case WINED3D_SHADER_VERSION(4, 0):
@@ -1806,33 +1806,33 @@ static void vertexshader_set_limits(IWineD3DBaseShaderImpl *shader)
/* Fall through. */
case WINED3D_SHADER_VERSION(3, 0):
- shader->baseShader.limits.temporary = 32;
- shader->baseShader.limits.constant_bool = 32;
- shader->baseShader.limits.constant_int = 32;
- shader->baseShader.limits.address = 1;
- shader->baseShader.limits.packed_output = 12;
- shader->baseShader.limits.sampler = 4;
- shader->baseShader.limits.label = 16; /* FIXME: 2048 */
+ shader->limits.temporary = 32;
+ shader->limits.constant_bool = 32;
+ shader->limits.constant_int = 32;
+ shader->limits.address = 1;
+ shader->limits.packed_output = 12;
+ shader->limits.sampler = 4;
+ shader->limits.label = 16; /* FIXME: 2048 */
/* 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. */
- shader->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
break;
default:
- shader->baseShader.limits.temporary = 12;
- shader->baseShader.limits.constant_bool = 16;
- shader->baseShader.limits.constant_int = 16;
- shader->baseShader.limits.address = 1;
- shader->baseShader.limits.packed_output = 12;
- shader->baseShader.limits.sampler = 0;
- shader->baseShader.limits.label = 16;
- shader->baseShader.limits.constant_float = min(256, device->d3d_vshader_constantF);
+ shader->limits.temporary = 12;
+ shader->limits.constant_bool = 16;
+ shader->limits.constant_int = 16;
+ shader->limits.address = 1;
+ shader->limits.packed_output = 12;
+ shader->limits.sampler = 0;
+ shader->limits.label = 16;
+ shader->limits.constant_float = min(256, device->d3d_vshader_constantF);
FIXME("Unrecognized vertex shader version \"%u.%u\".\n",
- shader->baseShader.reg_maps.shader_version.major,
- shader->baseShader.reg_maps.shader_version.minor);
+ shader->reg_maps.shader_version.major,
+ shader->reg_maps.shader_version.minor);
}
}
@@ -1840,7 +1840,7 @@ HRESULT vertexshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *de
const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
void *parent, const struct wined3d_parent_ops *parent_ops)
{
- struct wined3d_shader_reg_maps *reg_maps = &shader->baseShader.reg_maps;
+ struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
unsigned int i;
HRESULT hr;
WORD map;
@@ -1848,7 +1848,7 @@ HRESULT vertexshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *de
if (!byte_code) return WINED3DERR_INVALIDCALL;
shader->lpVtbl = &wined3d_shader_vtbl;
- shader_init(&shader->baseShader, device, parent, parent_ops);
+ shader_init(shader, device, parent, parent_ops);
hr = shader_set_function(shader, byte_code, output_signature, device->d3d_vshader_constantF);
if (FAILED(hr))
@@ -1861,11 +1861,12 @@ HRESULT vertexshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *de
map = reg_maps->input_registers;
for (i = 0; map; map >>= 1, ++i)
{
- if (!(map & 1) || !shader->baseShader.input_signature[i].semantic_name) continue;
+ if (!(map & 1) || !shader->input_signature[i].semantic_name)
+ continue;
shader->u.vs.attributes[i].usage =
- shader_usage_from_semantic_name(shader->baseShader.input_signature[i].semantic_name);
- shader->u.vs.attributes[i].usage_idx = shader->baseShader.input_signature[i].semantic_idx;
+ shader_usage_from_semantic_name(shader->input_signature[i].semantic_name);
+ shader->u.vs.attributes[i].usage_idx = shader->input_signature[i].semantic_idx;
}
if (output_signature)
@@ -1874,14 +1875,14 @@ HRESULT vertexshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *de
{
struct wined3d_shader_signature_element *e = &output_signature->elements[i];
reg_maps->output_registers |= 1 << e->register_idx;
- shader->baseShader.output_signature[e->register_idx] = *e;
+ shader->output_signature[e->register_idx] = *e;
}
}
vertexshader_set_limits(shader);
- shader->baseShader.load_local_constsF = reg_maps->usesrelconstF
- && !list_empty(&shader->baseShader.constantsF);
+ shader->load_local_constsF = reg_maps->usesrelconstF
+ && !list_empty(&shader->constantsF);
return WINED3D_OK;
}
@@ -1893,7 +1894,7 @@ HRESULT geometryshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *
HRESULT hr;
shader->lpVtbl = &wined3d_shader_vtbl;
- shader_init(&shader->baseShader, device, parent, parent_ops);
+ shader_init(shader, device, parent, parent_ops);
hr = shader_set_function(shader, byte_code, output_signature, 0);
if (FAILED(hr))
@@ -1903,7 +1904,7 @@ HRESULT geometryshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *
return hr;
}
- shader->baseShader.load_local_constsF = FALSE;
+ shader->load_local_constsF = FALSE;
return WINED3D_OK;
}
@@ -1911,7 +1912,7 @@ HRESULT geometryshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *
void find_ps_compile_args(const struct wined3d_state *state,
IWineD3DBaseShaderImpl *shader, struct ps_compile_args *args)
{
- IWineD3DDeviceImpl *device = shader->baseShader.device;
+ IWineD3DDeviceImpl *device = shader->device;
const struct wined3d_texture *texture;
UINT i;
@@ -1922,8 +1923,8 @@ void find_ps_compile_args(const struct wined3d_state *state,
if (rt->resource.format->flags & WINED3DFMT_FLAG_SRGB_WRITE) args->srgb_correction = 1;
}
- if (shader->baseShader.reg_maps.shader_version.major == 1
- && shader->baseShader.reg_maps.shader_version.minor <= 3)
+ if (shader->reg_maps.shader_version.major == 1
+ && shader->reg_maps.shader_version.minor <= 3)
{
for (i = 0; i < 4; ++i)
{
@@ -1937,7 +1938,9 @@ void find_ps_compile_args(const struct wined3d_state *state,
for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
{
- if (!shader->baseShader.reg_maps.sampler_type[i]) continue;
+ if (!shader->reg_maps.sampler_type[i])
+ continue;
+
texture = state->textures[i];
if (!texture)
{
@@ -1953,7 +1956,7 @@ void find_ps_compile_args(const struct wined3d_state *state,
if (!(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
args->np2_fixup |= (1 << i);
}
- if (shader->baseShader.reg_maps.shader_version.major >= 3)
+ if (shader->reg_maps.shader_version.major >= 3)
{
if (device->strided_streams.position_transformed)
{
@@ -2006,12 +2009,12 @@ void find_ps_compile_args(const struct wined3d_state *state,
static void pixelshader_set_limits(IWineD3DBaseShaderImpl *shader)
{
- DWORD shader_version = WINED3D_SHADER_VERSION(shader->baseShader.reg_maps.shader_version.major,
- shader->baseShader.reg_maps.shader_version.minor);
+ DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
+ shader->reg_maps.shader_version.minor);
- shader->baseShader.limits.attributes = 0;
- shader->baseShader.limits.address = 0;
- shader->baseShader.limits.packed_output = 0;
+ shader->limits.attributes = 0;
+ shader->limits.address = 0;
+ shader->limits.packed_output = 0;
switch (shader_version)
{
@@ -2019,47 +2022,47 @@ static void pixelshader_set_limits(IWineD3DBaseShaderImpl *shader)
case WINED3D_SHADER_VERSION(1, 1):
case WINED3D_SHADER_VERSION(1, 2):
case WINED3D_SHADER_VERSION(1, 3):
- shader->baseShader.limits.temporary = 2;
- shader->baseShader.limits.constant_float = 8;
- shader->baseShader.limits.constant_int = 0;
- shader->baseShader.limits.constant_bool = 0;
- shader->baseShader.limits.texcoord = 4;
- shader->baseShader.limits.sampler = 4;
- shader->baseShader.limits.packed_input = 0;
- shader->baseShader.limits.label = 0;
+ shader->limits.temporary = 2;
+ shader->limits.constant_float = 8;
+ shader->limits.constant_int = 0;
+ shader->limits.constant_bool = 0;
+ shader->limits.texcoord = 4;
+ shader->limits.sampler = 4;
+ shader->limits.packed_input = 0;
+ shader->limits.label = 0;
break;
case WINED3D_SHADER_VERSION(1, 4):
- shader->baseShader.limits.temporary = 6;
- shader->baseShader.limits.constant_float = 8;
- shader->baseShader.limits.constant_int = 0;
- shader->baseShader.limits.constant_bool = 0;
- shader->baseShader.limits.texcoord = 6;
- shader->baseShader.limits.sampler = 6;
- shader->baseShader.limits.packed_input = 0;
- shader->baseShader.limits.label = 0;
+ shader->limits.temporary = 6;
+ shader->limits.constant_float = 8;
+ shader->limits.constant_int = 0;
+ shader->limits.constant_bool = 0;
+ shader->limits.texcoord = 6;
+ shader->limits.sampler = 6;
+ shader->limits.packed_input = 0;
+ shader->limits.label = 0;
break;
/* FIXME: Temporaries must match D3DPSHADERCAPS2_0.NumTemps. */
case WINED3D_SHADER_VERSION(2, 0):
- shader->baseShader.limits.temporary = 32;
- shader->baseShader.limits.constant_float = 32;
- shader->baseShader.limits.constant_int = 16;
- shader->baseShader.limits.constant_bool = 16;
- shader->baseShader.limits.texcoord = 8;
- shader->baseShader.limits.sampler = 16;
- shader->baseShader.limits.packed_input = 0;
+ shader->limits.temporary = 32;
+ shader->limits.constant_float = 32;
+ shader->limits.constant_int = 16;
+ shader->limits.constant_bool = 16;
+ shader->limits.texcoord = 8;
+ shader->limits.sampler = 16;
+ shader->limits.packed_input = 0;
break;
case WINED3D_SHADER_VERSION(2, 1):
- shader->baseShader.limits.temporary = 32;
- shader->baseShader.limits.constant_float = 32;
- shader->baseShader.limits.constant_int = 16;
- shader->baseShader.limits.constant_bool = 16;
- shader->baseShader.limits.texcoord = 8;
- shader->baseShader.limits.sampler = 16;
- shader->baseShader.limits.packed_input = 0;
- shader->baseShader.limits.label = 16;
+ shader->limits.temporary = 32;
+ shader->limits.constant_float = 32;
+ shader->limits.constant_int = 16;
+ shader->limits.constant_bool = 16;
+ shader->limits.texcoord = 8;
+ shader->limits.sampler = 16;
+ shader->limits.packed_input = 0;
+ shader->limits.label = 16;
break;
case WINED3D_SHADER_VERSION(4, 0):
@@ -2067,28 +2070,28 @@ static void pixelshader_set_limits(IWineD3DBaseShaderImpl *shader)
/* Fall through. */
case WINED3D_SHADER_VERSION(3, 0):
- shader->baseShader.limits.temporary = 32;
- shader->baseShader.limits.constant_float = 224;
- shader->baseShader.limits.constant_int = 16;
- shader->baseShader.limits.constant_bool = 16;
- shader->baseShader.limits.texcoord = 0;
- shader->baseShader.limits.sampler = 16;
- shader->baseShader.limits.packed_input = 12;
- shader->baseShader.limits.label = 16; /* FIXME: 2048 */
+ shader->limits.temporary = 32;
+ shader->limits.constant_float = 224;
+ shader->limits.constant_int = 16;
+ shader->limits.constant_bool = 16;
+ shader->limits.texcoord = 0;
+ shader->limits.sampler = 16;
+ shader->limits.packed_input = 12;
+ shader->limits.label = 16; /* FIXME: 2048 */
break;
default:
- shader->baseShader.limits.temporary = 32;
- shader->baseShader.limits.constant_float = 32;
- shader->baseShader.limits.constant_int = 16;
- shader->baseShader.limits.constant_bool = 16;
- shader->baseShader.limits.texcoord = 8;
- shader->baseShader.limits.sampler = 16;
- shader->baseShader.limits.packed_input = 0;
- shader->baseShader.limits.label = 0;
+ shader->limits.temporary = 32;
+ shader->limits.constant_float = 32;
+ shader->limits.constant_int = 16;
+ shader->limits.constant_bool = 16;
+ shader->limits.texcoord = 8;
+ shader->limits.sampler = 16;
+ shader->limits.packed_input = 0;
+ shader->limits.label = 0;
FIXME("Unrecognized pixel shader version %u.%u\n",
- shader->baseShader.reg_maps.shader_version.major,
- shader->baseShader.reg_maps.shader_version.minor);
+ shader->reg_maps.shader_version.major,
+ shader->reg_maps.shader_version.minor);
}
}
@@ -2103,7 +2106,7 @@ HRESULT pixelshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *dev
if (!byte_code) return WINED3DERR_INVALIDCALL;
shader->lpVtbl = &wined3d_shader_vtbl;
- shader_init(&shader->baseShader, device, parent, parent_ops);
+ shader_init(shader, device, parent, parent_ops);
hr = shader_set_function(shader, byte_code, output_signature, device->d3d_pshader_constantF);
if (FAILED(hr))
@@ -2155,7 +2158,7 @@ HRESULT pixelshader_init(IWineD3DBaseShaderImpl *shader, IWineD3DDeviceImpl *dev
}
}
- shader->baseShader.load_local_constsF = FALSE;
+ shader->load_local_constsF = FALSE;
return WINED3D_OK;
}
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 45eabb1..8a6f451 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -3571,7 +3571,7 @@ static void tex_bumpenvlscale(DWORD state, struct wined3d_stateblock *stateblock
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
IWineD3DBaseShaderImpl *ps = stateblock->state.pixel_shader;
- if (ps && stage && (ps->baseShader.reg_maps.luminanceparams & (1 << stage)))
+ if (ps && stage && (ps->reg_maps.luminanceparams & (1 << stage)))
{
/* The pixel shader has to know the luminance scale. Do a constants update if it
* isn't scheduled anyway
@@ -3742,7 +3742,7 @@ static void shader_bumpenvmat(DWORD state, struct wined3d_stateblock *stateblock
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
IWineD3DBaseShaderImpl *ps = stateblock->state.pixel_shader;
- if (ps && stage && (ps->baseShader.reg_maps.bumpmat & (1 << stage)))
+ if (ps && stage && (ps->reg_maps.bumpmat & (1 << stage)))
{
/* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
* anyway
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 3ca570d..e5fe1d0 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -2685,41 +2685,6 @@ int shader_vaddline(struct wined3d_shader_buffer *buffer, const char *fmt, va_li
extern BOOL vshader_get_input(struct IWineD3DBaseShaderImpl *shader,
BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum) DECLSPEC_HIDDEN;
-/*****************************************************************************
- * IDirect3DBaseShader implementation structure
- */
-typedef struct IWineD3DBaseShaderClass
-{
- LONG ref;
- SHADER_LIMITS limits;
- DWORD *function;
- UINT functionLength;
- BOOL load_local_constsF;
- const struct wined3d_shader_frontend *frontend;
- void *frontend_data;
- void *backend_data;
-
- void *parent;
- const struct wined3d_parent_ops *parent_ops;
-
- /* Programs this shader is linked with */
- struct list linked_programs;
-
- /* Immediate constants (override global ones) */
- struct list constantsB;
- struct list constantsF;
- struct list constantsI;
- struct wined3d_shader_reg_maps reg_maps;
-
- struct wined3d_shader_signature_element input_signature[max(MAX_ATTRIBS, MAX_REG_INPUT)];
- struct wined3d_shader_signature_element output_signature[MAX_REG_OUTPUT];
-
- /* Pointer to the parent device */
- struct IWineD3DDeviceImpl *device;
- struct list shader_list_entry;
-
-} IWineD3DBaseShaderClass;
-
struct wined3d_vertex_shader
{
struct wined3d_shader_attribute attributes[MAX_ATTRIBS];
@@ -2742,8 +2707,33 @@ typedef struct IWineD3DBaseShaderImpl {
/* IUnknown */
const IWineD3DBaseShaderVtbl *lpVtbl;
- /* IWineD3DBaseShader */
- IWineD3DBaseShaderClass baseShader;
+ LONG ref;
+ SHADER_LIMITS limits;
+ DWORD *function;
+ UINT functionLength;
+ BOOL load_local_constsF;
+ const struct wined3d_shader_frontend *frontend;
+ void *frontend_data;
+ void *backend_data;
+
+ void *parent;
+ const struct wined3d_parent_ops *parent_ops;
+
+ /* Programs this shader is linked with */
+ struct list linked_programs;
+
+ /* Immediate constants (override global ones) */
+ struct list constantsB;
+ struct list constantsF;
+ struct list constantsI;
+ struct wined3d_shader_reg_maps reg_maps;
+
+ struct wined3d_shader_signature_element input_signature[max(MAX_ATTRIBS, MAX_REG_INPUT)];
+ struct wined3d_shader_signature_element output_signature[MAX_REG_OUTPUT];
+
+ /* Pointer to the parent device */
+ struct IWineD3DDeviceImpl *device;
+ struct list shader_list_entry;
union
{
@@ -2843,15 +2833,20 @@ static inline void shader_get_position_fixup(const struct wined3d_context *conte
}
}
-static inline BOOL shader_constant_is_local(IWineD3DBaseShaderImpl* This, DWORD reg) {
- local_constant* lconst;
+static inline BOOL shader_constant_is_local(IWineD3DBaseShaderImpl *shader, DWORD reg)
+{
+ struct local_constant *lconst;
+
+ if (shader->load_local_constsF)
+ return FALSE;
- if(This->baseShader.load_local_constsF) return FALSE;
- LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
- if(lconst->idx == reg) return TRUE;
+ LIST_FOR_EACH_ENTRY(lconst, &shader->constantsF, local_constant, entry)
+ {
+ if (lconst->idx == reg)
+ return TRUE;
}
- return FALSE;
+ return FALSE;
}
/* Using additional shader constants (uniforms in GLSL / program environment
--
1.7.3.4
More information about the wine-patches
mailing list