OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

glsl/mesa: move duplicate shader fields into new struct gl_shader_info

Browse Source 
Reviewed-by: Iago Toral Quiroga <itoral@igalia.com>
This commit is contained in:
Timothy Arceri
2016-06-30 14:44:59 +10:00
parent fd2b3da5c8
commit 1591e668e1
11 changed files with 303 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
src/compiler/glsl/glsl_parser_extras.cpp
View File

@@ -1648,14 +1648,14 @@ set_shader_inout_layout(struct gl_shader *shader,
if (state->out_qualifier->out_xfb_stride[i]->
process_qualifier_constant(state, "xfb_stride", &xfb_stride,
true)) {
shader->TransformFeedback.BufferStride[i] = xfb_stride;
shader->info.TransformFeedback.BufferStride[i] = xfb_stride;
}
}
}
switch (shader->Stage) {
case MESA_SHADER_TESS_CTRL:
shader->TessCtrl.VerticesOut = 0;
shader->info.TessCtrl.VerticesOut = 0;
if (state->tcs_output_vertices_specified) {
unsigned vertices;
if (state->out_qualifier->vertices->
@@ -1667,29 +1667,29 @@ set_shader_inout_layout(struct gl_shader *shader,
_mesa_glsl_error(&loc, state, "vertices (%d) exceeds "
"GL_MAX_PATCH_VERTICES", vertices);
}
shader->TessCtrl.VerticesOut = vertices;
shader->info.TessCtrl.VerticesOut = vertices;
}
}
break;
case MESA_SHADER_TESS_EVAL:
shader->TessEval.PrimitiveMode = PRIM_UNKNOWN;
shader->info.TessEval.PrimitiveMode = PRIM_UNKNOWN;
if (state->in_qualifier->flags.q.prim_type)
shader->TessEval.PrimitiveMode = state->in_qualifier->prim_type;
shader->info.TessEval.PrimitiveMode = state->in_qualifier->prim_type;
shader->TessEval.Spacing = 0;
shader->info.TessEval.Spacing = 0;
if (state->in_qualifier->flags.q.vertex_spacing)
shader->TessEval.Spacing = state->in_qualifier->vertex_spacing;
shader->info.TessEval.Spacing = state->in_qualifier->vertex_spacing;
shader->TessEval.VertexOrder = 0;
shader->info.TessEval.VertexOrder = 0;
if (state->in_qualifier->flags.q.ordering)
shader->TessEval.VertexOrder = state->in_qualifier->ordering;
shader->info.TessEval.VertexOrder = state->in_qualifier->ordering;
shader->TessEval.PointMode = -1;
shader->info.TessEval.PointMode = -1;
if (state->in_qualifier->flags.q.point_mode)
shader->TessEval.PointMode = state->in_qualifier->point_mode;
shader->info.TessEval.PointMode = state->in_qualifier->point_mode;
break;
case MESA_SHADER_GEOMETRY:
shader->Geom.VerticesOut = -1;
shader->info.Geom.VerticesOut = -1;
if (state->out_qualifier->flags.q.max_vertices) {
unsigned qual_max_vertices;
if (state->out_qualifier->max_vertices->
@@ -1703,23 +1703,23 @@ set_shader_inout_layout(struct gl_shader *shader,
"GL_MAX_GEOMETRY_OUTPUT_VERTICES",
qual_max_vertices);
}
shader->Geom.VerticesOut = qual_max_vertices;
shader->info.Geom.VerticesOut = qual_max_vertices;
}
}
if (state->gs_input_prim_type_specified) {
shader->Geom.InputType = state->in_qualifier->prim_type;
shader->info.Geom.InputType = state->in_qualifier->prim_type;
} else {
shader->Geom.InputType = PRIM_UNKNOWN;
shader->info.Geom.InputType = PRIM_UNKNOWN;
}
if (state->out_qualifier->flags.q.prim_type) {
shader->Geom.OutputType = state->out_qualifier->prim_type;
shader->info.Geom.OutputType = state->out_qualifier->prim_type;
} else {
shader->Geom.OutputType = PRIM_UNKNOWN;
shader->info.Geom.OutputType = PRIM_UNKNOWN;
}
shader->Geom.Invocations = 0;
shader->info.Geom.Invocations = 0;
if (state->in_qualifier->flags.q.invocations) {
unsigned invocations;
if (state->in_qualifier->invocations->
@@ -1733,7 +1733,7 @@ set_shader_inout_layout(struct gl_shader *shader,
"GL_MAX_GEOMETRY_SHADER_INVOCATIONS",
invocations);
}
shader->Geom.Invocations = invocations;
shader->info.Geom.Invocations = invocations;
}
}
break;
@@ -1741,21 +1741,22 @@ set_shader_inout_layout(struct gl_shader *shader,
case MESA_SHADER_COMPUTE:
if (state->cs_input_local_size_specified) {
for (int i = 0; i < 3; i++)
shader->Comp.LocalSize[i] = state->cs_input_local_size[i];
shader->info.Comp.LocalSize[i] = state->cs_input_local_size[i];
} else {
for (int i = 0; i < 3; i++)
shader->Comp.LocalSize[i] = 0;
shader->info.Comp.LocalSize[i] = 0;
}
break;
case MESA_SHADER_FRAGMENT:
shader->redeclares_gl_fragcoord = state->fs_redeclares_gl_fragcoord;
shader->uses_gl_fragcoord = state->fs_uses_gl_fragcoord;
shader->pixel_center_integer = state->fs_pixel_center_integer;
shader->origin_upper_left = state->fs_origin_upper_left;
shader->ARB_fragment_coord_conventions_enable =
shader->info.redeclares_gl_fragcoord =
state->fs_redeclares_gl_fragcoord;
shader->info.uses_gl_fragcoord = state->fs_uses_gl_fragcoord;
shader->info.pixel_center_integer = state->fs_pixel_center_integer;
shader->info.origin_upper_left = state->fs_origin_upper_left;
shader->info.ARB_fragment_coord_conventions_enable =
state->ARB_fragment_coord_conventions_enable;
shader->EarlyFragmentTests = state->fs_early_fragment_tests;
shader->info.EarlyFragmentTests = state->fs_early_fragment_tests;
break;
default:
@@ -1877,7 +1878,7 @@ _mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *shader,
shader->InfoLog = state->info_log;
shader->Version = state->language_version;
shader->IsES = state->es_shader;
shader->uses_builtin_functions = state->uses_builtin_functions;
shader->info.uses_builtin_functions = state->uses_builtin_functions;
/* Retain any live IR, but trash the rest. */
reparent_ir(shader->ir, shader->ir);

10
src/compiler/glsl/glsl_to_nir.cpp
View File

@@ -166,14 +166,14 @@ glsl_to_nir(const struct gl_shader_program *shader_prog,
switch (stage) {
case MESA_SHADER_TESS_CTRL:
shader->info.tcs.vertices_out = sh->TessCtrl.VerticesOut;
shader->info.tcs.vertices_out = sh->info.TessCtrl.VerticesOut;
break;
case MESA_SHADER_GEOMETRY:
shader->info.gs.vertices_in = shader_prog->Geom.VerticesIn;
shader->info.gs.output_primitive = sh->Geom.OutputType;
shader->info.gs.vertices_out = sh->Geom.VerticesOut;
shader->info.gs.invocations = sh->Geom.Invocations;
shader->info.gs.output_primitive = sh->info.Geom.OutputType;
shader->info.gs.vertices_out = sh->info.Geom.VerticesOut;
shader->info.gs.invocations = sh->info.Geom.Invocations;
shader->info.gs.uses_end_primitive = shader_prog->Geom.UsesEndPrimitive;
shader->info.gs.uses_streams = shader_prog->Geom.UsesStreams;
break;
@@ -184,7 +184,7 @@ glsl_to_nir(const struct gl_shader_program *shader_prog,
shader->info.fs.uses_discard = fp->UsesKill;
shader->info.fs.uses_sample_qualifier = fp->IsSample != 0;
shader->info.fs.early_fragment_tests = sh->EarlyFragmentTests;
shader->info.fs.early_fragment_tests = sh->info.EarlyFragmentTests;
shader->info.fs.depth_layout = fp->FragDepthLayout;
break;
}

2
src/compiler/glsl/link_varyings.cpp
View File

@@ -118,7 +118,7 @@ process_xfb_layout_qualifiers(void *mem_ctx, const gl_linked_shader *sh,
* xfb_stride to interface block members so this will catch that case also.
*/
for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
if (sh->TransformFeedback.BufferStride[j]) {
if (sh->info.TransformFeedback.BufferStride[j]) {
has_xfb_qualifiers = true;
}
}

249
src/compiler/glsl/linker.cpp
View File

@@ -857,7 +857,7 @@ validate_geometry_shader_executable(struct gl_shader_program *prog,
if (shader == NULL)
return;
unsigned num_vertices = vertices_per_prim(shader->Geom.InputType);
unsigned num_vertices = vertices_per_prim(shader->info.Geom.InputType);
prog->Geom.VerticesIn = num_vertices;
analyze_clip_cull_usage(prog, shader, ctx,
@@ -912,7 +912,7 @@ validate_geometry_shader_emissions(struct gl_context *ctx,
* EmitStreamVertex() or EmitEndPrimitive() are called with a non-zero
* stream.
*/
if (prog->Geom.UsesStreams && sh->Geom.OutputType != GL_POINTS) {
if (prog->Geom.UsesStreams && sh->info.Geom.OutputType != GL_POINTS) {
linker_error(prog, "EmitStreamVertex(n) and EndStreamPrimitive(n) "
"with n>0 requires point output\n");
}
@@ -1687,37 +1687,38 @@ link_xfb_stride_layout_qualifiers(struct gl_context *ctx,
unsigned num_shaders)
{
for (unsigned i = 0; i < MAX_FEEDBACK_BUFFERS; i++) {
linked_shader->TransformFeedback.BufferStride[i] = 0;
linked_shader->info.TransformFeedback.BufferStride[i] = 0;
}
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
if (shader->TransformFeedback.BufferStride[j]) {
if (linked_shader->TransformFeedback.BufferStride[j] != 0 &&
shader->TransformFeedback.BufferStride[j] != 0 &&
linked_shader->TransformFeedback.BufferStride[j] !=
shader->TransformFeedback.BufferStride[j]) {
if (shader->info.TransformFeedback.BufferStride[j]) {
if (linked_shader->info.TransformFeedback.BufferStride[j] != 0 &&
shader->info.TransformFeedback.BufferStride[j] != 0 &&
linked_shader->info.TransformFeedback.BufferStride[j] !=
shader->info.TransformFeedback.BufferStride[j]) {
linker_error(prog,
"intrastage shaders defined with conflicting "
"xfb_stride for buffer %d (%d and %d)\n", j,
linked_shader->TransformFeedback.BufferStride[j],
shader->TransformFeedback.BufferStride[j]);
linked_shader->
info.TransformFeedback.BufferStride[j],
shader->info.TransformFeedback.BufferStride[j]);
return;
}
if (shader->TransformFeedback.BufferStride[j])
linked_shader->TransformFeedback.BufferStride[j] =
shader->TransformFeedback.BufferStride[j];
if (shader->info.TransformFeedback.BufferStride[j])
linked_shader->info.TransformFeedback.BufferStride[j] =
shader->info.TransformFeedback.BufferStride[j];
}
}
}
for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
if (linked_shader->TransformFeedback.BufferStride[j]) {
if (linked_shader->info.TransformFeedback.BufferStride[j]) {
prog->TransformFeedback.BufferStride[j] =
linked_shader->TransformFeedback.BufferStride[j];
linked_shader->info.TransformFeedback.BufferStride[j];
/* We will validate doubles at a later stage */
if (prog->TransformFeedback.BufferStride[j] % 4) {
@@ -1750,7 +1751,7 @@ link_tcs_out_layout_qualifiers(struct gl_shader_program *prog,
struct gl_shader **shader_list,
unsigned num_shaders)
{
linked_shader->TessCtrl.VerticesOut = 0;
linked_shader->info.TessCtrl.VerticesOut = 0;
if (linked_shader->Stage != MESA_SHADER_TESS_CTRL)
return;
@@ -1768,16 +1769,18 @@ link_tcs_out_layout_qualifiers(struct gl_shader_program *prog,
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
if (shader->TessCtrl.VerticesOut != 0) {
if (linked_shader->TessCtrl.VerticesOut != 0 &&
linked_shader->TessCtrl.VerticesOut != shader->TessCtrl.VerticesOut) {
if (shader->info.TessCtrl.VerticesOut != 0) {
if (linked_shader->info.TessCtrl.VerticesOut != 0 &&
linked_shader->info.TessCtrl.VerticesOut !=
shader->info.TessCtrl.VerticesOut) {
linker_error(prog, "tessellation control shader defined with "
"conflicting output vertex count (%d and %d)\n",
linked_shader->TessCtrl.VerticesOut,
shader->TessCtrl.VerticesOut);
linked_shader->info.TessCtrl.VerticesOut,
shader->info.TessCtrl.VerticesOut);
return;
}
linked_shader->TessCtrl.VerticesOut = shader->TessCtrl.VerticesOut;
linked_shader->info.TessCtrl.VerticesOut =
shader->info.TessCtrl.VerticesOut;
}
}
@@ -1785,7 +1788,7 @@ link_tcs_out_layout_qualifiers(struct gl_shader_program *prog,
* since we already know we're in the right type of shader program
* for doing it.
*/
if (linked_shader->TessCtrl.VerticesOut == 0) {
if (linked_shader->info.TessCtrl.VerticesOut == 0) {
linker_error(prog, "tessellation control shader didn't declare "
"vertices out layout qualifier\n");
return;
@@ -1805,10 +1808,10 @@ link_tes_in_layout_qualifiers(struct gl_shader_program *prog,
struct gl_shader **shader_list,
unsigned num_shaders)
{
linked_shader->TessEval.PrimitiveMode = PRIM_UNKNOWN;
linked_shader->TessEval.Spacing = 0;
linked_shader->TessEval.VertexOrder = 0;
linked_shader->TessEval.PointMode = -1;
linked_shader->info.TessEval.PrimitiveMode = PRIM_UNKNOWN;
linked_shader->info.TessEval.Spacing = 0;
linked_shader->info.TessEval.VertexOrder = 0;
linked_shader->info.TessEval.PointMode = -1;
if (linked_shader->Stage != MESA_SHADER_TESS_EVAL)
return;
@@ -1830,44 +1833,50 @@ link_tes_in_layout_qualifiers(struct gl_shader_program *prog,
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
if (shader->TessEval.PrimitiveMode != PRIM_UNKNOWN) {
if (linked_shader->TessEval.PrimitiveMode != PRIM_UNKNOWN &&
linked_shader->TessEval.PrimitiveMode != shader->TessEval.PrimitiveMode) {
if (shader->info.TessEval.PrimitiveMode != PRIM_UNKNOWN) {
if (linked_shader->info.TessEval.PrimitiveMode != PRIM_UNKNOWN &&
linked_shader->info.TessEval.PrimitiveMode !=
shader->info.TessEval.PrimitiveMode) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting input primitive modes.\n");
return;
}
linked_shader->TessEval.PrimitiveMode = shader->TessEval.PrimitiveMode;
linked_shader->info.TessEval.PrimitiveMode = shader->info.TessEval.PrimitiveMode;
}
if (shader->TessEval.Spacing != 0) {
if (linked_shader->TessEval.Spacing != 0 &&
linked_shader->TessEval.Spacing != shader->TessEval.Spacing) {
if (shader->info.TessEval.Spacing != 0) {
if (linked_shader->info.TessEval.Spacing != 0 &&
linked_shader->info.TessEval.Spacing !=
shader->info.TessEval.Spacing) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting vertex spacing.\n");
return;
}
linked_shader->TessEval.Spacing = shader->TessEval.Spacing;
linked_shader->info.TessEval.Spacing = shader->info.TessEval.Spacing;
}
if (shader->TessEval.VertexOrder != 0) {
if (linked_shader->TessEval.VertexOrder != 0 &&
linked_shader->TessEval.VertexOrder != shader->TessEval.VertexOrder) {
if (shader->info.TessEval.VertexOrder != 0) {
if (linked_shader->info.TessEval.VertexOrder != 0 &&
linked_shader->info.TessEval.VertexOrder !=
shader->info.TessEval.VertexOrder) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting ordering.\n");
return;
}
linked_shader->TessEval.VertexOrder = shader->TessEval.VertexOrder;
linked_shader->info.TessEval.VertexOrder =
shader->info.TessEval.VertexOrder;
}
if (shader->TessEval.PointMode != -1) {
if (linked_shader->TessEval.PointMode != -1 &&
linked_shader->TessEval.PointMode != shader->TessEval.PointMode) {
if (shader->info.TessEval.PointMode != -1) {
if (linked_shader->info.TessEval.PointMode != -1 &&
linked_shader->info.TessEval.PointMode !=
shader->info.TessEval.PointMode) {
linker_error(prog, "tessellation evaluation shader defined with "
"conflicting point modes.\n");
return;
}
linked_shader->TessEval.PointMode = shader->TessEval.PointMode;
linked_shader->info.TessEval.PointMode =
shader->info.TessEval.PointMode;
}
}
@@ -1876,21 +1885,21 @@ link_tes_in_layout_qualifiers(struct gl_shader_program *prog,
* since we already know we're in the right type of shader program
* for doing it.
*/
if (linked_shader->TessEval.PrimitiveMode == PRIM_UNKNOWN) {
if (linked_shader->info.TessEval.PrimitiveMode == PRIM_UNKNOWN) {
linker_error(prog,
"tessellation evaluation shader didn't declare input "
"primitive modes.\n");
return;
}
if (linked_shader->TessEval.Spacing == 0)
linked_shader->TessEval.Spacing = GL_EQUAL;
if (linked_shader->info.TessEval.Spacing == 0)
linked_shader->info.TessEval.Spacing = GL_EQUAL;
if (linked_shader->TessEval.VertexOrder == 0)
linked_shader->TessEval.VertexOrder = GL_CCW;
if (linked_shader->info.TessEval.VertexOrder == 0)
linked_shader->info.TessEval.VertexOrder = GL_CCW;
if (linked_shader->TessEval.PointMode == -1)
linked_shader->TessEval.PointMode = GL_FALSE;
if (linked_shader->info.TessEval.PointMode == -1)
linked_shader->info.TessEval.PointMode = GL_FALSE;
}
@@ -1905,10 +1914,10 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog,
struct gl_shader **shader_list,
unsigned num_shaders)
{
linked_shader->redeclares_gl_fragcoord = false;
linked_shader->uses_gl_fragcoord = false;
linked_shader->origin_upper_left = false;
linked_shader->pixel_center_integer = false;
linked_shader->info.redeclares_gl_fragcoord = false;
linked_shader->info.uses_gl_fragcoord = false;
linked_shader->info.origin_upper_left = false;
linked_shader->info.pixel_center_integer = false;
if (linked_shader->Stage != MESA_SHADER_FRAGMENT ||
(prog->Version < 150 && !prog->ARB_fragment_coord_conventions_enable))
@@ -1922,12 +1931,12 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog,
* it must be redeclared in all the fragment shaders in that program
* that have a static use gl_FragCoord."
*/
if ((linked_shader->redeclares_gl_fragcoord
&& !shader->redeclares_gl_fragcoord
&& shader->uses_gl_fragcoord)
|| (shader->redeclares_gl_fragcoord
&& !linked_shader->redeclares_gl_fragcoord
&& linked_shader->uses_gl_fragcoord)) {
if ((linked_shader->info.redeclares_gl_fragcoord
&& !shader->info.redeclares_gl_fragcoord
&& shader->info.uses_gl_fragcoord)
|| (shader->info.redeclares_gl_fragcoord
&& !linked_shader->info.redeclares_gl_fragcoord
&& linked_shader->info.uses_gl_fragcoord)) {
linker_error(prog, "fragment shader defined with conflicting "
"layout qualifiers for gl_FragCoord\n");
}
@@ -1937,9 +1946,12 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog,
* "All redeclarations of gl_FragCoord in all fragment shaders in a
* single program must have the same set of qualifiers."
*/
if (linked_shader->redeclares_gl_fragcoord && shader->redeclares_gl_fragcoord
&& (shader->origin_upper_left != linked_shader->origin_upper_left
|| shader->pixel_center_integer != linked_shader->pixel_center_integer)) {
if (linked_shader->info.redeclares_gl_fragcoord &&
shader->info.redeclares_gl_fragcoord &&
(shader->info.origin_upper_left !=
linked_shader->info.origin_upper_left ||
shader->info.pixel_center_integer !=
linked_shader->info.pixel_center_integer)) {
linker_error(prog, "fragment shader defined with conflicting "
"layout qualifiers for gl_FragCoord\n");
}
@@ -1949,16 +1961,21 @@ link_fs_input_layout_qualifiers(struct gl_shader_program *prog,
* are multiple redeclarations, all the fields except uses_gl_fragcoord
* are already known to be the same.
*/
if (shader->redeclares_gl_fragcoord || shader->uses_gl_fragcoord) {
linked_shader->redeclares_gl_fragcoord =
shader->redeclares_gl_fragcoord;
linked_shader->uses_gl_fragcoord = linked_shader->uses_gl_fragcoord
|| shader->uses_gl_fragcoord;
linked_shader->origin_upper_left = shader->origin_upper_left;
linked_shader->pixel_center_integer = shader->pixel_center_integer;
if (shader->info.redeclares_gl_fragcoord ||
shader->info.uses_gl_fragcoord) {
linked_shader->info.redeclares_gl_fragcoord =
shader->info.redeclares_gl_fragcoord;
linked_shader->info.uses_gl_fragcoord =
linked_shader->info.uses_gl_fragcoord ||
shader->info.uses_gl_fragcoord;
linked_shader->info.origin_upper_left =
shader->info.origin_upper_left;
linked_shader->info.pixel_center_integer =
shader->info.pixel_center_integer;
}
linked_shader->EarlyFragmentTests |= shader->EarlyFragmentTests;
linked_shader->info.EarlyFragmentTests |=
shader->info.EarlyFragmentTests;
}
}
@@ -1973,10 +1990,10 @@ link_gs_inout_layout_qualifiers(struct gl_shader_program *prog,
struct gl_shader **shader_list,
unsigned num_shaders)
{
linked_shader->Geom.VerticesOut = -1;
linked_shader->Geom.Invocations = 0;
linked_shader->Geom.InputType = PRIM_UNKNOWN;
linked_shader->Geom.OutputType = PRIM_UNKNOWN;
linked_shader->info.Geom.VerticesOut = -1;
linked_shader->info.Geom.Invocations = 0;
linked_shader->info.Geom.InputType = PRIM_UNKNOWN;
linked_shader->info.Geom.OutputType = PRIM_UNKNOWN;
/* No in/out qualifiers defined for anything but GLSL 1.50+
* geometry shaders so far.
@@ -1997,48 +2014,52 @@ link_gs_inout_layout_qualifiers(struct gl_shader_program *prog,
for (unsigned i = 0; i < num_shaders; i++) {
struct gl_shader *shader = shader_list[i];
if (shader->Geom.InputType != PRIM_UNKNOWN) {
if (linked_shader->Geom.InputType != PRIM_UNKNOWN &&
linked_shader->Geom.InputType != shader->Geom.InputType) {
if (shader->info.Geom.InputType != PRIM_UNKNOWN) {
if (linked_shader->info.Geom.InputType != PRIM_UNKNOWN &&
linked_shader->info.Geom.InputType !=
shader->info.Geom.InputType) {
linker_error(prog, "geometry shader defined with conflicting "
"input types\n");
return;
}
linked_shader->Geom.InputType = shader->Geom.InputType;
linked_shader->info.Geom.InputType = shader->info.Geom.InputType;
}
if (shader->Geom.OutputType != PRIM_UNKNOWN) {
if (linked_shader->Geom.OutputType != PRIM_UNKNOWN &&
linked_shader->Geom.OutputType != shader->Geom.OutputType) {
if (shader->info.Geom.OutputType != PRIM_UNKNOWN) {
if (linked_shader->info.Geom.OutputType != PRIM_UNKNOWN &&
linked_shader->info.Geom.OutputType !=
shader->info.Geom.OutputType) {
linker_error(prog, "geometry shader defined with conflicting "
"output types\n");
return;
}
linked_shader->Geom.OutputType = shader->Geom.OutputType;
linked_shader->info.Geom.OutputType = shader->info.Geom.OutputType;
}
if (shader->Geom.VerticesOut != -1) {
if (linked_shader->Geom.VerticesOut != -1 &&
linked_shader->Geom.VerticesOut != shader->Geom.VerticesOut) {
if (shader->info.Geom.VerticesOut != -1) {
if (linked_shader->info.Geom.VerticesOut != -1 &&
linked_shader->info.Geom.VerticesOut !=
shader->info.Geom.VerticesOut) {
linker_error(prog, "geometry shader defined with conflicting "
"output vertex count (%d and %d)\n",
linked_shader->Geom.VerticesOut,
shader->Geom.VerticesOut);
linked_shader->info.Geom.VerticesOut,
shader->info.Geom.VerticesOut);
return;
}
linked_shader->Geom.VerticesOut = shader->Geom.VerticesOut;
linked_shader->info.Geom.VerticesOut = shader->info.Geom.VerticesOut;
}
if (shader->Geom.Invocations != 0) {
if (linked_shader->Geom.Invocations != 0 &&
linked_shader->Geom.Invocations != shader->Geom.Invocations) {
if (shader->info.Geom.Invocations != 0) {
if (linked_shader->info.Geom.Invocations != 0 &&
linked_shader->info.Geom.Invocations !=
shader->info.Geom.Invocations) {
linker_error(prog, "geometry shader defined with conflicting "
"invocation count (%d and %d)\n",
linked_shader->Geom.Invocations,
shader->Geom.Invocations);
linked_shader->info.Geom.Invocations,
shader->info.Geom.Invocations);
return;
}
linked_shader->Geom.Invocations = shader->Geom.Invocations;
linked_shader->info.Geom.Invocations = shader->info.Geom.Invocations;
}
}
@@ -2046,26 +2067,26 @@ link_gs_inout_layout_qualifiers(struct gl_shader_program *prog,
* since we already know we're in the right type of shader program
* for doing it.
*/
if (linked_shader->Geom.InputType == PRIM_UNKNOWN) {
if (linked_shader->info.Geom.InputType == PRIM_UNKNOWN) {
linker_error(prog,
"geometry shader didn't declare primitive input type\n");
return;
}
if (linked_shader->Geom.OutputType == PRIM_UNKNOWN) {
if (linked_shader->info.Geom.OutputType == PRIM_UNKNOWN) {
linker_error(prog,
"geometry shader didn't declare primitive output type\n");
return;
}
if (linked_shader->Geom.VerticesOut == -1) {
if (linked_shader->info.Geom.VerticesOut == -1) {
linker_error(prog,
"geometry shader didn't declare max_vertices\n");
return;
}
if (linked_shader->Geom.Invocations == 0)
linked_shader->Geom.Invocations = 1;
if (linked_shader->info.Geom.Invocations == 0)
linked_shader->info.Geom.Invocations = 1;
}
@@ -2081,7 +2102,7 @@ link_cs_input_layout_qualifiers(struct gl_shader_program *prog,
unsigned num_shaders)
{
for (int i = 0; i < 3; i++)
linked_shader->Comp.LocalSize[i] = 0;
linked_shader->info.Comp.LocalSize[i] = 0;
/* This function is called for all shader stages, but it only has an effect
* for compute shaders.
@@ -2102,19 +2123,21 @@ link_cs_input_layout_qualifiers(struct gl_shader_program *prog,
for (unsigned sh = 0; sh < num_shaders; sh++) {
struct gl_shader *shader = shader_list[sh];
if (shader->Comp.LocalSize[0] != 0) {
if (linked_shader->Comp.LocalSize[0] != 0) {
if (shader->info.Comp.LocalSize[0] != 0) {
if (linked_shader->info.Comp.LocalSize[0] != 0) {
for (int i = 0; i < 3; i++) {
if (linked_shader->Comp.LocalSize[i] !=
shader->Comp.LocalSize[i]) {
if (linked_shader->info.Comp.LocalSize[i] !=
shader->info.Comp.LocalSize[i]) {
linker_error(prog, "compute shader defined with conflicting "
"local sizes\n");
return;
}
}
}
for (int i = 0; i < 3; i++)
linked_shader->Comp.LocalSize[i] = shader->Comp.LocalSize[i];
for (int i = 0; i < 3; i++) {
linked_shader->info.Comp.LocalSize[i] =
shader->info.Comp.LocalSize[i];
}
}
}
@@ -2122,12 +2145,12 @@ link_cs_input_layout_qualifiers(struct gl_shader_program *prog,
* since we already know we're in the right type of shader program
* for doing it.
*/
if (linked_shader->Comp.LocalSize[0] == 0) {
if (linked_shader->info.Comp.LocalSize[0] == 0) {
linker_error(prog, "compute shader didn't declare local size\n");
return;
}
for (int i = 0; i < 3; i++)
prog->Comp.LocalSize[i] = linked_shader->Comp.LocalSize[i];
prog->Comp.LocalSize[i] = linked_shader->info.Comp.LocalSize[i];
}
@@ -2266,7 +2289,7 @@ link_intrastage_shaders(void *mem_ctx,
/* Check if any shader needs built-in functions. */
bool need_builtins = false;
for (unsigned i = 0; i < num_shaders; i++) {
if (shader_list[i]->uses_builtin_functions) {
if (shader_list[i]->info.uses_builtin_functions) {
need_builtins = true;
break;
}
@@ -2345,7 +2368,7 @@ link_intrastage_shaders(void *mem_ctx,
/* Set the size of geometry shader input arrays */
if (linked->Stage == MESA_SHADER_GEOMETRY) {
unsigned num_vertices = vertices_per_prim(linked->Geom.InputType);
unsigned num_vertices = vertices_per_prim(linked->info.Geom.InputType);
geom_array_resize_visitor input_resize_visitor(num_vertices, prog);
foreach_in_list(ir_instruction, ir, linked->ir) {
ir->accept(&input_resize_visitor);
@@ -2470,7 +2493,7 @@ resize_tes_inputs(struct gl_context *ctx,
* known until draw time.
*/
const int num_vertices = tcs
? tcs->TessCtrl.VerticesOut
? tcs->info.TessCtrl.VerticesOut
: ctx->Const.MaxPatchVertices;
tess_eval_array_resize_visitor input_resize_visitor(num_vertices, prog);
@@ -4511,7 +4534,7 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
goto done;
}
if (prog->Shaders[i]->ARB_fragment_coord_conventions_enable) {
if (prog->Shaders[i]->info.ARB_fragment_coord_conventions_enable) {
prog->ARB_fragment_coord_conventions_enable = true;
}

2
src/mesa/drivers/dri/i965/brw_tcs.c
View File

@@ -392,7 +392,7 @@ brw_tcs_precompile(struct gl_context *ctx,
/* Guess that the input and output patches have the same dimensionality. */
if (brw->gen < 8) {
key.input_vertices = shader_prog->
_LinkedShaders[MESA_SHADER_TESS_CTRL]->TessCtrl.VerticesOut;
_LinkedShaders[MESA_SHADER_TESS_CTRL]->info.TessCtrl.VerticesOut;
}
key.tes_primitive_mode = brw->tess_eval_program ?

13
src/mesa/main/api_validate.c
View File

@@ -201,7 +201,7 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
if (ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]) {
const GLenum geom_mode =
ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]->
_LinkedShaders[MESA_SHADER_GEOMETRY]->Geom.InputType;
_LinkedShaders[MESA_SHADER_GEOMETRY]->info.Geom.InputType;
struct gl_shader_program *tes =
ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL];
GLenum mode_before_gs = mode;
@@ -209,9 +209,9 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
if (tes) {
struct gl_linked_shader *tes_sh =
tes->_LinkedShaders[MESA_SHADER_TESS_EVAL];
if (tes_sh->TessEval.PointMode)
if (tes_sh->info.TessEval.PointMode)
mode_before_gs = GL_POINTS;
else if (tes_sh->TessEval.PrimitiveMode == GL_ISOLINES)
else if (tes_sh->info.TessEval.PrimitiveMode == GL_ISOLINES)
mode_before_gs = GL_LINES;
else
/* the GL_QUADS mode generates triangles too */
@@ -308,7 +308,8 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
if(ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]) {
switch (ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]->
_LinkedShaders[MESA_SHADER_GEOMETRY]->Geom.OutputType) {
_LinkedShaders[MESA_SHADER_GEOMETRY]->
info.Geom.OutputType) {
case GL_POINTS:
pass = ctx->TransformFeedback.Mode == GL_POINTS;
break;
@@ -327,9 +328,9 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL];
struct gl_linked_shader *tes_sh =
tes->_LinkedShaders[MESA_SHADER_TESS_EVAL];
if (tes_sh->TessEval.PointMode)
if (tes_sh->info.TessEval.PointMode)
pass = ctx->TransformFeedback.Mode == GL_POINTS;
else if (tes_sh->TessEval.PrimitiveMode == GL_ISOLINES)
else if (tes_sh->info.TessEval.PrimitiveMode == GL_ISOLINES)
pass = ctx->TransformFeedback.Mode == GL_LINES;
else
pass = ctx->TransformFeedback.Mode == GL_TRIANGLES;

2
src/mesa/main/ff_fragment_shader.cpp
View File

@@ -1260,7 +1260,7 @@ create_new_program(struct gl_context *ctx, struct state_key *key)
p.shader->CompileStatus = true;
p.shader->Version = state->language_version;
p.shader->uses_builtin_functions = state->uses_builtin_functions;
p.shader->info.uses_builtin_functions = state->uses_builtin_functions;
p.shader_program->Shaders =
(gl_shader **)malloc(sizeof(*p.shader_program->Shaders));
p.shader_program->Shaders[0] = p.shader;

281
src/mesa/main/mtypes.h
View File

@@ -2234,6 +2234,103 @@ struct gl_subroutine_function
const struct glsl_type **types;
};
/**
* Shader information needed by both gl_shader and gl_linked shader.
*/
struct gl_shader_info
{
bool uses_builtin_functions;
bool uses_gl_fragcoord;
bool redeclares_gl_fragcoord;
bool ARB_fragment_coord_conventions_enable;
/**
* Fragment shader state from GLSL 1.50 layout qualifiers.
*/
bool origin_upper_left;
bool pixel_center_integer;
struct {
/** Global xfb_stride out qualifier if any */
GLuint BufferStride[MAX_FEEDBACK_BUFFERS];
} TransformFeedback;
/**
* Tessellation Control shader state from layout qualifiers.
*/
struct {
/**
* 0 - vertices not declared in shader, or
* 1 .. GL_MAX_PATCH_VERTICES
*/
GLint VerticesOut;
} TessCtrl;
/**
* Tessellation Evaluation shader state from layout qualifiers.
*/
struct {
/**
* GL_TRIANGLES, GL_QUADS, GL_ISOLINES or PRIM_UNKNOWN if it's not set
* in this shader.
*/
GLenum PrimitiveMode;
/**
* GL_EQUAL, GL_FRACTIONAL_ODD, GL_FRACTIONAL_EVEN, or 0 if it's not set
* in this shader.
*/
GLenum Spacing;
/**
* GL_CW, GL_CCW, or 0 if it's not set in this shader.
*/
GLenum VertexOrder;
/**
* 1, 0, or -1 if it's not set in this shader.
*/
int PointMode;
} TessEval;
/**
* Geometry shader state from GLSL 1.50 layout qualifiers.
*/
struct {
GLint VerticesOut;
/**
* 0 - Invocations count not declared in shader, or
* 1 .. MAX_GEOMETRY_SHADER_INVOCATIONS
*/
GLint Invocations;
/**
* GL_POINTS, GL_LINES, GL_LINES_ADJACENCY, GL_TRIANGLES, or
* GL_TRIANGLES_ADJACENCY, or PRIM_UNKNOWN if it's not set in this
* shader.
*/
GLenum InputType;
/**
* GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP, or PRIM_UNKNOWN if
* it's not set in this shader.
*/
GLenum OutputType;
} Geom;
/**
* Whether early fragment tests are enabled as defined by
* ARB_shader_image_load_store.
*/
bool EarlyFragmentTests;
/**
* Compute shader state from ARB_compute_shader layout qualifiers.
*/
struct {
/**
* Size specified using local_size_{x,y,z}, or all 0's to indicate that
* it's not set in this shader.
*/
unsigned LocalSize[3];
} Comp;
};
/**
* A linked GLSL shader object.
*/
@@ -2291,80 +2388,6 @@ struct gl_linked_shader
struct exec_list *fragdata_arrays;
struct glsl_symbol_table *symbols;
bool uses_builtin_functions;
bool uses_gl_fragcoord;
bool redeclares_gl_fragcoord;
bool ARB_fragment_coord_conventions_enable;
/**
* Fragment shader state from GLSL 1.50 layout qualifiers.
*/
bool origin_upper_left;
bool pixel_center_integer;
struct {
/** Global xfb_stride out qualifier if any */
GLuint BufferStride[MAX_FEEDBACK_BUFFERS];
} TransformFeedback;
/**
* Tessellation Control shader state from layout qualifiers.
*/
struct {
/**
* 0 - vertices not declared in shader, or
* 1 .. GL_MAX_PATCH_VERTICES
*/
GLint VerticesOut;
} TessCtrl;
/**
* Tessellation Evaluation shader state from layout qualifiers.
*/
struct {
/**
* GL_TRIANGLES, GL_QUADS, GL_ISOLINES or PRIM_UNKNOWN if it's not set
* in this shader.
*/
GLenum PrimitiveMode;
/**
* GL_EQUAL, GL_FRACTIONAL_ODD, GL_FRACTIONAL_EVEN, or 0 if it's not set
* in this shader.
*/
GLenum Spacing;
/**
* GL_CW, GL_CCW, or 0 if it's not set in this shader.
*/
GLenum VertexOrder;
/**
* 1, 0, or -1 if it's not set in this shader.
*/
int PointMode;
} TessEval;
/**
* Geometry shader state from GLSL 1.50 layout qualifiers.
*/
struct {
GLint VerticesOut;
/**
* 0 - Invocations count not declared in shader, or
* 1 .. MAX_GEOMETRY_SHADER_INVOCATIONS
*/
GLint Invocations;
/**
* GL_POINTS, GL_LINES, GL_LINES_ADJACENCY, GL_TRIANGLES, or
* GL_TRIANGLES_ADJACENCY, or PRIM_UNKNOWN if it's not set in this
* shader.
*/
GLenum InputType;
/**
* GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP, or PRIM_UNKNOWN if
* it's not set in this shader.
*/
GLenum OutputType;
} Geom;
/**
* Map from image uniform index to image unit (set by glUniform1i())
*
@@ -2394,23 +2417,6 @@ struct gl_linked_shader
struct gl_active_atomic_buffer **AtomicBuffers;
unsigned NumAtomicBuffers;
/**
* Whether early fragment tests are enabled as defined by
* ARB_shader_image_load_store.
*/
bool EarlyFragmentTests;
/**
* Compute shader state from ARB_compute_shader layout qualifiers.
*/
struct {
/**
* Size specified using local_size_{x,y,z}, or all 0's to indicate that
* it's not set in this shader.
*/
unsigned LocalSize[3];
} Comp;
/**
* Number of types for subroutine uniforms.
*/
@@ -2431,6 +2437,8 @@ struct gl_linked_shader
GLuint NumSubroutineFunctions;
GLuint MaxSubroutineFunctionIndex;
struct gl_subroutine_function *SubroutineFunctions;
struct gl_shader_info info;
};
/**
@@ -2461,96 +2469,7 @@ struct gl_shader
struct exec_list *ir;
struct glsl_symbol_table *symbols;
bool uses_builtin_functions;
bool uses_gl_fragcoord;
bool redeclares_gl_fragcoord;
bool ARB_fragment_coord_conventions_enable;
/**
* Fragment shader state from GLSL 1.50 layout qualifiers.
*/
bool origin_upper_left;
bool pixel_center_integer;
struct {
/** Global xfb_stride out qualifier if any */
GLuint BufferStride[MAX_FEEDBACK_BUFFERS];
} TransformFeedback;
/**
* Tessellation Control shader state from layout qualifiers.
*/
struct {
/**
* 0 - vertices not declared in shader, or
* 1 .. GL_MAX_PATCH_VERTICES
*/
GLint VerticesOut;
} TessCtrl;
/**
* Tessellation Evaluation shader state from layout qualifiers.
*/
struct {
/**
* GL_TRIANGLES, GL_QUADS, GL_ISOLINES or PRIM_UNKNOWN if it's not set
* in this shader.
*/
GLenum PrimitiveMode;
/**
* GL_EQUAL, GL_FRACTIONAL_ODD, GL_FRACTIONAL_EVEN, or 0 if it's not set
* in this shader.
*/
GLenum Spacing;
/**
* GL_CW, GL_CCW, or 0 if it's not set in this shader.
*/
GLenum VertexOrder;
/**
* 1, 0, or -1 if it's not set in this shader.
*/
int PointMode;
} TessEval;
/**
* Geometry shader state from GLSL 1.50 layout qualifiers.
*/
struct {
GLint VerticesOut;
/**
* 0 - Invocations count not declared in shader, or
* 1 .. MAX_GEOMETRY_SHADER_INVOCATIONS
*/
GLint Invocations;
/**
* GL_POINTS, GL_LINES, GL_LINES_ADJACENCY, GL_TRIANGLES, or
* GL_TRIANGLES_ADJACENCY, or PRIM_UNKNOWN if it's not set in this
* shader.
*/
GLenum InputType;
/**
* GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP, or PRIM_UNKNOWN if
* it's not set in this shader.
*/
GLenum OutputType;
} Geom;
/**
* Whether early fragment tests are enabled as defined by
* ARB_shader_image_load_store.
*/
bool EarlyFragmentTests;
/**
* Compute shader state from ARB_compute_shader layout qualifiers.
*/
struct {
/**
* Size specified using local_size_{x,y,z}, or all 0's to indicate that
* it's not set in this shader.
*/
unsigned LocalSize[3];
} Comp;
struct gl_shader_info info;
};

38
src/mesa/main/shaderapi.c
View File

@@ -732,7 +732,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_gs_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->
Geom.VerticesOut;
info.Geom.VerticesOut;
}
return;
case GL_GEOMETRY_SHADER_INVOCATIONS:
@@ -740,7 +740,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_gs_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->
Geom.Invocations;
info.Geom.Invocations;
}
return;
case GL_GEOMETRY_INPUT_TYPE:
@@ -748,7 +748,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_gs_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->
Geom.InputType;
info.Geom.InputType;
}
return;
case GL_GEOMETRY_OUTPUT_TYPE:
@@ -756,7 +756,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_gs_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_GEOMETRY]->
Geom.OutputType;
info.Geom.OutputType;
}
return;
case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: {
@@ -834,7 +834,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_tcs_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_TESS_CTRL]->
TessCtrl.VerticesOut;
info.TessCtrl.VerticesOut;
}
return;
case GL_TESS_GEN_MODE:
@@ -842,7 +842,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_tes_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL]->
TessEval.PrimitiveMode;
info.TessEval.PrimitiveMode;
}
return;
case GL_TESS_GEN_SPACING:
@@ -850,7 +850,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_tes_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL]->
TessEval.Spacing;
info.TessEval.Spacing;
}
return;
case GL_TESS_GEN_VERTEX_ORDER:
@@ -858,7 +858,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_tes_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL]->
TessEval.VertexOrder;
info.TessEval.VertexOrder;
}
return;
case GL_TESS_GEN_POINT_MODE:
@@ -866,7 +866,7 @@ get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
break;
if (check_tes_query(ctx, shProg)) {
*params = shProg->_LinkedShaders[MESA_SHADER_TESS_EVAL]->
TessEval.PointMode;
info.TessEval.PointMode;
}
return;
default:
@@ -2168,8 +2168,8 @@ _mesa_copy_linked_program_data(gl_shader_stage type,
case MESA_SHADER_TESS_CTRL: {
struct gl_tess_ctrl_program *dst_tcp =
(struct gl_tess_ctrl_program *) dst;
dst_tcp->VerticesOut =
src->_LinkedShaders[MESA_SHADER_TESS_CTRL]->TessCtrl.VerticesOut;
dst_tcp->VerticesOut = src->_LinkedShaders[MESA_SHADER_TESS_CTRL]->
info.TessCtrl.VerticesOut;
break;
}
case MESA_SHADER_TESS_EVAL: {
@@ -2178,10 +2178,10 @@ _mesa_copy_linked_program_data(gl_shader_stage type,
struct gl_linked_shader *tes_sh =
src->_LinkedShaders[MESA_SHADER_TESS_EVAL];
dst_tep->PrimitiveMode = tes_sh->TessEval.PrimitiveMode;
dst_tep->Spacing = tes_sh->TessEval.Spacing;
dst_tep->VertexOrder = tes_sh->TessEval.VertexOrder;
dst_tep->PointMode = tes_sh->TessEval.PointMode;
dst_tep->PrimitiveMode = tes_sh->info.TessEval.PrimitiveMode;
dst_tep->Spacing = tes_sh->info.TessEval.Spacing;
dst_tep->VertexOrder = tes_sh->info.TessEval.VertexOrder;
dst_tep->PointMode = tes_sh->info.TessEval.PointMode;
dst->ClipDistanceArraySize = src->TessEval.ClipDistanceArraySize;
dst->CullDistanceArraySize = src->TessEval.CullDistanceArraySize;
break;
@@ -2192,10 +2192,10 @@ _mesa_copy_linked_program_data(gl_shader_stage type,
src->_LinkedShaders[MESA_SHADER_GEOMETRY];
dst_gp->VerticesIn = src->Geom.VerticesIn;
dst_gp->VerticesOut = geom_sh->Geom.VerticesOut;
dst_gp->Invocations = geom_sh->Geom.Invocations;
dst_gp->InputType = geom_sh->Geom.InputType;
dst_gp->OutputType = geom_sh->Geom.OutputType;
dst_gp->VerticesOut = geom_sh->info.Geom.VerticesOut;
dst_gp->Invocations = geom_sh->info.Geom.Invocations;
dst_gp->InputType = geom_sh->info.Geom.InputType;
dst_gp->OutputType = geom_sh->info.Geom.OutputType;
dst->ClipDistanceArraySize = src->Geom.ClipDistanceArraySize;
dst->CullDistanceArraySize = src->Geom.CullDistanceArraySize;
dst_gp->UsesEndPrimitive = src->Geom.UsesEndPrimitive;

6
src/mesa/main/shaderobj.c
View File

@@ -92,9 +92,9 @@ static void
_mesa_init_shader(struct gl_shader *shader)
{
shader->RefCount = 1;
shader->Geom.VerticesOut = -1;
shader->Geom.InputType = GL_TRIANGLES;
shader->Geom.OutputType = GL_TRIANGLE_STRIP;
shader->info.Geom.VerticesOut = -1;
shader->info.Geom.InputType = GL_TRIANGLES;
shader->info.Geom.OutputType = GL_TRIANGLE_STRIP;
}
/**

2
src/mesa/state_tracker/st_glsl_to_tgsi.cpp
View File

@@ -6133,7 +6133,7 @@ st_translate_program(
}
if (procType == PIPE_SHADER_FRAGMENT) {
if (program->shader->EarlyFragmentTests)
if (program->shader->info.EarlyFragmentTests)
ureg_property(ureg, TGSI_PROPERTY_FS_EARLY_DEPTH_STENCIL, 1);
if (proginfo->InputsRead & VARYING_BIT_POS) {