• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2015 Red Hat
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21  * SOFTWARE.
22  */
23 
24 #include "nir.h"
25 #include "nir_builder.h"
26 #include "program/prog_instruction.h"
27 
28 /* Lower gl_FragCoord (and fddy) to account for driver's requested coordinate-
29  * origin and pixel-center vs. shader.  If transformation is required, a
30  * gl_FbWposYTransform uniform is inserted (with the specified state-slots)
31  * and additional instructions are inserted to transform gl_FragCoord (and
32  * fddy src arg).
33  *
34  * This is based on the logic in emit_wpos()/emit_wpos_adjustment() in TGSI
35  * compiler.
36  *
37  * Run before nir_lower_io.
38  */
39 
40 typedef struct {
41    const nir_lower_wpos_ytransform_options *options;
42    nir_shader   *shader;
43    nir_builder   b;
44    nir_variable *transform;
45 } lower_wpos_ytransform_state;
46 
47 static nir_ssa_def *
get_transform(lower_wpos_ytransform_state * state)48 get_transform(lower_wpos_ytransform_state *state)
49 {
50    if (state->transform == NULL) {
51       /* NOTE: name must be prefixed w/ "gl_" to trigger slot based
52        * special handling in uniform setup:
53        */
54       nir_variable *var = nir_variable_create(state->shader,
55                                               nir_var_uniform,
56                                               glsl_vec4_type(),
57                                               "gl_FbWposYTransform");
58 
59       var->num_state_slots = 1;
60       var->state_slots = ralloc_array(var, nir_state_slot, 1);
61       var->state_slots[0].swizzle = SWIZZLE_XYZW;
62       memcpy(var->state_slots[0].tokens, state->options->state_tokens,
63              sizeof(var->state_slots[0].tokens));
64       var->data.how_declared = nir_var_hidden;
65       state->transform = var;
66    }
67    return nir_load_var(&state->b, state->transform);
68 }
69 
70 /* NIR equiv of TGSI CMP instruction: */
71 static nir_ssa_def *
nir_cmp(nir_builder * b,nir_ssa_def * src0,nir_ssa_def * src1,nir_ssa_def * src2)72 nir_cmp(nir_builder *b, nir_ssa_def *src0, nir_ssa_def *src1, nir_ssa_def *src2)
73 {
74    return nir_bcsel(b, nir_flt(b, src0, nir_imm_float(b, 0.0)), src1, src2);
75 }
76 
77 /* see emit_wpos_adjustment() in st_mesa_to_tgsi.c */
78 static void
emit_wpos_adjustment(lower_wpos_ytransform_state * state,nir_intrinsic_instr * intr,bool invert,float adjX,float adjY[2])79 emit_wpos_adjustment(lower_wpos_ytransform_state *state,
80                      nir_intrinsic_instr *intr, bool invert,
81                      float adjX, float adjY[2])
82 {
83    nir_builder *b = &state->b;
84    nir_ssa_def *wpostrans, *wpos_temp, *wpos_temp_y, *wpos_input;
85 
86    assert(intr->dest.is_ssa);
87    wpos_input = &intr->dest.ssa;
88 
89    b->cursor = nir_after_instr(&intr->instr);
90 
91    wpostrans = get_transform(state);
92 
93    /* First, apply the coordinate shift: */
94    if (adjX || adjY[0] || adjY[1]) {
95       if (adjY[0] != adjY[1]) {
96          /* Adjust the y coordinate by adjY[1] or adjY[0] respectively
97           * depending on whether inversion is actually going to be applied
98           * or not, which is determined by testing against the inversion
99           * state variable used below, which will be either +1 or -1.
100           */
101          nir_ssa_def *adj_temp;
102 
103          adj_temp = nir_cmp(b,
104                             nir_channel(b, wpostrans, invert ? 2 : 0),
105                             nir_imm_vec4(b, adjX, adjY[0], 0.0f, 0.0f),
106                             nir_imm_vec4(b, adjX, adjY[1], 0.0f, 0.0f));
107 
108          wpos_temp = nir_fadd(b, wpos_input, adj_temp);
109       } else {
110          wpos_temp = nir_fadd(b,
111                               wpos_input,
112                               nir_imm_vec4(b, adjX, adjY[0], 0.0f, 0.0f));
113       }
114       wpos_input = wpos_temp;
115    } else {
116       /* MOV wpos_temp, input[wpos]
117        */
118       wpos_temp = wpos_input;
119    }
120 
121    /* Now the conditional y flip: STATE_FB_WPOS_Y_TRANSFORM.xy/zw will be
122     * inversion/identity, or the other way around if we're drawing to an FBO.
123     */
124    if (invert) {
125       /* wpos_temp.y = wpos_input * wpostrans.xxxx + wpostrans.yyyy */
126       wpos_temp_y = nir_fadd(b, nir_fmul(b, nir_channel(b, wpos_temp, 1),
127                                             nir_channel(b, wpostrans, 0)),
128                                 nir_channel(b, wpostrans, 1));
129    } else {
130       /* wpos_temp.y = wpos_input * wpostrans.zzzz + wpostrans.wwww */
131       wpos_temp_y = nir_fadd(b, nir_fmul(b, nir_channel(b, wpos_temp, 1),
132                                             nir_channel(b, wpostrans, 2)),
133                                 nir_channel(b, wpostrans, 3));
134    }
135 
136    wpos_temp = nir_vec4(b,
137                         nir_channel(b, wpos_temp, 0),
138                         wpos_temp_y,
139                         nir_channel(b, wpos_temp, 2),
140                         nir_channel(b, wpos_temp, 3));
141 
142    nir_ssa_def_rewrite_uses_after(&intr->dest.ssa,
143                                   wpos_temp,
144                                   wpos_temp->parent_instr);
145 }
146 
147 static void
lower_fragcoord(lower_wpos_ytransform_state * state,nir_intrinsic_instr * intr)148 lower_fragcoord(lower_wpos_ytransform_state *state, nir_intrinsic_instr *intr)
149 {
150    const nir_lower_wpos_ytransform_options *options = state->options;
151    float adjX = 0.0f;
152    float adjY[2] = { 0.0f, 0.0f };
153    bool invert = false;
154 
155    /* Based on logic in emit_wpos():
156     *
157     * Query the pixel center conventions supported by the pipe driver and set
158     * adjX, adjY to help out if it cannot handle the requested one internally.
159     *
160     * The bias of the y-coordinate depends on whether y-inversion takes place
161     * (adjY[1]) or not (adjY[0]), which is in turn dependent on whether we are
162     * drawing to an FBO (causes additional inversion), and whether the pipe
163     * driver origin and the requested origin differ (the latter condition is
164     * stored in the 'invert' variable).
165     *
166     * For height = 100 (i = integer, h = half-integer, l = lower, u = upper):
167     *
168     * center shift only:
169     * i -> h: +0.5
170     * h -> i: -0.5
171     *
172     * inversion only:
173     * l,i -> u,i: ( 0.0 + 1.0) * -1 + 100 = 99
174     * l,h -> u,h: ( 0.5 + 0.0) * -1 + 100 = 99.5
175     * u,i -> l,i: (99.0 + 1.0) * -1 + 100 = 0
176     * u,h -> l,h: (99.5 + 0.0) * -1 + 100 = 0.5
177     *
178     * inversion and center shift:
179     * l,i -> u,h: ( 0.0 + 0.5) * -1 + 100 = 99.5
180     * l,h -> u,i: ( 0.5 + 0.5) * -1 + 100 = 99
181     * u,i -> l,h: (99.0 + 0.5) * -1 + 100 = 0.5
182     * u,h -> l,i: (99.5 + 0.5) * -1 + 100 = 0
183     */
184 
185    if (state->shader->info.fs.origin_upper_left) {
186       /* Fragment shader wants origin in upper-left */
187       if (options->fs_coord_origin_upper_left) {
188          /* the driver supports upper-left origin */
189       } else if (options->fs_coord_origin_lower_left) {
190          /* the driver supports lower-left origin, need to invert Y */
191          invert = true;
192       } else {
193          unreachable("invalid options");
194       }
195    } else {
196       /* Fragment shader wants origin in lower-left */
197       if (options->fs_coord_origin_lower_left) {
198          /* the driver supports lower-left origin */
199       } else if (options->fs_coord_origin_upper_left) {
200          /* the driver supports upper-left origin, need to invert Y */
201          invert = true;
202       } else {
203          unreachable("invalid options");
204       }
205    }
206 
207    if (state->shader->info.fs.pixel_center_integer) {
208       /* Fragment shader wants pixel center integer */
209       if (options->fs_coord_pixel_center_integer) {
210          /* the driver supports pixel center integer */
211          adjY[1] = 1.0f;
212       } else if (options->fs_coord_pixel_center_half_integer) {
213          /* the driver supports pixel center half integer, need to bias X,Y */
214          adjX = -0.5f;
215          adjY[0] = -0.5f;
216          adjY[1] = 0.5f;
217       } else {
218          unreachable("invalid options");
219       }
220    } else {
221       /* Fragment shader wants pixel center half integer */
222       if (options->fs_coord_pixel_center_half_integer) {
223          /* the driver supports pixel center half integer */
224       } else if (options->fs_coord_pixel_center_integer) {
225          /* the driver supports pixel center integer, need to bias X,Y */
226          adjX = adjY[0] = adjY[1] = 0.5f;
227       } else {
228          unreachable("invalid options");
229       }
230    }
231 
232    emit_wpos_adjustment(state, intr, invert, adjX, adjY);
233 }
234 
235 /* turns 'fddy(p)' into 'fddy(fmul(p, transform.x))' */
236 static void
lower_fddy(lower_wpos_ytransform_state * state,nir_alu_instr * fddy)237 lower_fddy(lower_wpos_ytransform_state *state, nir_alu_instr *fddy)
238 {
239    nir_builder *b = &state->b;
240    nir_ssa_def *p, *pt, *trans;
241 
242    b->cursor = nir_before_instr(&fddy->instr);
243 
244    p = nir_ssa_for_alu_src(b, fddy, 0);
245    trans = nir_channel(b, get_transform(state), 0);
246    if (p->bit_size == 16)
247       trans = nir_f2f16(b, trans);
248 
249    pt = nir_fmul(b, p, trans);
250 
251    nir_instr_rewrite_src(&fddy->instr,
252                          &fddy->src[0].src,
253                          nir_src_for_ssa(pt));
254 
255    for (unsigned i = 0; i < 4; i++)
256       fddy->src[0].swizzle[i] = MIN2(i, pt->num_components - 1);
257 }
258 
259 /* Multiply interp_deref_at_offset's offset by transform.x to flip it. */
260 static void
lower_interp_deref_at_offset(lower_wpos_ytransform_state * state,nir_intrinsic_instr * interp)261 lower_interp_deref_at_offset(lower_wpos_ytransform_state *state,
262                            nir_intrinsic_instr *interp)
263 {
264    nir_builder *b = &state->b;
265    nir_ssa_def *offset;
266    nir_ssa_def *flip_y;
267 
268    b->cursor = nir_before_instr(&interp->instr);
269 
270    offset = nir_ssa_for_src(b, interp->src[1], 2);
271    flip_y = nir_fmul(b, nir_channel(b, offset, 1),
272                         nir_channel(b, get_transform(state), 0));
273    nir_instr_rewrite_src(&interp->instr, &interp->src[1],
274                          nir_src_for_ssa(nir_vec2(b, nir_channel(b, offset, 0),
275                                                      flip_y)));
276 }
277 
278 static void
lower_load_sample_pos(lower_wpos_ytransform_state * state,nir_intrinsic_instr * intr)279 lower_load_sample_pos(lower_wpos_ytransform_state *state,
280                       nir_intrinsic_instr *intr)
281 {
282    nir_builder *b = &state->b;
283    b->cursor = nir_after_instr(&intr->instr);
284 
285    nir_ssa_def *pos = &intr->dest.ssa;
286    nir_ssa_def *scale = nir_channel(b, get_transform(state), 0);
287    nir_ssa_def *neg_scale = nir_channel(b, get_transform(state), 2);
288    /* Either y or 1-y for scale equal to 1 or -1 respectively. */
289    nir_ssa_def *flipped_y =
290                nir_fadd(b, nir_fmax(b, neg_scale, nir_imm_float(b, 0.0)),
291                         nir_fmul(b, nir_channel(b, pos, 1), scale));
292    nir_ssa_def *flipped_pos = nir_vec2(b, nir_channel(b, pos, 0), flipped_y);
293 
294    nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, flipped_pos,
295                                   flipped_pos->parent_instr);
296 }
297 
298 static void
lower_wpos_ytransform_block(lower_wpos_ytransform_state * state,nir_block * block)299 lower_wpos_ytransform_block(lower_wpos_ytransform_state *state, nir_block *block)
300 {
301    nir_foreach_instr_safe(instr, block) {
302       if (instr->type == nir_instr_type_intrinsic) {
303          nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
304          if (intr->intrinsic == nir_intrinsic_load_deref) {
305             nir_deref_instr *deref = nir_src_as_deref(intr->src[0]);
306             nir_variable *var = nir_deref_instr_get_variable(deref);
307 
308             if ((var->data.mode == nir_var_shader_in &&
309                  var->data.location == VARYING_SLOT_POS) ||
310                 (var->data.mode == nir_var_system_value &&
311                  var->data.location == SYSTEM_VALUE_FRAG_COORD)) {
312                /* gl_FragCoord should not have array/struct derefs: */
313                lower_fragcoord(state, intr);
314             } else if (var->data.mode == nir_var_system_value &&
315                        var->data.location == SYSTEM_VALUE_SAMPLE_POS) {
316                lower_load_sample_pos(state, intr);
317             }
318          } else if (intr->intrinsic == nir_intrinsic_load_frag_coord) {
319             lower_fragcoord(state, intr);
320          } else if (intr->intrinsic == nir_intrinsic_load_sample_pos) {
321             lower_load_sample_pos(state, intr);
322          } else if (intr->intrinsic == nir_intrinsic_interp_deref_at_offset) {
323             lower_interp_deref_at_offset(state, intr);
324          }
325       } else if (instr->type == nir_instr_type_alu) {
326          nir_alu_instr *alu = nir_instr_as_alu(instr);
327          if (alu->op == nir_op_fddy ||
328              alu->op == nir_op_fddy_fine ||
329              alu->op == nir_op_fddy_coarse)
330             lower_fddy(state, alu);
331       }
332    }
333 }
334 
335 static void
lower_wpos_ytransform_impl(lower_wpos_ytransform_state * state,nir_function_impl * impl)336 lower_wpos_ytransform_impl(lower_wpos_ytransform_state *state, nir_function_impl *impl)
337 {
338    nir_builder_init(&state->b, impl);
339 
340    nir_foreach_block(block, impl) {
341       lower_wpos_ytransform_block(state, block);
342    }
343    nir_metadata_preserve(impl, nir_metadata_block_index |
344                                nir_metadata_dominance);
345 }
346 
347 bool
nir_lower_wpos_ytransform(nir_shader * shader,const nir_lower_wpos_ytransform_options * options)348 nir_lower_wpos_ytransform(nir_shader *shader,
349                           const nir_lower_wpos_ytransform_options *options)
350 {
351    lower_wpos_ytransform_state state = {
352       .options = options,
353       .shader = shader,
354    };
355 
356    assert(shader->info.stage == MESA_SHADER_FRAGMENT);
357 
358    nir_foreach_function(function, shader) {
359       if (function->impl)
360          lower_wpos_ytransform_impl(&state, function->impl);
361    }
362 
363    return state.transform != NULL;
364 }
365