#include "main/core.h" /* for struct gl_context */
#include "main/context.h"
#include "main/debug_output.h"
+#include "main/formats.h"
#include "main/shaderobj.h"
#include "util/u_atomic.h" /* for p_atomic_cmpxchg */
#include "util/ralloc.h"
this->default_uniform_qualifier = new(this) ast_type_qualifier();
this->default_uniform_qualifier->flags.q.shared = 1;
this->default_uniform_qualifier->flags.q.column_major = 1;
- this->default_uniform_qualifier->is_default_qualifier = true;
this->default_shader_storage_qualifier = new(this) ast_type_qualifier();
this->default_shader_storage_qualifier->flags.q.shared = 1;
this->default_shader_storage_qualifier->flags.q.column_major = 1;
- this->default_shader_storage_qualifier->is_default_qualifier = true;
this->fs_uses_gl_fragcoord = false;
this->fs_redeclares_gl_fragcoord = false;
this->in_qualifier = new(this) ast_type_qualifier();
this->out_qualifier = new(this) ast_type_qualifier();
this->fs_early_fragment_tests = false;
+ this->fs_inner_coverage = false;
+ this->fs_post_depth_coverage = false;
this->fs_blend_support = 0;
memset(this->atomic_counter_offsets, 0,
sizeof(this->atomic_counter_offsets));
EXT(ARB_fragment_layer_viewport),
EXT(ARB_gpu_shader5),
EXT(ARB_gpu_shader_fp64),
+ EXT(ARB_post_depth_coverage),
EXT(ARB_sample_shading),
EXT(ARB_separate_shader_objects),
EXT(ARB_shader_atomic_counter_ops),
EXT(EXT_texture_array),
EXT_AEP(EXT_texture_buffer),
EXT_AEP(EXT_texture_cube_map_array),
+ EXT(INTEL_conservative_rasterization),
EXT(MESA_shader_integer_functions),
+ EXT(NV_image_formats),
};
#undef EXT
*/
uint64_t block_interface_qualifier = q.flags.i;
- block->layout.flags.i |= block_interface_qualifier;
+ block->default_layout.flags.i |= block_interface_qualifier;
if (state->stage == MESA_SHADER_GEOMETRY &&
state->has_explicit_attrib_stream() &&
- block->layout.flags.q.out) {
+ block->default_layout.flags.q.out) {
/* Assign global layout's stream value. */
- block->layout.flags.q.stream = 1;
- block->layout.flags.q.explicit_stream = 0;
- block->layout.stream = state->out_qualifier->stream;
+ block->default_layout.flags.q.stream = 1;
+ block->default_layout.flags.q.explicit_stream = 0;
+ block->default_layout.stream = state->out_qualifier->stream;
}
- if (state->has_enhanced_layouts() && block->layout.flags.q.out) {
+ if (state->has_enhanced_layouts() && block->default_layout.flags.q.out) {
/* Assign global layout's xfb_buffer value. */
- block->layout.flags.q.xfb_buffer = 1;
- block->layout.flags.q.explicit_xfb_buffer = 0;
- block->layout.xfb_buffer = state->out_qualifier->xfb_buffer;
+ block->default_layout.flags.q.xfb_buffer = 1;
+ block->default_layout.flags.q.explicit_xfb_buffer = 0;
+ block->default_layout.xfb_buffer = state->out_qualifier->xfb_buffer;
}
foreach_list_typed (ast_declarator_list, member, link, &block->declarations) {
assert(!state->fs_pixel_center_integer);
assert(!state->fs_origin_upper_left);
assert(!state->fs_early_fragment_tests);
+ assert(!state->fs_inner_coverage);
+ assert(!state->fs_post_depth_coverage);
}
for (unsigned i = 0; i < MAX_FEEDBACK_BUFFERS; i++) {
if (state->in_qualifier->flags.q.prim_type)
shader->info.TessEval.PrimitiveMode = state->in_qualifier->prim_type;
- shader->info.TessEval.Spacing = 0;
+ shader->info.TessEval.Spacing = TESS_SPACING_UNSPECIFIED;
if (state->in_qualifier->flags.q.vertex_spacing)
shader->info.TessEval.Spacing = state->in_qualifier->vertex_spacing;
unsigned qual_max_vertices;
if (state->out_qualifier->max_vertices->
process_qualifier_constant(state, "max_vertices",
- &qual_max_vertices, true, true)) {
+ &qual_max_vertices, true)) {
if (qual_max_vertices > state->Const.MaxGeometryOutputVertices) {
YYLTYPE loc = state->out_qualifier->max_vertices->get_location();
shader->info.origin_upper_left = state->fs_origin_upper_left;
shader->info.ARB_fragment_coord_conventions_enable =
state->ARB_fragment_coord_conventions_enable;
- shader->info.EarlyFragmentTests = state->fs_early_fragment_tests;
- shader->info.BlendSupport = state->fs_blend_support;
+ shader->EarlyFragmentTests = state->fs_early_fragment_tests;
+ shader->info.InnerCoverage = state->fs_inner_coverage;
+ shader->info.PostDepthCoverage = state->fs_post_depth_coverage;
+ shader->BlendSupport = state->fs_blend_support;
break;
default:
assign_subroutine_indexes(shader, state);
lower_subroutine(shader->ir, state);
+
/* Do some optimization at compile time to reduce shader IR size
* and reduce later work if the same shader is linked multiple times
*/
- while (do_common_optimization(shader->ir, false, false, options,
- ctx->Const.NativeIntegers))
- ;
+ if (ctx->Const.GLSLOptimizeConservatively) {
+ /* Run it just once. */
+ do_common_optimization(shader->ir, false, false, options,
+ ctx->Const.NativeIntegers);
+ } else {
+ /* Repeat it until it stops making changes. */
+ while (do_common_optimization(shader->ir, false, false, options,
+ ctx->Const.NativeIntegers))
+ ;
+ }
validate_ir_tree(shader->ir);
shader->InfoLog = state->info_log;
shader->Version = state->language_version;
shader->IsES = state->es_shader;
- shader->info.uses_builtin_functions = state->uses_builtin_functions;
/* Retain any live IR, but trash the rest. */
reparent_ir(shader->ir, shader->ir);
OPT(do_minmax_prune, ir);
OPT(do_rebalance_tree, ir);
OPT(do_algebraic, ir, native_integers, options);
- OPT(do_lower_jumps, ir);
+ OPT(do_lower_jumps, ir, true, true, options->EmitNoMainReturn,
+ options->EmitNoCont, options->EmitNoLoops);
OPT(do_vec_index_to_swizzle, ir);
OPT(lower_vector_insert, ir, false);
OPT(do_swizzle_swizzle, ir);
OPT(optimize_split_arrays, ir, linked);
OPT(optimize_redundant_jumps, ir);
- loop_state *ls = analyze_loop_variables(ir);
- if (ls->loop_found) {
- OPT(set_loop_controls, ir, ls);
- OPT(unroll_loops, ir, ls, options);
+ if (options->MaxUnrollIterations) {
+ loop_state *ls = analyze_loop_variables(ir);
+ if (ls->loop_found) {
+ OPT(set_loop_controls, ir, ls);
+ OPT(unroll_loops, ir, ls, options);
+ }
+ delete ls;
}
- delete ls;
#undef OPT
projects / mesa.git / blobdiff