third_party
/
virglrenderer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

shader: move header generation into context and align with main body code

Browse Source 
This aligns the header generation code with the main body code as much
as possible. The glsl_hdr is now stored in the context to save the
passing around.

Reviewed-by: Gert Wollny <gert.wollny@collabora.com>
Reviewed-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Signed-off-by: Jakob Bornecrantz <jakob@collabora.com>
macos/master
Dave Airlie 6 years ago committed by Jakob Bornecrantz
parent bf183d4c8d
commit dddf10c954
1 changed files with 144 additions and 139 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 275
      src/vrend_shader.c

275
src/vrend_shader.c
Unescape View File

@ -130,6 +130,7 @@ struct dump_ctx {
int prog_type;
int size;
char *glsl_main;
char *glsl_hdr;
uint instno;
uint32_t num_interps;
@ -522,6 +523,22 @@ static bool emit_buf(struct dump_ctx *ctx, const char *buf)
if (!_ret) return FALSE; \
} while(0)
static bool add_str_to_glsl_hdr(struct dump_ctx *ctx, const char *buf)
{
ctx->glsl_hdr = strcat_realloc(ctx->glsl_hdr, buf);
return ctx->glsl_hdr ? true : false;
}
static bool emit_hdr(struct dump_ctx *ctx, const char *buf)
{
return add_str_to_glsl_hdr(ctx, buf);
}
#define EMIT_HDR_WITH_RET(ctx, buf) do { \
bool _ret = emit_hdr((ctx), (buf)); \
if (!_ret) return FALSE; \
} while(0)
static bool allocate_temp_range(struct dump_ctx *ctx, int first, int last,
int array_id)
{
@ -4019,113 +4036,108 @@ prolog(struct tgsi_iterate_context *iter)
return TRUE;
}
#define STRCAT_WITH_RET(mainstr, buf) do { \
(mainstr) = strcat_realloc((mainstr), (buf)); \
if ((mainstr) == NULL) return NULL; \
} while(0)
/* reserve space for: "#extension GL_ARB_gpu_shader5 : require\n" */
#define PAD_GPU_SHADER5(s) \
STRCAT_WITH_RET(s, " \n")
#define PAD_GPU_MSINTERPOL(s) \
STRCAT_WITH_RET(s, " \n")
#define PAD_GPU_SHADER5(ctx) \
EMIT_HDR_WITH_RET(ctx, " \n")
#define PAD_GPU_MSINTERPOL(ctx) \
EMIT_HDR_WITH_RET(ctx, " \n")
static char *emit_header(struct dump_ctx *ctx, char *glsl_hdr)
static bool 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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
if (ctx->cfg->glsl_version < 320 &&
(ctx->prog_type == TGSI_PROCESSOR_VERTEX ||
ctx->prog_type == TGSI_PROCESSOR_GEOMETRY ||
ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL)) {
PAD_GPU_SHADER5(glsl_hdr);
PAD_GPU_MSINTERPOL(glsl_hdr);
PAD_GPU_SHADER5(ctx);
PAD_GPU_MSINTERPOL(ctx);
}
if (ctx->shader_req_bits & SHADER_REQ_SAMPLER_MS)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_texture_storage_multisample_2d_array : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_texture_storage_multisample_2d_array : require\n");
if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT) {
if (ctx->shader_req_bits & SHADER_REQ_FBFETCH)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_EXT_shader_framebuffer_fetch : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_EXT_shader_framebuffer_fetch : require\n");
}
if (ctx->prog_type == TGSI_PROCESSOR_GEOMETRY) {
STRCAT_WITH_RET(glsl_hdr, "#extension GL_EXT_geometry_shader : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_EXT_geometry_shader : require\n");
if (ctx->shader_req_bits & SHADER_REQ_PSIZE)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_geometry_point_size : enable\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_geometry_point_size : enable\n");
}
if ((ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL ||
ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL)) {
if (ctx->cfg->glsl_version < 320)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_tessellation_shader : require\n");
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_tessellation_point_size : enable\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_tessellation_shader : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_tessellation_point_size : enable\n");
}
if (ctx->cfg->glsl_version < 320) {
if (ctx->shader_req_bits & SHADER_REQ_SAMPLE_SHADING)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_sample_variables : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_sample_variables : require\n");
if (ctx->shader_req_bits & SHADER_REQ_GPU_SHADER5) {
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_gpu_shader5 : require\n");
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_shader_multisample_interpolation : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_gpu_shader5 : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_shader_multisample_interpolation : require\n");
}
if (ctx->shader_req_bits & SHADER_REQ_CUBE_ARRAY)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_texture_cube_map_array : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_texture_cube_map_array : require\n");
if (ctx->shader_req_bits & SHADER_REQ_LAYER)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_EXT_geometry_shader : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_EXT_geometry_shader : require\n");
if (ctx->shader_req_bits & SHADER_REQ_IMAGE_ATOMIC)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_OES_shader_image_atomic : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_OES_shader_image_atomic : require\n");
}
PAD_GPU_SHADER5(glsl_hdr);
STRCAT_WITH_RET(glsl_hdr, "precision highp float;\n");
STRCAT_WITH_RET(glsl_hdr, "precision highp int;\n");
PAD_GPU_SHADER5(ctx);
EMIT_HDR_WITH_RET(ctx, "precision highp float;\n");
EMIT_HDR_WITH_RET(ctx, "precision highp int;\n");
} else {
char buf[128];
if (ctx->prog_type == TGSI_PROCESSOR_COMPUTE) {
STRCAT_WITH_RET(glsl_hdr, "#version 330\n");
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_compute_shader : require\n");
EMIT_HDR_WITH_RET(ctx, "#version 330\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_compute_shader : require\n");
} else {
if (ctx->prog_type == TGSI_PROCESSOR_GEOMETRY ||
ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL ||
ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL ||
ctx->glsl_ver_required == 150)
STRCAT_WITH_RET(glsl_hdr, "#version 150\n");
EMIT_HDR_WITH_RET(ctx, "#version 150\n");
else if (ctx->glsl_ver_required == 140)
STRCAT_WITH_RET(glsl_hdr, "#version 140\n");
EMIT_HDR_WITH_RET(ctx, "#version 140\n");
else
STRCAT_WITH_RET(glsl_hdr, "#version 130\n");
EMIT_HDR_WITH_RET(ctx, "#version 130\n");
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX ||
ctx->prog_type == TGSI_PROCESSOR_GEOMETRY ||
ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL)
PAD_GPU_SHADER5(glsl_hdr);
PAD_GPU_SHADER5(ctx);
}
if (ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL ||
ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_tessellation_shader : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_tessellation_shader : require\n");
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX && ctx->cfg->use_explicit_locations)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_explicit_attrib_location : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_explicit_attrib_location : require\n");
if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT && fs_emit_layout(ctx))
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_fragment_coord_conventions : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_fragment_coord_conventions : require\n");
if (ctx->num_ubo)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_uniform_buffer_object : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_uniform_buffer_object : require\n");
if (ctx->num_cull_dist_prop || ctx->key->prev_stage_num_cull_out)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_cull_distance : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_cull_distance : require\n");
if (ctx->ssbo_used_mask)
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_shader_storage_buffer_object : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_shader_storage_buffer_object : require\n");
if (ctx->num_abo) {
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_shader_atomic_counters : require\n");
STRCAT_WITH_RET(glsl_hdr, "#extension GL_ARB_shader_atomic_counter_ops : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_shader_atomic_counters : require\n");
EMIT_HDR_WITH_RET(ctx, "#extension GL_ARB_shader_atomic_counter_ops : require\n");
}
for (uint32_t i = 0; i < ARRAY_SIZE(shader_req_table); i++) {
@ -4134,12 +4146,12 @@ static char *emit_header(struct dump_ctx *ctx, char *glsl_hdr)
if (ctx->shader_req_bits & shader_req_table[i].key) {
snprintf(buf, 128, "#extension GL_%s : require\n", shader_req_table[i].string);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
}
return glsl_hdr;
return true;
}
char vrend_shader_samplerreturnconv(enum tgsi_return_type type)
@ -4229,7 +4241,7 @@ static const char *get_aux_string(unsigned location)
}
}
static void *emit_sampler_decl(struct dump_ctx *ctx, char *glsl_hdr,
static bool emit_sampler_decl(struct dump_ctx *ctx,
uint32_t i, uint32_t range,
const struct vrend_shader_sampler *sampler)
{
@ -4252,16 +4264,16 @@ static void *emit_sampler_decl(struct dump_ctx *ctx, char *glsl_hdr,
else
snprintf(buf, 255, "uniform %s%csampler%s %ssamp%d;\n", precision, ptc, stc, sname, i);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
if (is_shad) {
snprintf(buf, 255, "uniform %svec4 %sshadmask%d;\n", precision, sname, i);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
snprintf(buf, 255, "uniform %svec4 %sshadadd%d;\n", precision, sname, i);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
ctx->shadow_samp_mask |= (1 << i);
}
return glsl_hdr;
return true;
}
const char *get_internalformat_string(int virgl_format, enum tgsi_return_type *stype)
@ -4394,7 +4406,7 @@ const char *get_internalformat_string(int virgl_format, enum tgsi_return_type *s
}
}
static void *emit_image_decl(const struct dump_ctx *ctx, char *glsl_hdr,
static bool emit_image_decl(struct dump_ctx *ctx,
uint32_t i, uint32_t range,
const struct vrend_shader_image *image)
{
@ -4422,10 +4434,10 @@ static void *emit_image_decl(const struct dump_ctx *ctx, char *glsl_hdr,
if (ctx->cfg->use_gles) { /* TODO: enable on OpenGL 4.2 and up also */
snprintf(buf, 255, "layout(binding=%d%s%s) ",
i, formatstr[0] != '\0' ? ", " : "", formatstr);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
} else if (formatstr[0] != '\0') {
snprintf(buf, 255, "layout(%s) ", formatstr);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (range)
@ -4435,11 +4447,11 @@ static void *emit_image_decl(const struct dump_ctx *ctx, char *glsl_hdr,
snprintf(buf, 255, "%s%suniform %s%cimage%s %simg%d;\n",
access, volatile_str, precision, ptc, stc, sname, i);
STRCAT_WITH_RET(glsl_hdr, buf);
return glsl_hdr;
EMIT_HDR_WITH_RET(ctx, buf);
return true;
}
static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
static bool emit_ios(struct dump_ctx *ctx)
{
uint32_t i;
char buf[255];
@ -4452,7 +4464,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
if (ctx->so && ctx->so->num_outputs >= PIPE_MAX_SO_OUTPUTS) {
fprintf(stderr, "Num outputs exceeded, max is %u\n", PIPE_MAX_SO_OUTPUTS);
return NULL;
return false;
}
if (ctx->key->color_two_side) {
@ -4468,22 +4480,22 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
upper_left ? "origin_upper_left" : "",
comma,
ctx->fs_pixel_center ? "pixel_center_integer" : "");
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->early_depth_stencil) {
STRCAT_WITH_RET(glsl_hdr, "layout(early_fragment_tests) in;\n");
EMIT_HDR_WITH_RET(ctx, "layout(early_fragment_tests) in;\n");
}
}
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",
ctx->local_cs_block_size[0], ctx->local_cs_block_size[1], ctx->local_cs_block_size[2]);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
@ -4495,9 +4507,9 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
snprintf(buf, 255, "layout(%s%s) in;\n", prim_to_name(ctx->gs_in_prim),
ctx->gs_num_invocations > 1 ? invocbuf : "");
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
snprintf(buf, 255, "layout(%s, max_vertices = %d) out;\n", prim_to_name(ctx->gs_out_prim), ctx->gs_max_out_verts);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx_indirect_inputs(ctx)) {
@ -4508,7 +4520,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
@ -4519,7 +4531,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
}
@ -4527,7 +4539,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
prefix = "";
auxprefix = "";
@ -4552,19 +4564,19 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
} else
postfix[0] = 0;
snprintf(buf, 255, "%s%sin vec4 %s%s;\n", prefix, auxprefix, ctx->inputs[i].glsl_name, postfix);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT && ctx->cfg->use_gles &&
!ctx->key->winsys_adjust_y_emitted &&
(ctx->key->coord_replace & (1 << ctx->inputs[i].sid))) {
ctx->key->winsys_adjust_y_emitted = true;
STRCAT_WITH_RET(glsl_hdr, "uniform float winsys_adjust_y;\n");
EMIT_HDR_WITH_RET(ctx, "uniform float winsys_adjust_y;\n");
}
}
if (ctx->prog_type == TGSI_PROCESSOR_TESS_CTRL) {
snprintf(buf, 255, "layout(vertices = %d) out;\n", ctx->tcs_vertices_out);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL) {
snprintf(buf, 255, "layout(%s, %s, %s%s) in;\n",
@ -4572,7 +4584,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
get_spacing_string(ctx->tes_spacing),
ctx->tes_vertex_order ? "cw" : "ccw",
ctx->tes_point_mode ? ", point_mode" : "");
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx_indirect_outputs(ctx)) {
@ -4580,17 +4592,17 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
}
@ -4601,7 +4613,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
snprintf(buf, 255, "layout (location=%d) out vec4 fsout_c%d;\n", i, i);
else
snprintf(buf, 255, "out vec4 fsout_c%d;\n", i);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
} else {
for (i = 0; i < ctx->num_outputs; i++) {
@ -4640,13 +4652,13 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
ctx->outputs[i].invariant ? "invariant " : "",
ctx->outputs[i].fbfetch_used ? "inout" : "out",
ctx->outputs[i].glsl_name);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
} else if (ctx->outputs[i].invariant || ctx->outputs[i].precise) {
snprintf(buf, 255, "%s%s;\n",
ctx->outputs[i].precise ? "precise " :
(ctx->outputs[i].invariant ? "invariant " : ""),
ctx->outputs[i].glsl_name);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
}
@ -4655,11 +4667,11 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (bcolor_emitted[i] && !fcolor_emitted[i]) {
snprintf(buf, 255, "%sout vec4 ex_c%d;\n", INTERP_PREFIX, i);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
}
@ -4667,13 +4679,13 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX ||
ctx->prog_type == TGSI_PROCESSOR_GEOMETRY ||
ctx->prog_type == TGSI_PROCESSOR_TESS_EVAL) {
STRCAT_WITH_RET(glsl_hdr, "uniform float winsys_adjust_y;\n");
EMIT_HDR_WITH_RET(ctx, "uniform float winsys_adjust_y;\n");
}
if (ctx->prog_type == TGSI_PROCESSOR_VERTEX) {
if (ctx->has_clipvertex) {
snprintf(buf, 255, "%svec4 clipv_tmp;\n", ctx->has_clipvertex_so ? "out " : "");
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->num_clip_dist || ctx->key->clip_plane_enable) {
bool has_prop = (ctx->num_clip_dist_prop + ctx->num_cull_dist_prop) > 0;
@ -4691,17 +4703,17 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
} else
snprintf(clip_buf, 64, "out float gl_ClipDistance[%d];\n", num_clip_dists);
if (ctx->key->clip_plane_enable) {
STRCAT_WITH_RET(glsl_hdr, "uniform vec4 clipp[8];\n");
EMIT_HDR_WITH_RET(ctx, "uniform vec4 clipp[8];\n");
}
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
} else {
snprintf(buf, 255, "%s%s", clip_buf, cull_buf);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
STRCAT_WITH_RET(glsl_hdr, "vec4 clip_dist_temp[2];\n");
EMIT_HDR_WITH_RET(ctx, "vec4 clip_dist_temp[2];\n");
}
}
@ -4719,7 +4731,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->num_clip_dist) {
bool has_prop = (ctx->num_clip_dist_prop + ctx->num_cull_dist_prop) > 0;
@ -4737,20 +4749,20 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
} else
snprintf(clip_buf, 64, "out float gl_ClipDistance[%d];\n", num_clip_dists);
snprintf(buf, 255, "%s%s\n", clip_buf, cull_buf);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
snprintf(buf, 255, "vec4 clip_dist_temp[2];\n");
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->key->prev_stage_num_cull_out) {
snprintf(buf, 255, "in float gl_CullDistance[%d];\n", ctx->key->prev_stage_num_cull_out);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
@ -4768,13 +4780,13 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
snprintf(buf, 255, "vec4 clip_dist_temp[2];\n");
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
@ -4793,48 +4805,48 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
snprintf(buf, 255, "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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->write_mul_utemp) {
STRCAT_WITH_RET(glsl_hdr, "uvec4 mul_utemp;\n");
STRCAT_WITH_RET(glsl_hdr, "uvec4 umul_temp;\n");
EMIT_HDR_WITH_RET(ctx, "uvec4 mul_utemp;\n");
EMIT_HDR_WITH_RET(ctx, "uvec4 umul_temp;\n");
}
if (ctx->write_mul_itemp) {
STRCAT_WITH_RET(glsl_hdr, "ivec4 mul_itemp;\n");
STRCAT_WITH_RET(glsl_hdr, "ivec4 imul_temp;\n");
EMIT_HDR_WITH_RET(ctx, "ivec4 mul_itemp;\n");
EMIT_HDR_WITH_RET(ctx, "ivec4 imul_temp;\n");
}
if (ctx->ssbo_used_mask || ctx->has_file_memory) {
STRCAT_WITH_RET(glsl_hdr, "uint ssbo_addr_temp;\n");
EMIT_HDR_WITH_RET(ctx, "uint ssbo_addr_temp;\n");
}
if (ctx->shader_req_bits & SHADER_REQ_FP64) {
STRCAT_WITH_RET(glsl_hdr, "dvec2 fp64_dst[3];\n");
STRCAT_WITH_RET(glsl_hdr, "dvec2 fp64_src[4];\n");
EMIT_HDR_WITH_RET(ctx, "dvec2 fp64_dst[3];\n");
EMIT_HDR_WITH_RET(ctx, "dvec2 fp64_src[4];\n");
}
for (i = 0; i < ctx->num_address; i++) {
snprintf(buf, 255, "int addr%d;\n", i);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->key->color_two_side) {
if (ctx->color_in_mask & 1)
STRCAT_WITH_RET(glsl_hdr, "vec4 realcolor0;\n");
EMIT_HDR_WITH_RET(ctx, "vec4 realcolor0;\n");
if (ctx->color_in_mask & 2)
STRCAT_WITH_RET(glsl_hdr, "vec4 realcolor1;\n");
EMIT_HDR_WITH_RET(ctx, "vec4 realcolor1;\n");
}
if (ctx->num_ubo) {
const char *cname = tgsi_proc_to_prefix(ctx->prog_type);
@ -4842,11 +4854,11 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
} 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]);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
}
@ -4855,9 +4867,8 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
for (i = 0; i < ctx->num_sampler_arrays; i++) {
uint32_t first = ctx->sampler_arrays[i].first;
uint32_t range = ctx->sampler_arrays[i].array_size;
glsl_hdr = emit_sampler_decl(ctx, glsl_hdr, first, range, ctx->samplers + first);
if (!glsl_hdr)
return NULL;
if (!emit_sampler_decl(ctx, first, range, ctx->samplers + first))
return false;
}
} else {
nsamp = util_last_bit(ctx->samplers_used);
@ -4866,9 +4877,8 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
if ((ctx->samplers_used & (1 << i)) == 0)
continue;
glsl_hdr = emit_sampler_decl(ctx, glsl_hdr, i, 0, ctx->samplers + i);
if (!glsl_hdr)
return NULL;
if (!emit_sampler_decl(ctx, i, 0, ctx->samplers + i))
return false;
}
}
@ -4876,17 +4886,15 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
for (i = 0; i < ctx->num_image_arrays; i++) {
uint32_t first = ctx->image_arrays[i].first;
uint32_t range = ctx->image_arrays[i].array_size;
glsl_hdr = emit_image_decl(ctx, glsl_hdr, first, range, ctx->images + first);
if (!glsl_hdr)
return NULL;
if (!emit_image_decl(ctx, first, range, ctx->images + first))
return false;
}
} else {
uint32_t mask = ctx->images_used_mask;
while (mask) {
i = u_bit_scan(&mask);
glsl_hdr = emit_image_decl(ctx, glsl_hdr, i, 0, ctx->images + i);
if (!glsl_hdr)
return NULL;
if (!emit_image_decl(ctx, i, 0, ctx->images + i))
return false;
}
}
@ -4895,7 +4903,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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]);
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
if (ctx->info.indirect_files & (1 << TGSI_FILE_BUFFER)) {
@ -4905,7 +4913,7 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
} else {
uint32_t mask = ctx->ssbo_used_mask;
@ -4915,15 +4923,15 @@ static char *emit_ios(struct dump_ctx *ctx, char *glsl_hdr)
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,
get_string(type), sname, id);
STRCAT_WITH_RET(glsl_hdr, buf);
EMIT_HDR_WITH_RET(ctx, buf);
}
}
if (ctx->prog_type == TGSI_PROCESSOR_FRAGMENT &&
ctx->key->pstipple_tex == true) {
STRCAT_WITH_RET(glsl_hdr, "uniform sampler2D pstipple_sampler;\nfloat stip_temp;\n");
EMIT_HDR_WITH_RET(ctx, "uniform sampler2D pstipple_sampler;\nfloat stip_temp;\n");
}
return glsl_hdr;
return true;
}
static boolean fill_fragment_interpolants(struct dump_ctx *ctx, struct vrend_shader_info *sinfo)
@ -5001,7 +5009,6 @@ char *vrend_convert_shader(struct vrend_context *rctx,
struct dump_ctx ctx;
char *glsl_final = NULL;
boolean bret;
char *glsl_hdr = NULL;
memset(&ctx, 0, sizeof(struct dump_ctx));
@ -5061,19 +5068,17 @@ char *vrend_convert_shader(struct vrend_context *rctx,
if (bret == FALSE)
goto fail;
glsl_hdr = malloc(1024);
if (!glsl_hdr)
ctx.glsl_hdr = malloc(1024);
if (!ctx.glsl_hdr)
goto fail;
glsl_hdr[0] = '\0';
glsl_hdr = emit_header(&ctx, glsl_hdr);
if (!glsl_hdr)
ctx.glsl_hdr[0] = '\0';
if (!emit_header(&ctx))
goto fail;
glsl_hdr = emit_ios(&ctx, glsl_hdr);
if (!glsl_hdr)
if (!emit_ios(&ctx))
goto fail;
glsl_final = malloc(strlen(glsl_hdr) + strlen(ctx.glsl_main) + 1);
glsl_final = malloc(strlen(ctx.glsl_hdr) + strlen(ctx.glsl_main) + 1);
if (!glsl_final)
goto fail;
@ -5083,14 +5088,14 @@ char *vrend_convert_shader(struct vrend_context *rctx,
if (bret == FALSE)
goto fail;
strcat(glsl_final, glsl_hdr);
strcat(glsl_final, ctx.glsl_hdr);
strcat(glsl_final, ctx.glsl_main);
VREND_DEBUG(dbg_shader_glsl, rctx, "GLSL: %s\n", glsl_final);
free(ctx.temp_ranges);
free(ctx.glsl_main);
free(glsl_hdr);
free(ctx.glsl_hdr);
sinfo->num_ucp = ctx.key->clip_plane_enable ? 8 : 0;
sinfo->has_pervertex_out = ctx.vs_has_pervertex;
sinfo->has_sample_input = ctx.has_sample_input;
@ -5146,7 +5151,7 @@ char *vrend_convert_shader(struct vrend_context *rctx,
fail:
free(ctx.glsl_main);
free(glsl_final);
free(glsl_hdr);
free(ctx.glsl_hdr);
free(ctx.so_names);
free(ctx.temp_ranges);
return NULL;

Write Preview
Loading…
Cancel
Save