shader: move header generation to variadic emission.

This moves to using the strbuf variadic append.

Reviewed-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
macos/master
Dave Airlie 6 years ago
parent 695e7c3092
commit 1c5d6570fd
  1. 178
      src/vrend_shader.c

@ -521,6 +521,15 @@ static void set_hdr_error(struct dump_ctx *ctx)
strbuf_set_error(&ctx->glsl_hdr);
}
__attribute__((format(printf, 2, 3)))
static void emit_hdrf(struct dump_ctx *ctx, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
strbuf_vappendf(&ctx->glsl_hdr, fmt, va);
va_end(va);
}
static bool allocate_temp_range(struct dump_ctx *ctx, int first, int last,
int array_id)
{
@ -3986,9 +3995,7 @@ prolog(struct tgsi_iterate_context *iter)
static void emit_header(struct dump_ctx *ctx)
{
if (ctx->cfg->use_gles) {
char buf[32];
snprintf(buf, sizeof(buf), "#version %d es\n", ctx->cfg->glsl_version);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "#version %d es\n", ctx->cfg->glsl_version);
if (ctx->cfg->glsl_version < 320 &&
(ctx->prog_type == TGSI_PROCESSOR_VERTEX ||
@ -4039,7 +4046,6 @@ static void emit_header(struct dump_ctx *ctx)
emit_hdr(ctx, "precision highp float;\n");
emit_hdr(ctx, "precision highp int;\n");
} else {
char buf[128];
if (ctx->prog_type == TGSI_PROCESSOR_COMPUTE) {
emit_hdr(ctx, "#version 330\n");
emit_hdr(ctx, "#extension GL_ARB_compute_shader : require\n");
@ -4086,8 +4092,7 @@ static void emit_header(struct dump_ctx *ctx)
continue;
if (ctx->shader_req_bits & shader_req_table[i].key) {
snprintf(buf, 128, "#extension GL_%s : require\n", shader_req_table[i].string);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "#extension GL_%s : require\n", shader_req_table[i].string);
}
}
}
@ -4184,7 +4189,7 @@ static void emit_sampler_decl(struct dump_ctx *ctx,
uint32_t i, uint32_t range,
const struct vrend_shader_sampler *sampler)
{
char buf[255], ptc;
char ptc;
int is_shad = 0;
const char *sname, *precision, *stc;
@ -4197,18 +4202,15 @@ static void emit_sampler_decl(struct dump_ctx *ctx,
/* GLES does not support 1D textures -- we use a 2D texture and set the parameter set to 0.5 */
if (ctx->cfg->use_gles && sampler->tgsi_sampler_type == TGSI_TEXTURE_1D)
snprintf(buf, 255, "uniform highp %csampler2D %ssamp%d;\n", ptc, sname, i);
emit_hdrf(ctx, "uniform highp %csampler2D %ssamp%d;\n", ptc, sname, i);
else if (range)
snprintf(buf, 255, "uniform %s%csampler%s %ssamp%d[%d];\n", precision, ptc, stc, sname, i, range);
emit_hdrf(ctx, "uniform %s%csampler%s %ssamp%d[%d];\n", precision, ptc, stc, sname, i, range);
else
snprintf(buf, 255, "uniform %s%csampler%s %ssamp%d;\n", precision, ptc, stc, sname, i);
emit_hdrf(ctx, "uniform %s%csampler%s %ssamp%d;\n", precision, ptc, stc, sname, i);
emit_hdr(ctx, buf);
if (is_shad) {
snprintf(buf, 255, "uniform %svec4 %sshadmask%d;\n", precision, sname, i);
emit_hdr(ctx, buf);
snprintf(buf, 255, "uniform %svec4 %sshadadd%d;\n", precision, sname, i);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "uniform %svec4 %sshadmask%d;\n", precision, sname, i);
emit_hdrf(ctx, "uniform %svec4 %sshadadd%d;\n", precision, sname, i);
ctx->shadow_samp_mask |= (1 << i);
}
}
@ -4347,7 +4349,7 @@ static void emit_image_decl(struct dump_ctx *ctx,
uint32_t i, uint32_t range,
const struct vrend_shader_image *image)
{
char buf[255], ptc;
char ptc;
int is_shad = 0;
const char *sname, *stc, *formatstr;
enum tgsi_return_type itype;
@ -4369,28 +4371,23 @@ static void emit_image_decl(struct dump_ctx *ctx,
access = "writeonly ";
if (ctx->cfg->use_gles) { /* TODO: enable on OpenGL 4.2 and up also */
snprintf(buf, 255, "layout(binding=%d%s%s) ",
emit_hdrf(ctx, "layout(binding=%d%s%s) ",
i, formatstr[0] != '\0' ? ", " : "", formatstr);
emit_hdr(ctx, buf);
} else if (formatstr[0] != '\0') {
snprintf(buf, 255, "layout(%s) ", formatstr);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "layout(%s) ", formatstr);
}
if (range)
snprintf(buf, 255, "%s%suniform %s%cimage%s %simg%d[%d];\n",
emit_hdrf(ctx, "%s%suniform %s%cimage%s %simg%d[%d];\n",
access, volatile_str, precision, ptc, stc, sname, i, range);
else
snprintf(buf, 255, "%s%suniform %s%cimage%s %simg%d;\n",
emit_hdrf(ctx, "%s%suniform %s%cimage%s %simg%d;\n",
access, volatile_str, precision, ptc, stc, sname, i);
emit_hdr(ctx, buf);
}
static void emit_ios(struct dump_ctx *ctx)
{
uint32_t i;
char buf[255];
char postfix[8];
const char *prefix = "", *auxprefix = "";
bool fcolor_emitted[2], bcolor_emitted[2];
@ -4413,11 +4410,10 @@ static void emit_ios(struct dump_ctx *ctx)
bool upper_left = !(ctx->fs_coord_origin ^ ctx->key->invert_fs_origin);
char comma = (upper_left && ctx->fs_pixel_center) ? ',' : ' ';
snprintf(buf, 255, "layout(%s%c%s) in vec4 gl_FragCoord;\n",
emit_hdrf(ctx, "layout(%s%c%s) in vec4 gl_FragCoord;\n",
upper_left ? "origin_upper_left" : "",
comma,
ctx->fs_pixel_center ? "pixel_center_integer" : "");
emit_hdr(ctx, buf);
}
if (ctx->early_depth_stencil) {
emit_hdr(ctx, "layout(early_fragment_tests) in;\n");
@ -4425,14 +4421,12 @@ static void emit_ios(struct dump_ctx *ctx)
}
if (ctx->prog_type == TGSI_PROCESSOR_COMPUTE) {
snprintf(buf, 255, "layout (local_size_x = %d, local_size_y = %d, local_size_z = %d) in;\n",
emit_hdrf(ctx, "layout (local_size_x = %d, local_size_y = %d, local_size_z = %d) in;\n",
ctx->local_cs_block_size[0], ctx->local_cs_block_size[1], ctx->local_cs_block_size[2]);
emit_hdr(ctx, buf);
if (ctx->req_local_mem) {
enum vrend_type_qualifier type = ctx->integer_memory ? INT : UINT;
snprintf(buf, 255, "shared %s values[%d];\n", get_string(type), ctx->req_local_mem / 4);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "shared %s values[%d];\n", get_string(type), ctx->req_local_mem / 4);
}
}
@ -4442,11 +4436,9 @@ static void emit_ios(struct dump_ctx *ctx)
if (ctx->gs_num_invocations)
snprintf(invocbuf, 25, ", invocations = %d", ctx->gs_num_invocations);
snprintf(buf, 255, "layout(%s%s) in;\n", prim_to_name(ctx->gs_in_prim),
emit_hdrf(ctx, "layout(%s%s) in;\n", prim_to_name(ctx->gs_in_prim),
ctx->gs_num_invocations > 1 ? invocbuf : "");
emit_hdr(ctx, buf);
snprintf(buf, 255, "layout(%s, max_vertices = %d) out;\n", prim_to_name(ctx->gs_out_prim), ctx->gs_max_out_verts);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "layout(%s, max_vertices = %d) out;\n", prim_to_name(ctx->gs_out_prim), ctx->gs_max_out_verts);
}
if (ctx_indirect_inputs(ctx)) {
@ -4456,8 +4448,7 @@ static void emit_ios(struct dump_ctx *ctx)
int size = ctx->patch_input_range.last - ctx->patch_input_range.first + 1;
if (size < ctx->key->num_indirect_patch_inputs)
size = ctx->key->num_indirect_patch_inputs;
snprintf(buf, 255, "patch in vec4 %sp%d[%d];\n", name_prefix, ctx->patch_input_range.first, size);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "patch in vec4 %sp%d[%d];\n", name_prefix, ctx->patch_input_range.first, size);
}
}
@ -4467,16 +4458,14 @@ static void emit_ios(struct dump_ctx *ctx)
int size = ctx->generic_input_range.last - ctx->generic_input_range.first + 1;
if (size < ctx->key->num_indirect_generic_inputs)
size = ctx->key->num_indirect_generic_inputs;
snprintf(buf, 255, "in block { vec4 %s%d[%d]; } blk[];\n", name_prefix, ctx->generic_input_range.first, size);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "in block { vec4 %s%d[%d]; } blk[];\n", name_prefix, ctx->generic_input_range.first, size);
}
}
}
for (i = 0; i < ctx->num_inputs; i++) {
if (!ctx->inputs[i].glsl_predefined_no_emit) {
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX && ctx->cfg->use_explicit_locations) {
snprintf(buf, 255, "layout(location=%d) ", ctx->inputs[i].first);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "layout(location=%d) ", ctx->inputs[i].first);
}
prefix = "";
auxprefix = "";
@ -4500,8 +4489,7 @@ static void emit_ios(struct dump_ctx *ctx)
snprintf(postfix, 8, "[]");
} else
postfix[0] = 0;
snprintf(buf, 255, "%s%sin vec4 %s%s;\n", prefix, auxprefix, ctx->inputs[i].glsl_name, postfix);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "%s%sin vec4 %s%s;\n", prefix, auxprefix, ctx->inputs[i].glsl_name, postfix);
}
if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT && ctx->cfg->use_gles &&
@ -4512,34 +4500,29 @@ static void emit_ios(struct dump_ctx *ctx)
}
}
if (ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL) {
snprintf(buf, 255, "layout(vertices = %d) out;\n", ctx->tcs_vertices_out);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "layout(vertices = %d) out;\n", ctx->tcs_vertices_out);
}
if (ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL) {
snprintf(buf, 255, "layout(%s, %s, %s%s) in;\n",
emit_hdrf(ctx, "layout(%s, %s, %s%s) in;\n",
prim_to_tes_name(ctx->tes_prim_mode),
get_spacing_string(ctx->tes_spacing),
ctx->tes_vertex_order ? "cw" : "ccw",
ctx->tes_point_mode ? ", point_mode" : "");
emit_hdr(ctx, buf);
}
if (ctx_indirect_outputs(ctx)) {
const char *name_prefix = get_stage_output_name_prefix(ctx->prog_type);
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX) {
if (ctx->generic_output_range.used) {
snprintf(buf, 255, "out block { vec4 %s%d[%d]; } oblk;\n", name_prefix, ctx->generic_output_range.first, ctx->generic_output_range.last - ctx->generic_output_range.first + 1);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "out block { vec4 %s%d[%d]; } oblk;\n", name_prefix, ctx->generic_output_range.first, ctx->generic_output_range.last - ctx->generic_output_range.first + 1);
}
}
if (ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL) {
if (ctx->generic_output_range.used) {
snprintf(buf, 255, "out block { vec4 %s%d[%d]; } oblk[];\n", name_prefix, ctx->generic_output_range.first, ctx->generic_output_range.last - ctx->generic_output_range.first + 1);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "out block { vec4 %s%d[%d]; } oblk[];\n", name_prefix, ctx->generic_output_range.first, ctx->generic_output_range.last - ctx->generic_output_range.first + 1);
}
if (ctx->patch_output_range.used) {
snprintf(buf, 255, "patch out vec4 %sp%d[%d];\n", name_prefix, ctx->patch_output_range.first, ctx->patch_output_range.last - ctx->patch_output_range.first + 1);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "patch out vec4 %sp%d[%d];\n", name_prefix, ctx->patch_output_range.first, ctx->patch_output_range.last - ctx->patch_output_range.first + 1);
}
}
}
@ -4547,10 +4530,9 @@ static void emit_ios(struct dump_ctx *ctx)
if (ctx->write_all_cbufs) {
for (i = 0; i < (uint32_t)ctx->cfg->max_draw_buffers; i++) {
if (ctx->cfg->use_gles)
snprintf(buf, 255, "layout (location=%d) out vec4 fsout_c%d;\n", i, i);
emit_hdrf(ctx, "layout (location=%d) out vec4 fsout_c%d;\n", i, i);
else
snprintf(buf, 255, "out vec4 fsout_c%d;\n", i);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "out vec4 fsout_c%d;\n", i);
}
} else {
for (i = 0; i < ctx->num_outputs; i++) {
@ -4574,28 +4556,26 @@ static void emit_ios(struct dump_ctx *ctx)
/* ugly leave spaces to patch interp in later */
if (ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL) {
if (ctx->outputs[i].name == TGSI_SEMANTIC_PATCH)
snprintf(buf, 255, "patch out vec4 %s;\n", ctx->outputs[i].glsl_name);
emit_hdrf(ctx, "patch out vec4 %s;\n", ctx->outputs[i].glsl_name);
else
snprintf(buf, 255, "%sout vec4 %s[];\n", prefix, ctx->outputs[i].glsl_name);
emit_hdrf(ctx, "%sout vec4 %s[];\n", prefix, ctx->outputs[i].glsl_name);
} else if (ctx->prog_type == TGSI_PROCESSOR_GEOMETRY && ctx->outputs[i].stream)
snprintf(buf, 255, "layout (stream = %d) %s%s%sout vec4 %s;\n", ctx->outputs[i].stream, prefix,
emit_hdrf(ctx, "layout (stream = %d) %s%s%sout vec4 %s;\n", ctx->outputs[i].stream, prefix,
ctx->outputs[i].precise ? "precise " : "",
ctx->outputs[i].invariant ? "invariant " : "",
ctx->outputs[i].glsl_name);
else
snprintf(buf, 255, "%s%s%s%s vec4 %s;\n",
emit_hdrf(ctx, "%s%s%s%s vec4 %s;\n",
prefix,
ctx->outputs[i].precise ? "precise " : "",
ctx->outputs[i].invariant ? "invariant " : "",
ctx->outputs[i].fbfetch_used ? "inout" : "out",
ctx->outputs[i].glsl_name);
emit_hdr(ctx, buf);
} else if (ctx->outputs[i].invariant || ctx->outputs[i].precise) {
snprintf(buf, 255, "%s%s;\n",
emit_hdrf(ctx, "%s%s;\n",
ctx->outputs[i].precise ? "precise " :
(ctx->outputs[i].invariant ? "invariant " : ""),
ctx->outputs[i].glsl_name);
emit_hdr(ctx, buf);
}
}
}
@ -4603,12 +4583,10 @@ static void emit_ios(struct dump_ctx *ctx)
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX && ctx->key->color_two_side) {
for (i = 0; i < 2; i++) {
if (fcolor_emitted[i] && !bcolor_emitted[i]) {
snprintf(buf, 255, "%sout vec4 ex_bc%d;\n", INTERP_PREFIX, i);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "%sout vec4 ex_bc%d;\n", INTERP_PREFIX, i);
}
if (bcolor_emitted[i] && !fcolor_emitted[i]) {
snprintf(buf, 255, "%sout vec4 ex_c%d;\n", INTERP_PREFIX, i);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "%sout vec4 ex_c%d;\n", INTERP_PREFIX, i);
}
}
}
@ -4621,8 +4599,7 @@ static void emit_ios(struct dump_ctx *ctx)
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX) {
if (ctx->has_clipvertex) {
snprintf(buf, 255, "%svec4 clipv_tmp;\n", ctx->has_clipvertex_so ? "out " : "");
emit_hdr(ctx, buf);
emit_hdrf(ctx, "%svec4 clipv_tmp;\n", ctx->has_clipvertex_so ? "out " : "");
}
if (ctx->num_clip_dist || ctx->key->clip_plane_enable) {
bool has_prop = (ctx->num_clip_dist_prop + ctx->num_cull_dist_prop) > 0;
@ -4644,11 +4621,9 @@ static void emit_ios(struct dump_ctx *ctx)
}
if (ctx->key->gs_present || ctx->key->tes_present) {
ctx->vs_has_pervertex = true;
snprintf(buf, 255, "out gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize;\n%s%s};\n", clip_buf, cull_buf);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "out gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize;\n%s%s};\n", clip_buf, cull_buf);
} else {
snprintf(buf, 255, "%s%s", clip_buf, cull_buf);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "%s%s", clip_buf, cull_buf);
}
emit_hdr(ctx, "vec4 clip_dist_temp[2];\n");
}
@ -4667,8 +4642,7 @@ static void emit_ios(struct dump_ctx *ctx)
if (cull_dist)
snprintf(cull_var, 64, "float gl_CullDistance[%d];\n", cull_dist);
snprintf(buf, 255, "in gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize; \n %s%s\n} gl_in[];\n", clip_var, cull_var);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "in gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize; \n %s%s\n} gl_in[];\n", clip_var, cull_var);
}
if (ctx->num_clip_dist) {
bool has_prop = (ctx->num_clip_dist_prop + ctx->num_cull_dist_prop) > 0;
@ -4685,21 +4659,17 @@ static void emit_ios(struct dump_ctx *ctx)
snprintf(cull_buf, 64, "out float gl_CullDistance[%d];\n", num_cull_dists);
} else
snprintf(clip_buf, 64, "out float gl_ClipDistance[%d];\n", num_clip_dists);
snprintf(buf, 255, "%s%s\n", clip_buf, cull_buf);
emit_hdr(ctx, buf);
snprintf(buf, 255, "vec4 clip_dist_temp[2];\n");
emit_hdr(ctx, buf);
emit_hdrf(ctx, "%s%s\n", clip_buf, cull_buf);
emit_hdrf(ctx, "vec4 clip_dist_temp[2];\n");
}
}
if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT && ctx->num_in_clip_dist) {
if (ctx->key->prev_stage_num_clip_out) {
snprintf(buf, 255, "in float gl_ClipDistance[%d];\n", ctx->key->prev_stage_num_clip_out);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "in float gl_ClipDistance[%d];\n", ctx->key->prev_stage_num_clip_out);
}
if (ctx->key->prev_stage_num_cull_out) {
snprintf(buf, 255, "in float gl_CullDistance[%d];\n", ctx->key->prev_stage_num_cull_out);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "in float gl_CullDistance[%d];\n", ctx->key->prev_stage_num_cull_out);
}
}
@ -4716,14 +4686,11 @@ static void emit_ios(struct dump_ctx *ctx)
if (cull_dist)
snprintf(cull_var, 64, "float gl_CullDistance[%d];\n", cull_dist);
snprintf(buf, 255, "in gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize; \n %s%s} gl_in[];\n", clip_var, cull_var);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "in gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize; \n %s%s} gl_in[];\n", clip_var, cull_var);
}
if (ctx->num_clip_dist) {
snprintf(buf, 255, "out gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize;\n float gl_ClipDistance[%d];\n} gl_out[];\n", ctx->num_clip_dist ? ctx->num_clip_dist : 8);
emit_hdr(ctx, buf);
snprintf(buf, 255, "vec4 clip_dist_temp[2];\n");
emit_hdr(ctx, buf);
emit_hdrf(ctx, "out gl_PerVertex {\n vec4 gl_Position;\n float gl_PointSize;\n float gl_ClipDistance[%d];\n} gl_out[];\n", ctx->num_clip_dist ? ctx->num_clip_dist : 8);
emit_hdr(ctx, "vec4 clip_dist_temp[2];\n");
}
}
@ -4737,17 +4704,15 @@ static void emit_ios(struct dump_ctx *ctx)
else
snprintf(outtype, 6, "vec%d", ctx->so->output[i].num_components);
if (ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL)
snprintf(buf, 255, "out %s tfout%d[];\n", outtype, i);
emit_hdrf(ctx, "out %s tfout%d[];\n", outtype, i);
else if (ctx->so->output[i].stream && ctx->prog_type == TGSI_PROCESSOR_GEOMETRY)
snprintf(buf, 255, "layout (stream=%d) out %s tfout%d;\n", ctx->so->output[i].stream, outtype, i);
emit_hdrf(ctx, "layout (stream=%d) out %s tfout%d;\n", ctx->so->output[i].stream, outtype, i);
else
snprintf(buf, 255, "out %s tfout%d;\n", outtype, i);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "out %s tfout%d;\n", outtype, i);
}
}
for (i = 0; i < ctx->num_temp_ranges; i++) {
snprintf(buf, 255, "vec4 temp%d[%d];\n", ctx->temp_ranges[i].first, ctx->temp_ranges[i].last - ctx->temp_ranges[i].first + 1);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "vec4 temp%d[%d];\n", ctx->temp_ranges[i].first, ctx->temp_ranges[i].last - ctx->temp_ranges[i].first + 1);
}
if (ctx->write_mul_utemp) {
@ -4770,13 +4735,11 @@ static void emit_ios(struct dump_ctx *ctx)
}
for (i = 0; i < ctx->num_address; i++) {
snprintf(buf, 255, "int addr%d;\n", i);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "int addr%d;\n", i);
}
if (ctx->num_consts) {
const char *cname = tgsi_proc_to_prefix(ctx->prog_type);
snprintf(buf, 255, "uniform uvec4 %sconst0[%d];\n", cname, ctx->num_consts);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "uniform uvec4 %sconst0[%d];\n", cname, ctx->num_consts);
}
if (ctx->key->color_two_side) {
@ -4790,12 +4753,10 @@ static void emit_ios(struct dump_ctx *ctx)
if (ctx->info.dimension_indirect_files & (1 << TGSI_FILE_CONSTANT)) {
require_glsl_ver(ctx, 150);
snprintf(buf, 255, "uniform %subo { vec4 ubocontents[%d]; } %suboarr[%d];\n", cname, ctx->ubo_sizes[0], cname, ctx->num_ubo);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "uniform %subo { vec4 ubocontents[%d]; } %suboarr[%d];\n", cname, ctx->ubo_sizes[0], cname, ctx->num_ubo);
} else {
for (i = 0; i < ctx->num_ubo; i++) {
snprintf(buf, 255, "uniform %subo%d { vec4 %subo%dcontents[%d]; };\n", cname, ctx->ubo_idx[i], cname, ctx->ubo_idx[i], ctx->ubo_sizes[i]);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "uniform %subo%d { vec4 %subo%dcontents[%d]; };\n", cname, ctx->ubo_idx[i], cname, ctx->ubo_idx[i], ctx->ubo_sizes[i]);
}
}
}
@ -4833,10 +4794,9 @@ static void emit_ios(struct dump_ctx *ctx)
for (i = 0; i < ctx->num_abo; i++){
if (ctx->abo_sizes[i] > 1)
snprintf(buf, 255, "layout (binding = %d, offset = %d) uniform atomic_uint ac%d[%d];\n", ctx->abo_idx[i], ctx->abo_offsets[i] * 4, i, ctx->abo_sizes[i]);
emit_hdrf(ctx, "layout (binding = %d, offset = %d) uniform atomic_uint ac%d[%d];\n", ctx->abo_idx[i], ctx->abo_offsets[i] * 4, i, ctx->abo_sizes[i]);
else
snprintf(buf, 255, "layout (binding = %d, offset = %d) uniform atomic_uint ac%d;\n", ctx->abo_idx[i], ctx->abo_offsets[i] * 4, i);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "layout (binding = %d, offset = %d) uniform atomic_uint ac%d;\n", ctx->abo_idx[i], ctx->abo_offsets[i] * 4, i);
}
if (ctx->info.indirect_files & (1 << TGSI_FILE_BUFFER)) {
@ -4845,8 +4805,7 @@ static void emit_ios(struct dump_ctx *ctx)
int start, count;
u_bit_scan_consecutive_range(&mask, &start, &count);
const char *atomic = (ctx->ssbo_atomic_mask & (1 << start)) ? "atomic" : "";
snprintf(buf, 255, "layout (binding = %d, std430) buffer %sssbo%d { uint %sssbocontents%d[]; } %sssboarr%s[%d];\n", start, sname, start, sname, start, sname, atomic, count);
emit_hdr(ctx, buf);
emit_hdrf(ctx, "layout (binding = %d, std430) buffer %sssbo%d { uint %sssbocontents%d[]; } %sssboarr%s[%d];\n", start, sname, start, sname, start, sname, atomic, count);
}
} else {
uint32_t mask = ctx->ssbo_used_mask;
@ -4854,9 +4813,8 @@ static void emit_ios(struct dump_ctx *ctx)
uint32_t id = u_bit_scan(&mask);
sname = tgsi_proc_to_prefix(ctx->prog_type);
enum vrend_type_qualifier type = (ctx->ssbo_integer_mask & (1 << id)) ? INT : UINT;
snprintf(buf, 255, "layout (binding = %d, std430) buffer %sssbo%d { %s %sssbocontents%d[]; };\n", id, sname, id,
emit_hdrf(ctx, "layout (binding = %d, std430) buffer %sssbo%d { %s %sssbocontents%d[]; };\n", id, sname, id,
get_string(type), sname, id);
emit_hdr(ctx, buf);
}
}

Loading…
Cancel
Save