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

wined3d: Pass a wined3d_string_buffer to shader_glsl_get_register_name(). 

Instead of hoping that 150 characters is plenty.

Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Henri Verbeet 2018-08-15 14:26:24 +04:30 committed by Alexandre Julliard
parent c90ce7b9a3
commit cee95b7853
1 changed files with 129 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
dlls/wined3d/glsl_shader.c
View File

@ -2844,22 +2844,22 @@ static void shader_glsl_gen_modifier(enum wined3d_shader_src_modifier src_modifi
} }
} }
static void shader_glsl_fixup_scalar_register_variable(char *register_name, static void shader_glsl_fixup_scalar_register_variable(struct wined3d_string_buffer *register_name,
const char *glsl_variable, const struct wined3d_gl_info *gl_info) const char *glsl_variable, const struct wined3d_gl_info *gl_info)
{ {
/* The ARB_shading_language_420pack extension allows swizzle operations on /* The ARB_shading_language_420pack extension allows swizzle operations on
* scalars. */ * scalars. */
if (gl_info->supported[ARB_SHADING_LANGUAGE_420PACK]) if (gl_info->supported[ARB_SHADING_LANGUAGE_420PACK])
sprintf(register_name, "%s", glsl_variable); string_buffer_sprintf(register_name, "%s", glsl_variable);
else else
sprintf(register_name, "ivec2(%s, 0)", glsl_variable); string_buffer_sprintf(register_name, "ivec2(%s, 0)", glsl_variable);
} }
/** Writes the GLSL variable name that corresponds to the register that the /** Writes the GLSL variable name that corresponds to the register that the
* DX opcode parameter is trying to access */ * DX opcode parameter is trying to access */
static void shader_glsl_get_register_name(const struct wined3d_shader_register *reg, static void shader_glsl_get_register_name(const struct wined3d_shader_register *reg,
enum wined3d_data_type data_type, char *register_name, BOOL *is_swizzled, enum wined3d_data_type data_type, struct wined3d_string_buffer *register_name,
const struct wined3d_shader_context *ctx) BOOL *is_swizzled, const struct wined3d_shader_context *ctx)
{ {
/* oPos, oFog and oPts in D3D */ /* oPos, oFog and oPts in D3D */
static const char * const hwrastout_reg_names[] = {"vs_out[10]", "vs_out[11].x", "vs_out[11].y"}; static const char * const hwrastout_reg_names[] = {"vs_out[10]", "vs_out[11].x", "vs_out[11].y"};
@ -2884,7 +2884,7 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
switch (reg->type) switch (reg->type)
{ {
case WINED3DSPR_TEMP: case WINED3DSPR_TEMP:
sprintf(register_name, "R%u", reg->idx[0].offset); string_buffer_sprintf(register_name, "R%u", reg->idx[0].offset);
break; break;
case WINED3DSPR_INPUT: case WINED3DSPR_INPUT:
@ -2899,12 +2899,12 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
*is_swizzled = TRUE; *is_swizzled = TRUE;
if (reg->idx[0].rel_addr) if (reg->idx[0].rel_addr)
{ {
sprintf(register_name, "%s_in[%s + %u]", string_buffer_sprintf(register_name, "%s_in[%s + %u]",
prefix, rel_param0.param_str, reg->idx[0].offset); prefix, rel_param0.param_str, reg->idx[0].offset);
} }
else else
{ {
sprintf(register_name, "%s_in%u", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_in%u", prefix, reg->idx[0].offset);
} }
break; break;
} }
@ -2916,19 +2916,19 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
if (reg->idx[0].rel_addr) if (reg->idx[0].rel_addr)
{ {
if (reg->idx[1].rel_addr) if (reg->idx[1].rel_addr)
sprintf(register_name, "shader_in[%s + %u].reg[%s + %u]", string_buffer_sprintf(register_name, "shader_in[%s + %u].reg[%s + %u]",
rel_param0.param_str, reg->idx[0].offset, rel_param0.param_str, reg->idx[0].offset,
rel_param1.param_str, reg->idx[1].offset); rel_param1.param_str, reg->idx[1].offset);
else else
sprintf(register_name, "shader_in[%s + %u].reg[%u]", string_buffer_sprintf(register_name, "shader_in[%s + %u].reg[%u]",
rel_param0.param_str, reg->idx[0].offset, rel_param0.param_str, reg->idx[0].offset,
reg->idx[1].offset); reg->idx[1].offset);
} }
else if (reg->idx[1].rel_addr) else if (reg->idx[1].rel_addr)
sprintf(register_name, "shader_in[%u].reg[%s + %u]", reg->idx[0].offset, string_buffer_sprintf(register_name, "shader_in[%u].reg[%s + %u]", reg->idx[0].offset,
rel_param1.param_str, reg->idx[1].offset); rel_param1.param_str, reg->idx[1].offset);
else else
sprintf(register_name, "shader_in[%u].reg[%u]", string_buffer_sprintf(register_name, "shader_in[%u].reg[%u]",
reg->idx[0].offset, reg->idx[1].offset); reg->idx[0].offset, reg->idx[1].offset);
break; break;
} }
@ -2948,14 +2948,14 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
if (needs_legacy_glsl_syntax(gl_info) if (needs_legacy_glsl_syntax(gl_info)
&& shader->u.ps.declared_in_count > in_count) && shader->u.ps.declared_in_count > in_count)
{ {
sprintf(register_name, string_buffer_sprintf(register_name,
"((%s + %u) > %u ? (%s + %u) > %u ? gl_SecondaryColor : gl_Color : %s_in[%s + %u])", "((%s + %u) > %u ? (%s + %u) > %u ? gl_SecondaryColor : gl_Color : %s_in[%s + %u])",
rel_param0.param_str, idx, in_count - 1, rel_param0.param_str, idx, in_count, rel_param0.param_str, idx, in_count - 1, rel_param0.param_str, idx, in_count,
prefix, rel_param0.param_str, idx); prefix, rel_param0.param_str, idx);
} }
else else
{ {
sprintf(register_name, "%s_in[%s + %u]", prefix, rel_param0.param_str, idx); string_buffer_sprintf(register_name, "%s_in[%s + %u]", prefix, rel_param0.param_str, idx);
} }
} }
else else
@ -2963,29 +2963,33 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
if (needs_legacy_glsl_syntax(gl_info) if (needs_legacy_glsl_syntax(gl_info)
&& shader->u.ps.declared_in_count > in_count) && shader->u.ps.declared_in_count > in_count)
{ {
sprintf(register_name, "((%s) > %u ? (%s) > %u ? gl_SecondaryColor : gl_Color : %s_in[%s])", string_buffer_sprintf(register_name,
"((%s) > %u ? (%s) > %u ? gl_SecondaryColor : gl_Color : %s_in[%s])",
rel_param0.param_str, in_count - 1, rel_param0.param_str, in_count, rel_param0.param_str, in_count - 1, rel_param0.param_str, in_count,
prefix, rel_param0.param_str); prefix, rel_param0.param_str);
} }
else else
{ {
sprintf(register_name, "%s_in[%s]", prefix, rel_param0.param_str); string_buffer_sprintf(register_name, "%s_in[%s]", prefix, rel_param0.param_str);
} }
} }
} }
else else
{ {
if (idx == in_count) sprintf(register_name, "gl_Color"); if (idx == in_count)
else if (idx == in_count + 1) sprintf(register_name, "gl_SecondaryColor"); string_buffer_sprintf(register_name, "gl_Color");
else sprintf(register_name, "%s_in[%u]", prefix, idx); else if (idx == in_count + 1)
string_buffer_sprintf(register_name, "gl_SecondaryColor");
else
string_buffer_sprintf(register_name, "%s_in[%u]", prefix, idx);
} }
} }
else else
{ {
if (!reg->idx[0].offset) if (!reg->idx[0].offset)
strcpy(register_name, "ffp_varying_diffuse"); string_buffer_sprintf(register_name, "ffp_varying_diffuse");
else else
strcpy(register_name, "ffp_varying_specular"); string_buffer_sprintf(register_name, "ffp_varying_specular");
break; break;
} }
break; break;
@ -2996,46 +3000,48 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
if (reg->idx[0].rel_addr) if (reg->idx[0].rel_addr)
{ {
if (wined3d_settings.check_float_constants) if (wined3d_settings.check_float_constants)
sprintf(register_name, "(%s + %u >= 0 && %s + %u < %u ? %s_c[%s + %u] : vec4(0.0))", string_buffer_sprintf(register_name,
"(%s + %u >= 0 && %s + %u < %u ? %s_c[%s + %u] : vec4(0.0))",
rel_param0.param_str, reg->idx[0].offset, rel_param0.param_str, reg->idx[0].offset,
rel_param0.param_str, reg->idx[0].offset, shader->limits->constant_float, rel_param0.param_str, reg->idx[0].offset, shader->limits->constant_float,
prefix, rel_param0.param_str, reg->idx[0].offset); prefix, rel_param0.param_str, reg->idx[0].offset);
else if (reg->idx[0].offset) else if (reg->idx[0].offset)
sprintf(register_name, "%s_c[%s + %u]", prefix, rel_param0.param_str, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_c[%s + %u]",
prefix, rel_param0.param_str, reg->idx[0].offset);
else else
sprintf(register_name, "%s_c[%s]", prefix, rel_param0.param_str); string_buffer_sprintf(register_name, "%s_c[%s]", prefix, rel_param0.param_str);
} }
else else
{ {
if (shader_constant_is_local(shader, reg->idx[0].offset)) if (shader_constant_is_local(shader, reg->idx[0].offset))
sprintf(register_name, "%s_lc%u", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_lc%u", prefix, reg->idx[0].offset);
else else
sprintf(register_name, "%s_c[%u]", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_c[%u]", prefix, reg->idx[0].offset);
} }
} }
break; break;
case WINED3DSPR_CONSTINT: case WINED3DSPR_CONSTINT:
sprintf(register_name, "%s_i[%u]", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_i[%u]", prefix, reg->idx[0].offset);
break; break;
case WINED3DSPR_CONSTBOOL: case WINED3DSPR_CONSTBOOL:
sprintf(register_name, "%s_b[%u]", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_b[%u]", prefix, reg->idx[0].offset);
break; break;
case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */ case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
if (version->type == WINED3D_SHADER_TYPE_PIXEL) if (version->type == WINED3D_SHADER_TYPE_PIXEL)
sprintf(register_name, "T%u", reg->idx[0].offset); string_buffer_sprintf(register_name, "T%u", reg->idx[0].offset);
else else
sprintf(register_name, "A%u", reg->idx[0].offset); string_buffer_sprintf(register_name, "A%u", reg->idx[0].offset);
break; break;
case WINED3DSPR_LOOP: case WINED3DSPR_LOOP:
sprintf(register_name, "aL%u", ctx->state->current_loop_reg - 1); string_buffer_sprintf(register_name, "aL%u", ctx->state->current_loop_reg - 1);
break; break;
case WINED3DSPR_SAMPLER: case WINED3DSPR_SAMPLER:
sprintf(register_name, "%s_sampler%u", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_sampler%u", prefix, reg->idx[0].offset);
break; break;
case WINED3DSPR_COLOROUT: case WINED3DSPR_COLOROUT:
@ -3043,51 +3049,51 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
WARN("Write to render target %u, only %d supported.\n", WARN("Write to render target %u, only %d supported.\n",
reg->idx[0].offset, gl_info->limits.buffers); reg->idx[0].offset, gl_info->limits.buffers);
sprintf(register_name, "%s[%u]", get_fragment_output(gl_info), reg->idx[0].offset); string_buffer_sprintf(register_name, "%s[%u]", get_fragment_output(gl_info), reg->idx[0].offset);
break; break;
case WINED3DSPR_RASTOUT: case WINED3DSPR_RASTOUT:
sprintf(register_name, "%s", hwrastout_reg_names[reg->idx[0].offset]); string_buffer_sprintf(register_name, "%s", hwrastout_reg_names[reg->idx[0].offset]);
break; break;
case WINED3DSPR_DEPTHOUT: case WINED3DSPR_DEPTHOUT:
case WINED3DSPR_DEPTHOUTGE: case WINED3DSPR_DEPTHOUTGE:
case WINED3DSPR_DEPTHOUTLE: case WINED3DSPR_DEPTHOUTLE:
sprintf(register_name, "gl_FragDepth"); string_buffer_sprintf(register_name, "gl_FragDepth");
break; break;
case WINED3DSPR_ATTROUT: case WINED3DSPR_ATTROUT:
if (!reg->idx[0].offset) if (!reg->idx[0].offset)
sprintf(register_name, "%s_out[8]", prefix); string_buffer_sprintf(register_name, "%s_out[8]", prefix);
else else
sprintf(register_name, "%s_out[9]", prefix); string_buffer_sprintf(register_name, "%s_out[9]", prefix);
break; break;
case WINED3DSPR_TEXCRDOUT: case WINED3DSPR_TEXCRDOUT:
/* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */ /* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
if (reg->idx[0].rel_addr) if (reg->idx[0].rel_addr)
sprintf(register_name, "%s_out[%s + %u]", string_buffer_sprintf(register_name, "%s_out[%s + %u]",
prefix, rel_param0.param_str, reg->idx[0].offset); prefix, rel_param0.param_str, reg->idx[0].offset);
else else
sprintf(register_name, "%s_out[%u]", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_out[%u]", prefix, reg->idx[0].offset);
break; break;
case WINED3DSPR_MISCTYPE: case WINED3DSPR_MISCTYPE:
if (!reg->idx[0].offset) if (!reg->idx[0].offset)
{ {
/* vPos */ /* vPos */
sprintf(register_name, "vpos"); string_buffer_sprintf(register_name, "vpos");
} }
else if (reg->idx[0].offset == 1) else if (reg->idx[0].offset == 1)
{ {
/* Note that gl_FrontFacing is a bool, while vFace is /* Note that gl_FrontFacing is a bool, while vFace is
* a float for which the sign determines front/back */ * a float for which the sign determines front/back */
sprintf(register_name, "(gl_FrontFacing ? 1.0 : -1.0)"); string_buffer_sprintf(register_name, "(gl_FrontFacing ? 1.0 : -1.0)");
} }
else else
{ {
FIXME("Unhandled misctype register %u.\n", reg->idx[0].offset); FIXME("Unhandled misctype register %u.\n", reg->idx[0].offset);
sprintf(register_name, "unrecognized_register"); string_buffer_sprintf(register_name, "unrecognized_register");
} }
break; break;
@ -3101,20 +3107,25 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
case WINED3D_DATA_SNORM: case WINED3D_DATA_SNORM:
case WINED3D_DATA_FLOAT: case WINED3D_DATA_FLOAT:
if (gl_info->supported[ARB_SHADER_BIT_ENCODING]) if (gl_info->supported[ARB_SHADER_BIT_ENCODING])
sprintf(register_name, "uintBitsToFloat(%#xu)", reg->u.immconst_data[0]); {
string_buffer_sprintf(register_name, "uintBitsToFloat(%#xu)", reg->u.immconst_data[0]);
}
else else
wined3d_ftoa(*(const float *)reg->u.immconst_data, register_name); {
wined3d_ftoa(*(const float *)reg->u.immconst_data, imm_str[0]);
string_buffer_sprintf(register_name, "%s", imm_str[0]);
}
break; break;
case WINED3D_DATA_INT: case WINED3D_DATA_INT:
sprintf(register_name, "%#x", reg->u.immconst_data[0]); string_buffer_sprintf(register_name, "%#x", reg->u.immconst_data[0]);
break; break;
case WINED3D_DATA_RESOURCE: case WINED3D_DATA_RESOURCE:
case WINED3D_DATA_SAMPLER: case WINED3D_DATA_SAMPLER:
case WINED3D_DATA_UINT: case WINED3D_DATA_UINT:
sprintf(register_name, "%#xu", reg->u.immconst_data[0]); string_buffer_sprintf(register_name, "%#xu", reg->u.immconst_data[0]);
break; break;
default: default:
sprintf(register_name, "<unhandled data type %#x>", data_type); string_buffer_sprintf(register_name, "<unhandled data type %#x>", data_type);
break; break;
} }
break; break;
@ -3127,7 +3138,7 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
case WINED3D_DATA_FLOAT: case WINED3D_DATA_FLOAT:
if (gl_info->supported[ARB_SHADER_BIT_ENCODING]) if (gl_info->supported[ARB_SHADER_BIT_ENCODING])
{ {
sprintf(register_name, "uintBitsToFloat(uvec4(%#xu, %#xu, %#xu, %#xu))", string_buffer_sprintf(register_name, "uintBitsToFloat(uvec4(%#xu, %#xu, %#xu, %#xu))",
reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[0], reg->u.immconst_data[1],
reg->u.immconst_data[2], reg->u.immconst_data[3]); reg->u.immconst_data[2], reg->u.immconst_data[3]);
} }
@ -3137,61 +3148,63 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
wined3d_ftoa(*(const float *)&reg->u.immconst_data[1], imm_str[1]); wined3d_ftoa(*(const float *)&reg->u.immconst_data[1], imm_str[1]);
wined3d_ftoa(*(const float *)&reg->u.immconst_data[2], imm_str[2]); wined3d_ftoa(*(const float *)&reg->u.immconst_data[2], imm_str[2]);
wined3d_ftoa(*(const float *)&reg->u.immconst_data[3], imm_str[3]); wined3d_ftoa(*(const float *)&reg->u.immconst_data[3], imm_str[3]);
sprintf(register_name, "vec4(%s, %s, %s, %s)", string_buffer_sprintf(register_name, "vec4(%s, %s, %s, %s)",
imm_str[0], imm_str[1], imm_str[2], imm_str[3]); imm_str[0], imm_str[1], imm_str[2], imm_str[3]);
} }
break; break;
case WINED3D_DATA_INT: case WINED3D_DATA_INT:
sprintf(register_name, "ivec4(%#x, %#x, %#x, %#x)", string_buffer_sprintf(register_name, "ivec4(%#x, %#x, %#x, %#x)",
reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[0], reg->u.immconst_data[1],
reg->u.immconst_data[2], reg->u.immconst_data[3]); reg->u.immconst_data[2], reg->u.immconst_data[3]);
break; break;
case WINED3D_DATA_RESOURCE: case WINED3D_DATA_RESOURCE:
case WINED3D_DATA_SAMPLER: case WINED3D_DATA_SAMPLER:
case WINED3D_DATA_UINT: case WINED3D_DATA_UINT:
sprintf(register_name, "uvec4(%#xu, %#xu, %#xu, %#xu)", string_buffer_sprintf(register_name, "uvec4(%#xu, %#xu, %#xu, %#xu)",
reg->u.immconst_data[0], reg->u.immconst_data[1], reg->u.immconst_data[0], reg->u.immconst_data[1],
reg->u.immconst_data[2], reg->u.immconst_data[3]); reg->u.immconst_data[2], reg->u.immconst_data[3]);
break; break;
default: default:
sprintf(register_name, "<unhandled data type %#x>", data_type); string_buffer_sprintf(register_name, "<unhandled data type %#x>", data_type);
break; break;
} }
break; break;
default: default:
FIXME("Unhandled immconst type %#x\n", reg->immconst_type); FIXME("Unhandled immconst type %#x\n", reg->immconst_type);
sprintf(register_name, "<unhandled_immconst_type %#x>", reg->immconst_type); string_buffer_sprintf(register_name, "<unhandled_immconst_type %#x>", reg->immconst_type);
} }
break; break;
case WINED3DSPR_CONSTBUFFER: case WINED3DSPR_CONSTBUFFER:
if (reg->idx[1].rel_addr) if (reg->idx[1].rel_addr)
sprintf(register_name, "%s_cb%u[%s + %u]", string_buffer_sprintf(register_name, "%s_cb%u[%s + %u]",
prefix, reg->idx[0].offset, rel_param1.param_str, reg->idx[1].offset); prefix, reg->idx[0].offset, rel_param1.param_str, reg->idx[1].offset);
else else
sprintf(register_name, "%s_cb%u[%u]", prefix, reg->idx[0].offset, reg->idx[1].offset); string_buffer_sprintf(register_name, "%s_cb%u[%u]", prefix, reg->idx[0].offset, reg->idx[1].offset);
break; break;
case WINED3DSPR_IMMCONSTBUFFER: case WINED3DSPR_IMMCONSTBUFFER:
if (reg->idx[0].rel_addr) if (reg->idx[0].rel_addr)
sprintf(register_name, "%s_icb[%s + %u]", prefix, rel_param0.param_str, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_icb[%s + %u]",
prefix, rel_param0.param_str, reg->idx[0].offset);
else else
sprintf(register_name, "%s_icb[%u]", prefix, reg->idx[0].offset); string_buffer_sprintf(register_name, "%s_icb[%u]", prefix, reg->idx[0].offset);
break; break;
case WINED3DSPR_PRIMID: case WINED3DSPR_PRIMID:
if (version->type == WINED3D_SHADER_TYPE_GEOMETRY) if (version->type == WINED3D_SHADER_TYPE_GEOMETRY)
sprintf(register_name, "gl_PrimitiveIDIn"); string_buffer_sprintf(register_name, "gl_PrimitiveIDIn");
else else
sprintf(register_name, "gl_PrimitiveID"); string_buffer_sprintf(register_name, "gl_PrimitiveID");
break; break;
case WINED3DSPR_IDXTEMP: case WINED3DSPR_IDXTEMP:
if (reg->idx[1].rel_addr) if (reg->idx[1].rel_addr)
sprintf(register_name, "X%u[%s + %u]", reg->idx[0].offset, rel_param1.param_str, reg->idx[1].offset); string_buffer_sprintf(register_name, "X%u[%s + %u]",
reg->idx[0].offset, rel_param1.param_str, reg->idx[1].offset);
else else
sprintf(register_name, "X%u[%u]", reg->idx[0].offset, reg->idx[1].offset); string_buffer_sprintf(register_name, "X%u[%u]", reg->idx[0].offset, reg->idx[1].offset);
break; break;
case WINED3DSPR_LOCALTHREADINDEX: case WINED3DSPR_LOCALTHREADINDEX:
@ -3206,15 +3219,15 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
break; break;
case WINED3DSPR_THREADID: case WINED3DSPR_THREADID:
sprintf(register_name, "ivec3(gl_GlobalInvocationID)"); string_buffer_sprintf(register_name, "ivec3(gl_GlobalInvocationID)");
break; break;
case WINED3DSPR_THREADGROUPID: case WINED3DSPR_THREADGROUPID:
sprintf(register_name, "ivec3(gl_WorkGroupID)"); string_buffer_sprintf(register_name, "ivec3(gl_WorkGroupID)");
break; break;
case WINED3DSPR_LOCALTHREADID: case WINED3DSPR_LOCALTHREADID:
sprintf(register_name, "ivec3(gl_LocalInvocationID)"); string_buffer_sprintf(register_name, "ivec3(gl_LocalInvocationID)");
break; break;
case WINED3DSPR_FORKINSTID: case WINED3DSPR_FORKINSTID:
@ -3224,48 +3237,48 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
break; break;
case WINED3DSPR_TESSCOORD: case WINED3DSPR_TESSCOORD:
sprintf(register_name, "gl_TessCoord"); string_buffer_sprintf(register_name, "gl_TessCoord");
break; break;
case WINED3DSPR_OUTCONTROLPOINT: case WINED3DSPR_OUTCONTROLPOINT:
if (reg->idx[0].rel_addr) if (reg->idx[0].rel_addr)
{ {
if (reg->idx[1].rel_addr) if (reg->idx[1].rel_addr)
sprintf(register_name, "shader_out[%s + %u].reg[%s + %u]", string_buffer_sprintf(register_name, "shader_out[%s + %u].reg[%s + %u]",
rel_param0.param_str, reg->idx[0].offset, rel_param0.param_str, reg->idx[0].offset,
rel_param1.param_str, reg->idx[1].offset); rel_param1.param_str, reg->idx[1].offset);
else else
sprintf(register_name, "shader_out[%s + %u].reg[%u]", string_buffer_sprintf(register_name, "shader_out[%s + %u].reg[%u]",
rel_param0.param_str, reg->idx[0].offset, rel_param0.param_str, reg->idx[0].offset,
reg->idx[1].offset); reg->idx[1].offset);
} }
else if (reg->idx[1].rel_addr) else if (reg->idx[1].rel_addr)
{ {
sprintf(register_name, "shader_out[%u].reg[%s + %u]", string_buffer_sprintf(register_name, "shader_out[%u].reg[%s + %u]",
reg->idx[0].offset, rel_param1.param_str, reg->idx[0].offset, rel_param1.param_str,
reg->idx[1].offset); reg->idx[1].offset);
} }
else else
{ {
sprintf(register_name, "shader_out[%u].reg[%u]", string_buffer_sprintf(register_name, "shader_out[%u].reg[%u]",
reg->idx[0].offset, reg->idx[1].offset); reg->idx[0].offset, reg->idx[1].offset);
} }
break; break;
case WINED3DSPR_PATCHCONST: case WINED3DSPR_PATCHCONST:
if (version->type == WINED3D_SHADER_TYPE_HULL) if (version->type == WINED3D_SHADER_TYPE_HULL)
sprintf(register_name, "hs_out[%u]", reg->idx[0].offset); string_buffer_sprintf(register_name, "hs_out[%u]", reg->idx[0].offset);
else else
sprintf(register_name, "vpc[%u]", reg->idx[0].offset); string_buffer_sprintf(register_name, "vpc[%u]", reg->idx[0].offset);
break; break;
case WINED3DSPR_SAMPLEMASK: case WINED3DSPR_SAMPLEMASK:
sprintf(register_name, "sample_mask"); string_buffer_sprintf(register_name, "sample_mask");
break; break;
default: default:
FIXME("Unhandled register type %#x.\n", reg->type); FIXME("Unhandled register type %#x.\n", reg->type);
sprintf(register_name, "unrecognized_register"); string_buffer_sprintf(register_name, "unrecognised_register");
break; break;
} }
} }
@ -3394,12 +3407,11 @@ static void shader_glsl_add_src_param_ext(const struct wined3d_shader_context *c
{ {
struct shader_glsl_ctx_priv *priv = ctx->backend_data; struct shader_glsl_ctx_priv *priv = ctx->backend_data;
struct wined3d_string_buffer *param_str = string_buffer_get(priv->string_buffers); struct wined3d_string_buffer *param_str = string_buffer_get(priv->string_buffers);
struct wined3d_string_buffer *reg_name = string_buffer_get(priv->string_buffers);
enum wined3d_data_type param_data_type; enum wined3d_data_type param_data_type;
BOOL is_color = FALSE; BOOL is_color = FALSE;
char swizzle_str[6]; char swizzle_str[6];
char reg_name[150];
reg_name[0] = '\0';
glsl_src->param_str[0] = '\0'; glsl_src->param_str[0] = '\0';
swizzle_str[0] = '\0'; swizzle_str[0] = '\0';
@ -3427,9 +3439,10 @@ static void shader_glsl_add_src_param_ext(const struct wined3d_shader_context *c
break; break;
} }
shader_glsl_sprintf_cast(param_str, reg_name, data_type, param_data_type); shader_glsl_sprintf_cast(param_str, reg_name->buffer, data_type, param_data_type);
shader_glsl_gen_modifier(wined3d_src->modifiers, param_str->buffer, swizzle_str, glsl_src->param_str); shader_glsl_gen_modifier(wined3d_src->modifiers, param_str->buffer, swizzle_str, glsl_src->param_str);
string_buffer_release(priv->string_buffers, reg_name);
string_buffer_release(priv->string_buffers, param_str); string_buffer_release(priv->string_buffers, param_str);
} }
@ -3445,11 +3458,19 @@ static void shader_glsl_add_src_param(const struct wined3d_shader_instruction *i
static DWORD shader_glsl_add_dst_param(const struct wined3d_shader_instruction *ins, static DWORD shader_glsl_add_dst_param(const struct wined3d_shader_instruction *ins,
const struct wined3d_shader_dst_param *wined3d_dst, struct glsl_dst_param *glsl_dst) const struct wined3d_shader_dst_param *wined3d_dst, struct glsl_dst_param *glsl_dst)
{ {
glsl_dst->mask_str[0] = '\0'; struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
glsl_dst->reg_name[0] = '\0'; struct wined3d_string_buffer *reg_name;
size_t len;
glsl_dst->mask_str[0] = '\0';
reg_name = string_buffer_get(priv->string_buffers);
shader_glsl_get_register_name(&wined3d_dst->reg, wined3d_dst->reg.data_type, reg_name, NULL, ins->ctx);
len = min(reg_name->content_size, ARRAY_SIZE(glsl_dst->reg_name) - 1);
memcpy(glsl_dst->reg_name, reg_name->buffer, len);
glsl_dst->reg_name[len] = '\0';
string_buffer_release(priv->string_buffers, reg_name);
shader_glsl_get_register_name(&wined3d_dst->reg, wined3d_dst->reg.data_type,
glsl_dst->reg_name, NULL, ins->ctx);
return shader_glsl_get_write_mask(wined3d_dst, glsl_dst->mask_str); return shader_glsl_get_write_mask(wined3d_dst, glsl_dst->mask_str);
} }
@ -3738,10 +3759,13 @@ static void shader_glsl_color_correction_ext(struct wined3d_string_buffer *buffe
static void shader_glsl_color_correction(const struct wined3d_shader_instruction *ins, struct color_fixup_desc fixup) static void shader_glsl_color_correction(const struct wined3d_shader_instruction *ins, struct color_fixup_desc fixup)
{ {
char reg_name[256]; struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
struct wined3d_string_buffer *reg_name;
reg_name = string_buffer_get(priv->string_buffers);
shader_glsl_get_register_name(&ins->dst[0].reg, ins->dst[0].reg.data_type, reg_name, NULL, ins->ctx); shader_glsl_get_register_name(&ins->dst[0].reg, ins->dst[0].reg.data_type, reg_name, NULL, ins->ctx);
shader_glsl_color_correction_ext(ins->ctx->buffer, reg_name, ins->dst[0].write_mask, fixup); shader_glsl_color_correction_ext(ins->ctx->buffer, reg_name->buffer, ins->dst[0].write_mask, fixup);
string_buffer_release(priv->string_buffers, reg_name);
} }
static void PRINTF_ATTR(9, 10) shader_glsl_gen_sample_code(const struct wined3d_shader_instruction *ins, static void PRINTF_ATTR(9, 10) shader_glsl_gen_sample_code(const struct wined3d_shader_instruction *ins,
@ -4995,16 +5019,15 @@ static void shader_glsl_sgn(const struct wined3d_shader_instruction *ins)
static void shader_glsl_loop(const struct wined3d_shader_instruction *ins) static void shader_glsl_loop(const struct wined3d_shader_instruction *ins)
{ {
struct wined3d_shader_parser_state *state = ins->ctx->state; struct wined3d_shader_parser_state *state = ins->ctx->state;
struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
struct wined3d_string_buffer *buffer = ins->ctx->buffer; struct wined3d_string_buffer *buffer = ins->ctx->buffer;
const struct wined3d_shader *shader = ins->ctx->shader; const struct wined3d_shader *shader = ins->ctx->shader;
const struct wined3d_shader_lconst *constant; const struct wined3d_shader_lconst *constant;
struct wined3d_string_buffer *reg_name;
const DWORD *control_values = NULL; const DWORD *control_values = NULL;
char reg_name[150];
if (ins->ctx->reg_maps->shader_version.major < 4) if (ins->ctx->reg_maps->shader_version.major < 4)
{ {
shader_glsl_get_register_name(&ins->src[1].reg, ins->src[1].reg.data_type, reg_name, NULL, ins->ctx);
/* Try to hardcode the loop control parameters if possible. Direct3D 9 /* Try to hardcode the loop control parameters if possible. Direct3D 9
* class hardware doesn't support real varying indexing, but Microsoft * class hardware doesn't support real varying indexing, but Microsoft
* designed this feature for Shader model 2.x+. If the loop control is * designed this feature for Shader model 2.x+. If the loop control is
@ -5053,10 +5076,16 @@ static void shader_glsl_loop(const struct wined3d_shader_instruction *ins)
} }
else else
{ {
reg_name = string_buffer_get(priv->string_buffers);
shader_glsl_get_register_name(&ins->src[1].reg, ins->src[1].reg.data_type, reg_name, NULL, ins->ctx);
shader_addline(buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z)\n{\n", shader_addline(buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z)\n{\n",
state->current_loop_depth, state->current_loop_reg, reg_name, state->current_loop_depth, state->current_loop_reg, reg_name->buffer,
state->current_loop_depth, reg_name, state->current_loop_depth, reg_name->buffer,
state->current_loop_depth, state->current_loop_reg, reg_name); state->current_loop_depth, state->current_loop_reg, reg_name->buffer);
string_buffer_release(priv->string_buffers, reg_name);
} }
++state->current_loop_reg; ++state->current_loop_reg;
@ -6742,32 +6771,40 @@ static void shader_glsl_bem(const struct wined3d_shader_instruction *ins)
* Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */ * Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
static void shader_glsl_texreg2ar(const struct wined3d_shader_instruction *ins) static void shader_glsl_texreg2ar(const struct wined3d_shader_instruction *ins)
{ {
struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
DWORD sampler_idx = ins->dst[0].reg.idx[0].offset; DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
struct glsl_sample_function sample_function; struct glsl_sample_function sample_function;
char reg_name[150]; struct wined3d_string_buffer *reg_name;
reg_name = string_buffer_get(priv->string_buffers);
shader_glsl_get_register_name(&ins->src[0].reg, ins->src[0].reg.data_type, reg_name, NULL, ins->ctx); shader_glsl_get_register_name(&ins->src[0].reg, ins->src[0].reg.data_type, reg_name, NULL, ins->ctx);
shader_glsl_get_sample_function(ins->ctx, sampler_idx, sampler_idx, 0, &sample_function); shader_glsl_get_sample_function(ins->ctx, sampler_idx, sampler_idx, 0, &sample_function);
shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, NULL, shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, NULL,
"%s.wx", reg_name); "%s.wx", reg_name->buffer);
shader_glsl_release_sample_function(ins->ctx, &sample_function); shader_glsl_release_sample_function(ins->ctx, &sample_function);
string_buffer_release(priv->string_buffers, reg_name);
} }
/** Process the WINED3DSIO_TEXREG2GB instruction in GLSL /** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
* Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */ * Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
static void shader_glsl_texreg2gb(const struct wined3d_shader_instruction *ins) static void shader_glsl_texreg2gb(const struct wined3d_shader_instruction *ins)
{ {
struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
DWORD sampler_idx = ins->dst[0].reg.idx[0].offset; DWORD sampler_idx = ins->dst[0].reg.idx[0].offset;
struct glsl_sample_function sample_function; struct glsl_sample_function sample_function;
char reg_name[150]; struct wined3d_string_buffer *reg_name;
reg_name = string_buffer_get(priv->string_buffers);
shader_glsl_get_register_name(&ins->src[0].reg, ins->src[0].reg.data_type, reg_name, NULL, ins->ctx); shader_glsl_get_register_name(&ins->src[0].reg, ins->src[0].reg.data_type, reg_name, NULL, ins->ctx);
shader_glsl_get_sample_function(ins->ctx, sampler_idx, sampler_idx, 0, &sample_function); shader_glsl_get_sample_function(ins->ctx, sampler_idx, sampler_idx, 0, &sample_function);
shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, NULL, shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, NULL,
"%s.yz", reg_name); "%s.yz", reg_name->buffer);
shader_glsl_release_sample_function(ins->ctx, &sample_function); shader_glsl_release_sample_function(ins->ctx, &sample_function);
string_buffer_release(priv->string_buffers, reg_name);
} }
/** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL /** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL