[Mesa-dev] [PATCH 11/34] glsl: support compilation of geometry shaders
Ian Romanick
idr at freedesktop.org
Wed Jul 31 17:16:52 PDT 2013
On 07/28/2013 11:03 PM, Paul Berry wrote:
> From: Bryan Cain <bryancain3 at gmail.com>
>
> This commit adds all of the parsing and semantics for GLSL 150 style
> geometry shaders.
>
> v2 (Paul Berry <stereotype441 at gmail.com>): Adjust i965's
> brw_link_shader() to pass the new is_geometry_shader argument to
> do_set_program_inouts. Add a few missing calls to
> get_pipeline_stage(). Fix some signed/unsigned comparison warnings.
> Fix handling of NULL consumer in assign_varying_locations().
>
> v3 (Bryan Cain <bryancain3 at gmail.com>): fix indexing order of 2D
> arrays. Also, allow interpolation qualifiers in geometry shaders.
>
> v4 (Paul Berry <stereotype441 at gmail.com>): Eliminate
> get_pipeline_stage()--it is no longer needed thanks to 030ca23 (mesa:
> renumber shader indices according to their placement in pipeline).
> Remove 2D stuff. Move vertices_per_prim() to ir.h, so that it will be
> accessible from outside the linker. Remove
> inject_num_vertices_visitor. Move use of geom_array_resize_visitor
> prior to use of array_resizing_visitor. Rework for GLSL 1.50. Use a
> single shader_type argument for do_set_program_inouts()
> ---
> src/glsl/ast_to_hir.cpp | 31 +++++--
> src/glsl/ir.cpp | 21 +++++
> src/glsl/ir.h | 5 +-
> src/glsl/ir_set_program_inouts.cpp | 86 +++++++++++++-----
> src/glsl/linker.cpp | 135 +++++++++++++++++++++++++++--
> src/mesa/drivers/dri/i965/brw_shader.cpp | 3 +-
> src/mesa/main/mtypes.h | 4 +-
> src/mesa/program/ir_to_mesa.cpp | 2 +-
> src/mesa/state_tracker/st_glsl_to_tgsi.cpp | 2 +-
> 9 files changed, 253 insertions(+), 36 deletions(-)
>
> diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp
> index 2569cde..431a13d 100644
> --- a/src/glsl/ast_to_hir.cpp
> +++ b/src/glsl/ast_to_hir.cpp
> @@ -2056,11 +2056,11 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
> var->interpolation = INTERP_QUALIFIER_NONE;
>
> if (var->interpolation != INTERP_QUALIFIER_NONE &&
> - !(state->target == vertex_shader && var->mode == ir_var_shader_out) &&
> - !(state->target == fragment_shader && var->mode == ir_var_shader_in)) {
> + ((state->target == vertex_shader && var->mode == ir_var_shader_in) ||
> + (state->target == fragment_shader && var->mode == ir_var_shader_out))) {
> _mesa_glsl_error(loc, state,
> - "interpolation qualifier `%s' can only be applied to "
> - "vertex shader outputs and fragment shader inputs",
> + "interpolation qualifier `%s' cannot be applied to "
> + "vertex shader inputs or fragment shader outputs",
> var->interpolation_string());
> }
>
> @@ -2662,6 +2662,27 @@ ast_declarator_list::hir(exec_list *instructions,
>
> var = new(ctx) ir_variable(var_type, decl->identifier, ir_var_auto);
>
> + /* The 'varying in' and 'varying out' qualifiers can only be used with
> + * ARB_geometry_shader4 and EXT_geometry_shader4, which we don't support
> + * yet.
> + */
> + if (this->type->qualifier.flags.q.varying) {
> + if (this->type->qualifier.flags.q.in) {
> + _mesa_glsl_error(& loc, state,
> + "`varying in' qualifier in declaration of "
> + "`%s' only valid for geometry shaders using "
> + "ARB_geometry_shader4 or EXT_geometry_shader4",
> + decl->identifier);
> + }
> + else if (this->type->qualifier.flags.q.out) {
> + _mesa_glsl_error(& loc, state,
> + "`varying out' qualifier in declaration of "
> + "`%s' only valid for geometry shaders using "
> + "ARB_geometry_shader4 or EXT_geometry_shader4",
> + decl->identifier);
> + }
> + }
> +
> /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification;
> *
> * "Global variables can only use the qualifiers const,
> @@ -2906,7 +2927,7 @@ ast_declarator_list::hir(exec_list *instructions,
> }
> break;
> default:
> - assert(0);
> + break;
> }
> }
>
> diff --git a/src/glsl/ir.cpp b/src/glsl/ir.cpp
> index dad58de..1a3983e 100644
> --- a/src/glsl/ir.cpp
> +++ b/src/glsl/ir.cpp
> @@ -1778,3 +1778,24 @@ ir_rvalue::as_rvalue_to_saturate()
>
> return NULL;
> }
> +
> +
> +unsigned
> +vertices_per_prim(GLenum prim)
> +{
> + switch (prim) {
> + case GL_POINTS:
> + return 1;
> + case GL_LINES:
> + return 2;
> + case GL_TRIANGLES:
> + return 3;
> + case GL_LINES_ADJACENCY_ARB:
> + return 4;
> + case GL_TRIANGLES_ADJACENCY_ARB:
> + return 6;
We should use the undecorated names.
> + default:
> + assert(!"Bad primitive");
> + return 3;
> + }
> +}
> diff --git a/src/glsl/ir.h b/src/glsl/ir.h
> index ae79a39..af9d77e 100644
> --- a/src/glsl/ir.h
> +++ b/src/glsl/ir.h
> @@ -2112,7 +2112,7 @@ ir_has_call(ir_instruction *ir);
>
> extern void
> do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
> - bool is_fragment_shader);
> + GLenum shader_type);
>
> extern char *
> prototype_string(const glsl_type *return_type, const char *name,
> @@ -2128,4 +2128,7 @@ extern void _mesa_print_ir(struct exec_list *instructions,
> } /* extern "C" */
> #endif
>
> +unsigned
> +vertices_per_prim(GLenum prim);
> +
> #endif /* IR_H */
> diff --git a/src/glsl/ir_set_program_inouts.cpp b/src/glsl/ir_set_program_inouts.cpp
> index 91a8b45..a578e2a 100644
> --- a/src/glsl/ir_set_program_inouts.cpp
> +++ b/src/glsl/ir_set_program_inouts.cpp
> @@ -44,11 +44,10 @@
>
> class ir_set_program_inouts_visitor : public ir_hierarchical_visitor {
> public:
> - ir_set_program_inouts_visitor(struct gl_program *prog,
> - bool is_fragment_shader)
> + ir_set_program_inouts_visitor(struct gl_program *prog, GLenum shader_type)
> {
> this->prog = prog;
> - this->is_fragment_shader = is_fragment_shader;
> + this->shader_type = shader_type;
> }
> ~ir_set_program_inouts_visitor()
> {
> @@ -61,7 +60,7 @@ public:
> virtual ir_visitor_status visit(ir_dereference_variable *);
>
> struct gl_program *prog;
> - bool is_fragment_shader;
> + GLenum shader_type;
> };
>
> static inline bool
> @@ -112,14 +111,24 @@ ir_set_program_inouts_visitor::visit(ir_dereference_variable *ir)
> return visit_continue;
>
> if (ir->type->is_array()) {
> - mark(this->prog, ir->var, 0,
> - ir->type->length * ir->type->fields.array->matrix_columns,
> - this->is_fragment_shader);
> + int matrix_columns = ir->type->fields.array->matrix_columns;
> + int length = ir->type->length;
> + if (this->shader_type == GL_GEOMETRY_SHADER &&
> + ir->var->mode == ir_var_shader_in) {
> + if (ir->type->element_type()->is_array()) {
> + const glsl_type *inner_array_type = ir->type->fields.array;
> + matrix_columns = inner_array_type->fields.array->matrix_columns;
> + length = inner_array_type->length;
> + } else {
> + length = 1;
> + }
> + }
> + mark(this->prog, ir->var, 0, length * matrix_columns,
> + this->shader_type == GL_FRAGMENT_SHADER);
> } else {
> mark(this->prog, ir->var, 0, ir->type->matrix_columns,
> - this->is_fragment_shader);
> + this->shader_type == GL_FRAGMENT_SHADER);
> }
> -
Spurious (and not necessarily correct) whitespace change.
> return visit_continue;
> }
>
> @@ -129,7 +138,40 @@ ir_set_program_inouts_visitor::visit_enter(ir_dereference_array *ir)
> ir_dereference_variable *deref_var;
> ir_constant *index = ir->array_index->as_constant();
> deref_var = ir->array->as_dereference_variable();
> - ir_variable *var = deref_var ? deref_var->var : NULL;
> + ir_variable *var;
> + bool is_vert_array = false, is_2D_array = false;
> +
> + /* Check whether this dereference is of a GS input array. These are special
> + * because the array index refers to the index of an input vertex instead of
> + * the attribute index. The exceptions to this exception are 2D arrays
> + * such as gl_TexCoordIn. For these, there is a nested dereference_array,
> + * where the inner index specifies the vertex and the outer index specifies
> + * the attribute. To complicate things further, matrix columns are also
> + * accessed with dereference_array. So we have to correctly handle 1D
> + * arrays of non-matrices, 1D arrays of matrices, 2D arrays of non-matrices,
> + * and 2D arrays of matrices.
> + */
> + if (this->shader_type == GL_GEOMETRY_SHADER) {
> + if (!deref_var) {
> + /* Either an outer (attribute) dereference of a 2D array or a column
> + * dereference of an array of matrices. */
> + ir_dereference_array *inner_deref = ir->array->as_dereference_array();
> + assert(inner_deref);
> + deref_var = inner_deref->array->as_dereference_variable();
> + is_2D_array = true;
> + }
> +
> + if (deref_var && deref_var->var->mode == ir_var_shader_in) {
> + if (ir->type->is_array())
> + /* Inner (vertex) dereference of a 2D array */
> + return visit_continue;
> + else
> + /* Dereference of a 1D (vertex) array */
> + is_vert_array = true;
> + }
> + }
> +
> + var = deref_var ? deref_var->var : NULL;
>
> /* Check that we're dereferencing a shader in or out */
> if (!var || !is_shader_inout(var))
> @@ -137,14 +179,17 @@ ir_set_program_inouts_visitor::visit_enter(ir_dereference_array *ir)
>
> if (index) {
> int width = 1;
> + const glsl_type *type = is_vert_array ?
> + deref_var->type->fields.array : deref_var->type;
> + int offset = is_vert_array && !is_2D_array ? 0 : index->value.i[0];
>
> - if (deref_var->type->is_array() &&
> - deref_var->type->fields.array->is_matrix()) {
> - width = deref_var->type->fields.array->matrix_columns;
> + if (type->is_array() &&
> + type->fields.array->is_matrix()) {
> + width = type->fields.array->matrix_columns;
> }
>
> - mark(this->prog, var, index->value.i[0] * width, width,
> - this->is_fragment_shader);
> + mark(this->prog, var, offset * width, width,
> + this->shader_type == GL_FRAGMENT_SHADER);
> return visit_continue_with_parent;
> }
>
> @@ -164,7 +209,8 @@ ir_set_program_inouts_visitor::visit_enter(ir_function_signature *ir)
> ir_visitor_status
> ir_set_program_inouts_visitor::visit_enter(ir_expression *ir)
> {
> - if (is_fragment_shader && ir->operation == ir_unop_dFdy) {
> + if (this->shader_type == GL_FRAGMENT_SHADER &&
> + ir->operation == ir_unop_dFdy) {
> gl_fragment_program *fprog = (gl_fragment_program *) prog;
> fprog->UsesDFdy = true;
> }
> @@ -175,7 +221,7 @@ ir_visitor_status
> ir_set_program_inouts_visitor::visit_enter(ir_discard *)
> {
> /* discards are only allowed in fragment shaders. */
> - assert(is_fragment_shader);
> + assert(this->shader_type == GL_FRAGMENT_SHADER);
>
> gl_fragment_program *fprog = (gl_fragment_program *) prog;
> fprog->UsesKill = true;
> @@ -185,14 +231,14 @@ ir_set_program_inouts_visitor::visit_enter(ir_discard *)
>
> void
> do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
> - bool is_fragment_shader)
> + GLenum shader_type)
> {
> - ir_set_program_inouts_visitor v(prog, is_fragment_shader);
> + ir_set_program_inouts_visitor v(prog, shader_type);
>
> prog->InputsRead = 0;
> prog->OutputsWritten = 0;
> prog->SystemValuesRead = 0;
> - if (is_fragment_shader) {
> + if (shader_type == GL_FRAGMENT_SHADER) {
> gl_fragment_program *fprog = (gl_fragment_program *) prog;
> memset(fprog->InterpQualifier, 0, sizeof(fprog->InterpQualifier));
> fprog->IsCentroid = 0;
> diff --git a/src/glsl/linker.cpp b/src/glsl/linker.cpp
> index 7192567..70d9cf4 100644
> --- a/src/glsl/linker.cpp
> +++ b/src/glsl/linker.cpp
> @@ -73,11 +73,14 @@
> #include "linker.h"
> #include "link_varyings.h"
> #include "ir_optimization.h"
> +#include "ir_rvalue_visitor.h"
>
> extern "C" {
> #include "main/shaderobj.h"
> }
>
> +void linker_error(gl_shader_program *, const char *, ...);
> +
Shouldn't this already come form linker.h?
> /**
> * Visitor that determines whether or not a variable is ever written.
> */
> @@ -174,6 +177,77 @@ private:
> };
>
>
> +class geom_array_resize_visitor : public ir_hierarchical_visitor {
> +public:
> + unsigned num_vertices;
> + gl_shader_program *prog;
> +
> + geom_array_resize_visitor(unsigned num_vertices, gl_shader_program *prog)
> + {
> + this->num_vertices = num_vertices;
> + this->prog = prog;
> + }
> +
> + virtual ~geom_array_resize_visitor()
> + {
> + /* empty */
> + }
> +
> + virtual ir_visitor_status visit(ir_variable *var)
> + {
> + if (!var->type->is_array() || var->mode != ir_var_shader_in)
> + return visit_continue;
> +
> + unsigned size = var->type->length;
> +
> + /* Generate a link error if the shader has declared this array with an
> + * incorrect size.
> + */
> + if (size && size != this->num_vertices) {
> + linker_error(this->prog, "size of array %s declared as %u, "
> + "but number of input vertices is %u\n",
> + var->name, size, this->num_vertices);
> + return visit_continue;
> + }
> +
> + /* Generate a link error if the shader attempts to access an input
> + * array using an index too large for its actual size assigned at link
> + * time.
> + */
Can this actually occur? It seems like the previous check and the
existing checks against var->type->length would catch this case. If it
can occur, is there a test? :) Hmm... is it only when size == 0?
> + if (var->max_array_access >= this->num_vertices) {
> + linker_error(this->prog, "geometry shader accesses element %i of "
> + "%s, but only %i input vertices\n",
> + var->max_array_access, var->name, this->num_vertices);
> + return visit_continue;
> + }
> +
> + var->type = glsl_type::get_array_instance(var->type->element_type(),
> + this->num_vertices);
> + var->max_array_access = this->num_vertices - 1;
> +
> + return visit_continue;
> + }
> +
> + /* Dereferences of input variables need to be updated so that their type
> + * matches the newly assigned type of the variable they are accessing. */
> + virtual ir_visitor_status visit(ir_dereference_variable *ir)
> + {
> + ir->type = ir->var->type;
> + return visit_continue;
> + }
> +
> + /* Dereferences of 2D input arrays need to be updated so that their type
> + * matches the newly assigned type of the array they are accessing. */
> + virtual ir_visitor_status visit_leave(ir_dereference_array *ir)
> + {
> + const glsl_type *const vt = ir->array->type;
> + if (vt->is_array())
> + ir->type = vt->element_type();
> + return visit_continue;
> + }
> +};
> +
> +
> void
> linker_error(gl_shader_program *prog, const char *fmt, ...)
> {
> @@ -437,6 +511,24 @@ validate_fragment_shader_executable(struct gl_shader_program *prog,
> }
> }
>
> +/**
> + * Verify that a geometry shader executable meets all semantic requirements
> + *
> + * Also sets prog->Geom.VerticesIn as a side effect.
> + *
> + * \param shader Geometry shader executable to be verified
> + */
> +void
> +validate_geometry_shader_executable(struct gl_shader_program *prog,
> + struct gl_shader *shader)
> +{
> + if (shader == NULL)
> + return;
> +
> + unsigned num_vertices = vertices_per_prim(prog->Geom.InputType);
> + prog->Geom.VerticesIn = num_vertices;
> +}
> +
>
> /**
> * Generate a string describing the mode of a variable
> @@ -1091,6 +1183,16 @@ link_intrastage_shaders(void *mem_ctx,
> if (linked)
> validate_ir_tree(linked->ir);
>
> + /* Set the size of geometry shader input arrays */
> + if (linked->Type == GL_GEOMETRY_SHADER) {
> + unsigned num_vertices = vertices_per_prim(prog->Geom.InputType);
> + geom_array_resize_visitor input_resize_visitor(num_vertices, prog);
> + foreach_iter(exec_list_iterator, iter, *linked->ir) {
> + ir_instruction *ir = (ir_instruction *)iter.get();
> + ir->accept(&input_resize_visitor);
> + }
> + }
> +
> /* Make a pass over all variable declarations to ensure that arrays with
> * unspecified sizes have a size specified. The size is inferred from the
> * max_array_access field.
> @@ -1648,10 +1750,13 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
> unsigned num_vert_shaders = 0;
> struct gl_shader **frag_shader_list;
> unsigned num_frag_shaders = 0;
> + struct gl_shader **geom_shader_list;
> + unsigned num_geom_shaders = 0;
>
> vert_shader_list = (struct gl_shader **)
> - calloc(2 * prog->NumShaders, sizeof(struct gl_shader *));
> + calloc(3 * prog->NumShaders, sizeof(struct gl_shader *));
> frag_shader_list = &vert_shader_list[prog->NumShaders];
> + geom_shader_list = &vert_shader_list[prog->NumShaders * 2];
>
> unsigned min_version = UINT_MAX;
> unsigned max_version = 0;
> @@ -1677,8 +1782,8 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
> num_frag_shaders++;
> break;
> case GL_GEOMETRY_SHADER:
> - /* FINISHME: Support geometry shaders. */
> - assert(prog->Shaders[i]->Type != GL_GEOMETRY_SHADER);
> + geom_shader_list[num_geom_shaders] = prog->Shaders[i];
> + num_geom_shaders++;
> break;
> }
> }
> @@ -1740,6 +1845,22 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
> sh);
> }
>
> + if (num_geom_shaders > 0) {
> + gl_shader *const sh =
> + link_intrastage_shaders(mem_ctx, ctx, prog, geom_shader_list,
> + num_geom_shaders);
> +
> + if (!prog->LinkStatus)
> + goto done;
> +
> + validate_geometry_shader_executable(prog, sh);
> + if (!prog->LinkStatus)
> + goto done;
> +
> + _mesa_reference_shader(ctx, &prog->_LinkedShaders[MESA_SHADER_GEOMETRY],
> + sh);
> + }
> +
> /* Here begins the inter-stage linking phase. Some initial validation is
> * performed, then locations are assigned for uniforms, attributes, and
> * varyings.
> @@ -1826,7 +1947,11 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
> prog->_LinkedShaders[MESA_SHADER_VERTEX],
> VERT_ATTRIB_GENERIC0, VARYING_SLOT_VAR0);
> }
> - /* FINISHME: Geometry shaders not implemented yet */
> + if (prog->_LinkedShaders[MESA_SHADER_GEOMETRY] != NULL) {
> + link_invalidate_variable_locations(
> + prog->_LinkedShaders[MESA_SHADER_GEOMETRY],
> + VARYING_SLOT_VAR0, VARYING_SLOT_VAR0);
> + }
> if (prog->_LinkedShaders[MESA_SHADER_FRAGMENT] != NULL) {
> link_invalidate_variable_locations(
> prog->_LinkedShaders[MESA_SHADER_FRAGMENT],
> @@ -1860,7 +1985,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
> * non-zero, but the program object has no vertex or geometry
> * shader;
> */
> - if (first >= MESA_SHADER_FRAGMENT) {
> + if (first == MESA_SHADER_FRAGMENT) {
> linker_error(prog, "Transform feedback varyings specified, but "
> "no vertex or geometry shader is present.");
> goto done;
> diff --git a/src/mesa/drivers/dri/i965/brw_shader.cpp b/src/mesa/drivers/dri/i965/brw_shader.cpp
> index 3322e80..418ea9b 100644
> --- a/src/mesa/drivers/dri/i965/brw_shader.cpp
> +++ b/src/mesa/drivers/dri/i965/brw_shader.cpp
> @@ -236,8 +236,7 @@ brw_link_shader(struct gl_context *ctx, struct gl_shader_program *shProg)
> reparent_ir(shader->ir, shader->ir);
> ralloc_free(mem_ctx);
>
> - do_set_program_inouts(shader->ir, prog,
> - shader->base.Type == GL_FRAGMENT_SHADER);
> + do_set_program_inouts(shader->ir, prog, shader->base.Type);
>
> prog->SamplersUsed = shader->base.active_samplers;
> _mesa_update_shader_textures_used(shProg, prog);
> diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
> index efa2d39..2725eef 100644
> --- a/src/mesa/main/mtypes.h
> +++ b/src/mesa/main/mtypes.h
> @@ -1851,7 +1851,7 @@ struct gl_program
> GLuint Id;
> GLubyte *String; /**< Null-terminated program text */
> GLint RefCount;
> - GLenum Target; /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB */
> + GLenum Target; /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_GEOMETRY_PROGRAM_NV */
> GLenum Format; /**< String encoding format */
>
> struct prog_instruction *Instructions;
> @@ -1918,6 +1918,7 @@ struct gl_geometry_program
> {
> struct gl_program Base; /**< base class */
>
> + GLint VerticesIn;
> GLint VerticesOut;
> GLenum InputType; /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
> GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
> @@ -2320,6 +2321,7 @@ struct gl_shader_program
>
> /** Geometry shader state - copied into gl_geometry_program at link time */
> struct {
> + GLint VerticesIn;
> GLint VerticesOut;
> GLenum InputType; /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
> GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
> diff --git a/src/mesa/program/ir_to_mesa.cpp b/src/mesa/program/ir_to_mesa.cpp
> index e526582..914aca4 100644
> --- a/src/mesa/program/ir_to_mesa.cpp
> +++ b/src/mesa/program/ir_to_mesa.cpp
> @@ -2975,7 +2975,7 @@ get_mesa_program(struct gl_context *ctx,
> */
> mesa_instructions = NULL;
>
> - do_set_program_inouts(shader->ir, prog, shader->Type == GL_FRAGMENT_SHADER);
> + do_set_program_inouts(shader->ir, prog, shader->Type);
>
> prog->SamplersUsed = shader->active_samplers;
> prog->ShadowSamplers = shader->shadow_samplers;
> diff --git a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> index 77623f9..52e44ad 100644
> --- a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> +++ b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
> @@ -5128,7 +5128,7 @@ get_mesa_program(struct gl_context *ctx,
> prog->Instructions = NULL;
> prog->NumInstructions = 0;
>
> - do_set_program_inouts(shader->ir, prog, shader->Type == GL_FRAGMENT_SHADER);
> + do_set_program_inouts(shader->ir, prog, shader->Type);
> count_resources(v, prog);
>
> _mesa_reference_program(ctx, &shader->Program, prog);
>
More information about the mesa-dev
mailing list