2015-09-09 19:57:15 +01:00
|
|
|
/*
|
|
|
|
* Copyright © 2015 Red Hat
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Rob Clark <robclark@freedesktop.org>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "nir.h"
|
|
|
|
#include "nir_builder.h"
|
|
|
|
|
|
|
|
#define MAX_CLIP_PLANES 8
|
|
|
|
|
|
|
|
/* 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-
|
|
|
|
* polated CLIPDIST
|
|
|
|
*
|
|
|
|
* NOTE: should be run after nir_lower_outputs_to_temporaries() (or at
|
|
|
|
* least in scenarios where you can count on each output written once
|
|
|
|
* and only once).
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
static nir_variable *
|
|
|
|
create_clipdist_var(nir_shader *shader, unsigned drvloc,
|
|
|
|
bool output, gl_varying_slot slot)
|
|
|
|
{
|
|
|
|
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 (output) {
|
|
|
|
exec_list_push_tail(&shader->outputs, &var->node);
|
2015-11-04 21:10:52 +00:00
|
|
|
shader->num_outputs++; /* TODO use type_size() */
|
2015-09-09 19:57:15 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
exec_list_push_tail(&shader->inputs, &var->node);
|
2015-11-04 21:10:52 +00:00
|
|
|
shader->num_inputs++; /* TODO use type_size() */
|
2015-09-09 19:57:15 +01:00
|
|
|
}
|
|
|
|
return var;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
store_clipdist_output(nir_builder *b, nir_variable *out, nir_ssa_def **val)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *store;
|
|
|
|
|
|
|
|
store = nir_intrinsic_instr_create(b->shader, nir_intrinsic_store_output);
|
|
|
|
store->num_components = 4;
|
2016-01-21 19:12:58 +00:00
|
|
|
nir_intrinsic_set_base(store, out->data.driver_location);
|
|
|
|
nir_intrinsic_set_write_mask(store, 0xf);
|
2015-09-09 19:57:15 +01:00
|
|
|
store->src[0].ssa = nir_vec4(b, val[0], val[1], val[2], val[3]);
|
|
|
|
store->src[0].is_ssa = true;
|
2015-11-25 22:14:05 +00:00
|
|
|
store->src[1] = nir_src_for_ssa(nir_imm_int(b, 0));
|
2015-09-09 19:57:15 +01:00
|
|
|
nir_builder_instr_insert(b, &store->instr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
load_clipdist_input(nir_builder *b, nir_variable *in, nir_ssa_def **val)
|
|
|
|
{
|
|
|
|
nir_intrinsic_instr *load;
|
|
|
|
|
|
|
|
load = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_input);
|
|
|
|
load->num_components = 4;
|
2016-01-21 19:12:58 +00:00
|
|
|
nir_intrinsic_set_base(load, in->data.driver_location);
|
2015-11-25 22:14:05 +00:00
|
|
|
load->src[0] = nir_src_for_ssa(nir_imm_int(b, 0));
|
2015-11-17 12:57:54 +00:00
|
|
|
nir_ssa_dest_init(&load->instr, &load->dest, 4, 32, NULL);
|
2015-09-09 19:57:15 +01:00
|
|
|
nir_builder_instr_insert(b, &load->instr);
|
|
|
|
|
|
|
|
val[0] = nir_channel(b, &load->dest.ssa, 0);
|
|
|
|
val[1] = nir_channel(b, &load->dest.ssa, 1);
|
|
|
|
val[2] = nir_channel(b, &load->dest.ssa, 2);
|
|
|
|
val[3] = nir_channel(b, &load->dest.ssa, 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct find_output_state
|
|
|
|
{
|
|
|
|
unsigned drvloc;
|
|
|
|
nir_ssa_def *def;
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool
|
|
|
|
find_output_in_block(nir_block *block, void *void_state)
|
|
|
|
{
|
|
|
|
struct find_output_state *state = void_state;
|
|
|
|
nir_foreach_instr(block, instr) {
|
|
|
|
|
|
|
|
if (instr->type == nir_instr_type_intrinsic) {
|
|
|
|
nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
|
|
|
|
if ((intr->intrinsic == nir_intrinsic_store_output) &&
|
2016-01-21 19:12:58 +00:00
|
|
|
nir_intrinsic_base(intr) == state->drvloc) {
|
2015-09-09 19:57:15 +01:00
|
|
|
assert(state->def == NULL);
|
|
|
|
assert(intr->src[0].is_ssa);
|
2015-11-25 22:14:05 +00:00
|
|
|
assert(nir_src_as_const_value(intr->src[1]));
|
2015-09-09 19:57:15 +01:00
|
|
|
state->def = intr->src[0].ssa;
|
|
|
|
|
|
|
|
#if !defined(DEBUG)
|
|
|
|
/* for debug builds, scan entire shader to assert
|
|
|
|
* if output is written multiple times. For release
|
|
|
|
* builds just assume all is well and bail when we
|
|
|
|
* find first:
|
|
|
|
*/
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: maybe this would be a useful helper?
|
|
|
|
* NOTE: assumes each output is written exactly once (and unconditionally)
|
|
|
|
* so if needed nir_lower_outputs_to_temporaries()
|
|
|
|
*/
|
|
|
|
static nir_ssa_def *
|
|
|
|
find_output(nir_shader *shader, unsigned drvloc)
|
|
|
|
{
|
|
|
|
struct find_output_state state = {
|
|
|
|
.drvloc = drvloc,
|
|
|
|
};
|
|
|
|
|
2015-12-26 18:00:47 +00:00
|
|
|
nir_foreach_function(shader, function) {
|
|
|
|
if (function->impl) {
|
2016-04-13 21:25:34 +01:00
|
|
|
nir_foreach_block_reverse_call(function->impl,
|
2015-09-09 19:57:15 +01:00
|
|
|
find_output_in_block, &state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return state.def;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* VS lowering
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
lower_clip_vs(nir_function_impl *impl, unsigned ucp_enables,
|
|
|
|
nir_ssa_def *cv, nir_variable **out)
|
|
|
|
{
|
|
|
|
nir_ssa_def *clipdist[MAX_CLIP_PLANES];
|
|
|
|
nir_builder b;
|
|
|
|
|
|
|
|
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 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);
|
|
|
|
|
|
|
|
for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) {
|
|
|
|
if (ucp_enables & (1 << plane)) {
|
2015-12-15 02:46:16 +00:00
|
|
|
nir_ssa_def *ucp =
|
|
|
|
nir_load_system_value(&b, nir_intrinsic_load_user_clip_plane, plane);
|
2015-09-09 19:57:15 +01:00
|
|
|
|
|
|
|
/* calculate clipdist[plane] - dot(ucp, cv): */
|
2015-12-15 02:46:16 +00:00
|
|
|
clipdist[plane] = nir_fdot4(&b, ucp, cv);
|
2015-09-09 19:57:15 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* 0.0 == don't-clip == disabled: */
|
|
|
|
clipdist[plane] = nir_imm_float(&b, 0.0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ucp_enables is bitmask of enabled ucp's. Actual ucp values are
|
|
|
|
* passed in to shader via user_clip_plane system-values
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nir_lower_clip_vs(nir_shader *shader, unsigned ucp_enables)
|
|
|
|
{
|
|
|
|
int clipvertex = -1;
|
|
|
|
int position = -1;
|
|
|
|
int maxloc = -1;
|
|
|
|
nir_ssa_def *cv;
|
2015-12-11 00:07:14 +00:00
|
|
|
nir_variable *out[2] = { NULL };
|
2015-09-09 19:57:15 +01:00
|
|
|
|
|
|
|
if (!ucp_enables)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* find clipvertex/position outputs: */
|
2015-10-03 02:15:06 +01:00
|
|
|
nir_foreach_variable(var, &shader->outputs) {
|
2015-09-09 19:57:15 +01:00
|
|
|
int loc = var->data.driver_location;
|
|
|
|
|
|
|
|
/* keep track of last used driver-location.. we'll be
|
|
|
|
* appending CLIP_DIST0/CLIP_DIST1 after last existing
|
|
|
|
* output:
|
|
|
|
*/
|
|
|
|
maxloc = MAX2(maxloc, loc);
|
|
|
|
|
|
|
|
switch (var->data.location) {
|
|
|
|
case VARYING_SLOT_POS:
|
|
|
|
position = loc;
|
|
|
|
break;
|
|
|
|
case VARYING_SLOT_CLIP_VERTEX:
|
|
|
|
clipvertex = loc;
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2015-12-26 18:00:47 +00:00
|
|
|
nir_foreach_function(shader, function) {
|
|
|
|
if (!strcmp(function->name, "main"))
|
|
|
|
lower_clip_vs(function->impl, ucp_enables, cv, out);
|
2015-09-09 19:57:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FS lowering
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
lower_clip_fs(nir_function_impl *impl, unsigned ucp_enables,
|
|
|
|
nir_variable **in)
|
|
|
|
{
|
|
|
|
nir_ssa_def *clipdist[MAX_CLIP_PLANES];
|
|
|
|
nir_builder b;
|
|
|
|
|
|
|
|
nir_builder_init(&b, impl);
|
|
|
|
b.cursor = nir_before_cf_list(&impl->body);
|
|
|
|
|
|
|
|
if (ucp_enables & 0x0f)
|
|
|
|
load_clipdist_input(&b, in[0], &clipdist[0]);
|
|
|
|
if (ucp_enables & 0xf0)
|
|
|
|
load_clipdist_input(&b, in[1], &clipdist[4]);
|
|
|
|
|
|
|
|
for (int plane = 0; plane < MAX_CLIP_PLANES; plane++) {
|
|
|
|
if (ucp_enables & (1 << plane)) {
|
|
|
|
nir_intrinsic_instr *discard;
|
|
|
|
nir_ssa_def *cond;
|
|
|
|
|
|
|
|
cond = nir_flt(&b, clipdist[plane], nir_imm_float(&b, 0.0));
|
|
|
|
|
|
|
|
discard = nir_intrinsic_instr_create(b.shader,
|
|
|
|
nir_intrinsic_discard_if);
|
|
|
|
discard->src[0] = nir_src_for_ssa(cond);
|
|
|
|
nir_builder_instr_insert(&b, &discard->instr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* insert conditional kill based on interpolated CLIPDIST
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
nir_lower_clip_fs(nir_shader *shader, unsigned ucp_enables)
|
|
|
|
{
|
|
|
|
nir_variable *in[2];
|
|
|
|
int maxloc = -1;
|
|
|
|
|
|
|
|
if (!ucp_enables)
|
|
|
|
return;
|
|
|
|
|
2015-10-03 02:15:06 +01:00
|
|
|
nir_foreach_variable(var, &shader->inputs) {
|
2015-09-09 19:57:15 +01:00
|
|
|
int loc = var->data.driver_location;
|
|
|
|
|
|
|
|
/* keep track of last used driver-location.. we'll be
|
|
|
|
* appending CLIP_DIST0/CLIP_DIST1 after last existing
|
|
|
|
* input:
|
|
|
|
*/
|
|
|
|
maxloc = MAX2(maxloc, loc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2015-12-26 18:00:47 +00:00
|
|
|
nir_foreach_function(shader, function) {
|
|
|
|
if (!strcmp(function->name, "main"))
|
|
|
|
lower_clip_fs(function->impl, ucp_enables, in);
|
2015-09-09 19:57:15 +01:00
|
|
|
}
|
|
|
|
}
|