/* Generates the lowering code for user-clip-planes, generating CLIPDIST
* from UCP[n] + CLIPVERTEX or POSITION. Additionally, an optional pass
- * for fragment shaders to insert conditional kill's based on the inter-
+ * for fragment shaders to insert conditional kills based on the inter-
* polated CLIPDIST
*
* NOTE: should be run after nir_lower_outputs_to_temporaries() (or at
static nir_variable *
create_clipdist_var(nir_shader *shader, unsigned drvloc,
- bool output, gl_varying_slot slot)
+ bool output, gl_varying_slot slot, unsigned array_size)
{
nir_variable *var = rzalloc(shader, nir_variable);
var->data.driver_location = drvloc;
- var->type = glsl_vec4_type();
var->data.mode = output ? nir_var_shader_out : nir_var_shader_in;
var->name = ralloc_asprintf(var, "clipdist_%d", drvloc);
var->data.index = 0;
var->data.location = slot;
+ if (array_size > 0) {
+ var->type = glsl_array_type(glsl_float_type(), array_size,
+ sizeof(float));
+ var->data.compact = 1;
+ } else
+ var->type = glsl_vec4_type();
+
if (output) {
exec_list_push_tail(&shader->outputs, &var->node);
shader->num_outputs++; /* TODO use type_size() */
return var;
}
+static void
+create_clipdist_vars(nir_shader *shader, nir_variable **io_vars,
+ unsigned ucp_enables, int *drvloc, bool output,
+ bool use_clipdist_array)
+{
+ if (use_clipdist_array) {
+ io_vars[0] =
+ create_clipdist_var(shader, ++(*drvloc), true,
+ VARYING_SLOT_CLIP_DIST0,
+ util_last_bit(ucp_enables));
+ } else {
+ if (ucp_enables & 0x0f)
+ io_vars[0] =
+ create_clipdist_var(shader, ++(*drvloc), output,
+ VARYING_SLOT_CLIP_DIST0, 0);
+ if (ucp_enables & 0xf0)
+ io_vars[1] =
+ create_clipdist_var(shader, ++(*drvloc), output,
+ VARYING_SLOT_CLIP_DIST1, 0);
+ }
+}
+
static void
store_clipdist_output(nir_builder *b, nir_variable *out, nir_ssa_def **val)
{
if ((intr->intrinsic == nir_intrinsic_store_output) &&
nir_intrinsic_base(intr) == drvloc) {
assert(intr->src[0].is_ssa);
- assert(nir_src_as_const_value(intr->src[1]));
+ assert(nir_src_is_const(intr->src[1]));
return intr->src[0].ssa;
}
}
return def;
}
-/*
- * VS lowering
- */
+static bool
+find_clipvertex_and_position_outputs(nir_shader *shader,
+ nir_variable **clipvertex,
+ nir_variable **position)
+{
+ nir_foreach_variable(var, &shader->outputs) {
+ switch (var->data.location) {
+ case VARYING_SLOT_POS:
+ *position = var;
+ break;
+ case VARYING_SLOT_CLIP_VERTEX:
+ *clipvertex = var;
+ break;
+ case VARYING_SLOT_CLIP_DIST0:
+ case VARYING_SLOT_CLIP_DIST1:
+ /* if shader is already writing CLIPDIST, then
+ * there should be no user-clip-planes to deal
+ * with.
+ *
+ * We assume nir_remove_dead_variables has removed the clipdist
+ * variables if they're not written.
+ */
+ return false;
+ }
+ }
+
+ return *clipvertex || *position;
+}
+
+static nir_ssa_def *
+get_ucp(nir_builder *b, int plane,
+ const gl_state_index16 clipplane_state_tokens[][STATE_LENGTH])
+{
+ if (clipplane_state_tokens) {
+ char tmp[100];
+ snprintf(tmp, ARRAY_SIZE(tmp), "gl_ClipPlane%dMESA", plane);
+ nir_variable *var = nir_variable_create(b->shader,
+ nir_var_uniform,
+ glsl_vec4_type(),
+ tmp);
+
+ var->num_state_slots = 1;
+ var->state_slots = ralloc_array(var, nir_state_slot, 1);
+ memcpy(var->state_slots[0].tokens,
+ clipplane_state_tokens[plane],
+ sizeof(var->state_slots[0].tokens));
+ return nir_load_var(b, var);
+ } else
+ return nir_load_user_clip_plane(b, plane);
+}
+
static void
-lower_clip_vs(nir_function_impl *impl, unsigned ucp_enables,
- nir_ssa_def *cv, nir_variable **out)
+lower_clip_outputs(nir_builder *b, nir_variable *position,
+ nir_variable *clipvertex, nir_variable **out,
+ unsigned ucp_enables, bool use_vars,
+ bool use_clipdist_array,
+ const gl_state_index16 clipplane_state_tokens[][STATE_LENGTH])
{
nir_ssa_def *clipdist[MAX_CLIP_PLANES];
- nir_builder b;
+ nir_ssa_def *cv;
- nir_builder_init(&b, impl);
+ if (use_vars) {
+ cv = nir_load_var(b, clipvertex ? clipvertex : position);
- /* NIR should ensure that, even in case of loops/if-else, there
- * should be only a single predecessor block to end_block, which
- * makes the perfect place to insert the clipdist calculations.
- *
- * NOTE: in case of early return's, these would have to be lowered
- * to jumps to end_block predecessor in a previous pass. Not sure
- * if there is a good way to sanity check this, but for now the
- * users of this pass don't support sub-routines.
- */
- assert(impl->end_block->predecessors->entries == 1);
- b.cursor = nir_after_cf_list(&impl->body);
+ if (clipvertex) {
+ exec_node_remove(&clipvertex->node);
+ clipvertex->data.mode = nir_var_shader_temp;
+ exec_list_push_tail(&b->shader->globals, &clipvertex->node);
+ nir_fixup_deref_modes(b->shader);
+ }
+ } else {
+ if (clipvertex)
+ cv = find_output(b->shader, clipvertex->data.driver_location);
+ else {
+ assert(position);
+ cv = find_output(b->shader, position->data.driver_location);
+ }
+ }
for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) {
if (ucp_enables & (1 << plane)) {
- nir_ssa_def *ucp =
- nir_load_system_value(&b, nir_intrinsic_load_user_clip_plane, plane);
+ nir_ssa_def *ucp = get_ucp(b, plane, clipplane_state_tokens);
/* calculate clipdist[plane] - dot(ucp, cv): */
- clipdist[plane] = nir_fdot4(&b, ucp, cv);
- }
- else {
+ clipdist[plane] = nir_fdot4(b, ucp, cv);
+ } else {
/* 0.0 == don't-clip == disabled: */
- clipdist[plane] = nir_imm_float(&b, 0.0);
+ clipdist[plane] = nir_imm_float(b, 0.0);
+ }
+ if (use_clipdist_array && plane < util_last_bit(ucp_enables)) {
+ assert(use_vars);
+ nir_deref_instr *deref;
+ deref = nir_build_deref_array_imm(b,
+ nir_build_deref_var(b, out[0]),
+ plane);
+ nir_store_deref(b, deref, clipdist[plane], 1);
}
}
- if (ucp_enables & 0x0f)
- store_clipdist_output(&b, out[0], &clipdist[0]);
- if (ucp_enables & 0xf0)
- store_clipdist_output(&b, out[1], &clipdist[4]);
-
- nir_metadata_preserve(impl, nir_metadata_dominance);
+ if (!use_clipdist_array) {
+ if (use_vars) {
+ if (ucp_enables & 0x0f)
+ nir_store_var(b, out[0], nir_vec(b, clipdist, 4), 0xf);
+ if (ucp_enables & 0xf0)
+ nir_store_var(b, out[1], nir_vec(b, &clipdist[4], 4), 0xf);
+ } else {
+ if (ucp_enables & 0x0f)
+ store_clipdist_output(b, out[0], &clipdist[0]);
+ if (ucp_enables & 0xf0)
+ store_clipdist_output(b, out[1], &clipdist[4]);
+ }
+ }
}
-/* ucp_enables is bitmask of enabled ucp's. Actual ucp values are
+/*
+ * VS lowering
+ */
+
+/* ucp_enables is bitmask of enabled ucps. Actual ucp values are
* passed in to shader via user_clip_plane system-values
+ *
+ * If use_vars is true, the pass will use variable loads and stores instead
+ * of working with store_output intrinsics.
+ *
+ * If use_clipdist_array is true, the pass will use compact arrays for the
+ * clipdist output instead of two vec4s.
*/
-void
-nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables)
+bool
+nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables, bool use_vars,
+ bool use_clipdist_array,
+ const gl_state_index16 clipplane_state_tokens[][STATE_LENGTH])
{
- int clipvertex = -1;
- int position = -1;
+ nir_function_impl *impl = nir_shader_get_entrypoint(shader);
+ nir_builder b;
int maxloc = -1;
- nir_ssa_def *cv;
+ nir_variable *position = NULL;
+ nir_variable *clipvertex = NULL;
nir_variable *out[2] = { NULL };
if (!ucp_enables)
- return;
+ return false;
/* find clipvertex/position outputs: */
nir_foreach_variable(var, &shader->outputs) {
* output:
*/
maxloc = MAX2(maxloc, loc);
+ }
- switch (var->data.location) {
- case VARYING_SLOT_POS:
- position = loc;
+ nir_builder_init(&b, impl);
+
+ /* NIR should ensure that, even in case of loops/if-else, there
+ * should be only a single predecessor block to end_block, which
+ * makes the perfect place to insert the clipdist calculations.
+ *
+ * NOTE: in case of early returns, these would have to be lowered
+ * to jumps to end_block predecessor in a previous pass. Not sure
+ * if there is a good way to sanity check this, but for now the
+ * users of this pass don't support sub-routines.
+ */
+ assert(impl->end_block->predecessors->entries == 1);
+ b.cursor = nir_after_cf_list(&impl->body);
+
+ /* find clipvertex/position outputs */
+ if (!find_clipvertex_and_position_outputs(shader, &clipvertex, &position))
+ return false;
+
+ /* insert CLIPDIST outputs */
+ create_clipdist_vars(shader, out, ucp_enables, &maxloc, true,
+ use_clipdist_array);
+
+ lower_clip_outputs(&b, position, clipvertex, out, ucp_enables, use_vars,
+ use_clipdist_array, clipplane_state_tokens);
+
+ nir_metadata_preserve(impl, nir_metadata_dominance);
+
+ return true;
+}
+
+static void
+lower_clip_in_gs_block(nir_builder *b, nir_block *block, nir_variable *position,
+ nir_variable *clipvertex, nir_variable **out,
+ unsigned ucp_enables, bool use_clipdist_array,
+ const gl_state_index16 clipplane_state_tokens[][STATE_LENGTH])
+{
+ nir_foreach_instr_safe(instr, block) {
+ if (instr->type != nir_instr_type_intrinsic)
+ continue;
+
+ nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
+ switch (intrin->intrinsic) {
+ case nir_intrinsic_emit_vertex_with_counter:
+ case nir_intrinsic_emit_vertex:
+ b->cursor = nir_before_instr(instr);
+ lower_clip_outputs(b, position, clipvertex, out, ucp_enables, true,
+ use_clipdist_array, clipplane_state_tokens);
break;
- case VARYING_SLOT_CLIP_VERTEX:
- clipvertex = loc;
+ default:
+ /* not interesting; skip this */
break;
- case VARYING_SLOT_CLIP_DIST0:
- case VARYING_SLOT_CLIP_DIST1:
- /* if shader is already writing CLIPDIST, then
- * there should be no user-clip-planes to deal
- * with.
- */
- return;
}
}
+}
- if (clipvertex != -1)
- cv = find_output(shader, clipvertex);
- else if (position != -1)
- cv = find_output(shader, position);
- else
- return;
+/*
+ * GS lowering
+ */
- /* insert CLIPDIST outputs: */
- if (ucp_enables & 0x0f)
- out[0] =
- create_clipdist_var(shader, ++maxloc, true, VARYING_SLOT_CLIP_DIST0);
- if (ucp_enables & 0xf0)
- out[1] =
- create_clipdist_var(shader, ++maxloc, true, VARYING_SLOT_CLIP_DIST1);
+bool
+nir_lower_clip_gs(nir_shader *shader, unsigned ucp_enables,
+ bool use_clipdist_array,
+ const gl_state_index16 clipplane_state_tokens[][STATE_LENGTH])
+{
+ nir_function_impl *impl = nir_shader_get_entrypoint(shader);
+ nir_builder b;
+ int maxloc = -1;
+ nir_variable *position = NULL;
+ nir_variable *clipvertex = NULL;
+ nir_variable *out[2] = { NULL };
- nir_foreach_function(function, shader) {
- if (!strcmp(function->name, "main"))
- lower_clip_vs(function->impl, ucp_enables, cv, out);
- }
+ if (!ucp_enables)
+ return false;
+
+ /* find clipvertex/position outputs */
+ if (!find_clipvertex_and_position_outputs(shader, &clipvertex, &position))
+ return false;
+
+ /* insert CLIPDIST outputs */
+ create_clipdist_vars(shader, out, ucp_enables, &maxloc, true,
+ use_clipdist_array);
+
+ nir_builder_init(&b, impl);
+
+ nir_foreach_block(block, impl)
+ lower_clip_in_gs_block(&b, block, position, clipvertex, out,
+ ucp_enables, use_clipdist_array,
+ clipplane_state_tokens);
+
+ nir_metadata_preserve(impl, nir_metadata_dominance);
+
+ return true;
}
/*
discard->src[0] = nir_src_for_ssa(cond);
nir_builder_instr_insert(&b, &discard->instr);
- b.shader->info->fs.uses_discard = true;
+ b.shader->info.fs.uses_discard = true;
}
}
+
+ nir_metadata_preserve(impl, nir_metadata_dominance);
}
/* insert conditional kill based on interpolated CLIPDIST
*/
-void
-nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables)
+bool
+nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables,
+ bool use_clipdist_array)
{
nir_variable *in[2];
int maxloc = -1;
if (!ucp_enables)
- return;
+ return false;
nir_foreach_variable(var, &shader->inputs) {
int loc = var->data.driver_location;
/* The shader won't normally have CLIPDIST inputs, so we
* must add our own:
*/
- /* insert CLIPDIST outputs: */
- if (ucp_enables & 0x0f)
- in[0] =
- create_clipdist_var(shader, ++maxloc, false,
- VARYING_SLOT_CLIP_DIST0);
- if (ucp_enables & 0xf0)
- in[1] =
- create_clipdist_var(shader, ++maxloc, false,
- VARYING_SLOT_CLIP_DIST1);
+ /* insert CLIPDIST inputs */
+ create_clipdist_vars(shader, in, ucp_enables, &maxloc, false,
+ use_clipdist_array);
nir_foreach_function(function, shader) {
if (!strcmp(function->name, "main"))
lower_clip_fs(function->impl, ucp_enables, in);
}
+
+ return true;
}
projects / mesa.git / blobdiff