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
40typedef 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
47static nir_ssa_def *
48get_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: */
71static nir_ssa_def *
72nir_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 */
78static void
79emit_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
147static void
148lower_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))' */
236static void
237lower_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. */
260static void
261lower_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
278static void
279lower_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
298static void
299lower_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
335static void
336lower_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
347bool
348nir_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