1 /*
2 * Copyright © 2015 Broadcom
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
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 /*
25 * This lowering pass supports (as configured via nir_lower_tex_options)
26 * various texture related conversions:
27 * + texture projector lowering: converts the coordinate division for
28 * texture projection to be done in ALU instructions instead of
29 * asking the texture operation to do so.
30 * + lowering RECT: converts the un-normalized RECT texture coordinates
31 * to normalized coordinates with txs plus ALU instructions
32 * + saturate s/t/r coords: to emulate certain texture clamp/wrap modes,
33 * inserts instructions to clamp specified coordinates to [0.0, 1.0].
34 * Note that this automatically triggers texture projector lowering if
35 * needed, since clamping must happen after projector lowering.
36 */
37
38 #include "nir.h"
39 #include "nir_builder.h"
40
41 static void
project_src(nir_builder * b,nir_tex_instr * tex)42 project_src(nir_builder *b, nir_tex_instr *tex)
43 {
44 /* Find the projector in the srcs list, if present. */
45 int proj_index = nir_tex_instr_src_index(tex, nir_tex_src_projector);
46 if (proj_index < 0)
47 return;
48
49 b->cursor = nir_before_instr(&tex->instr);
50
51 nir_ssa_def *inv_proj =
52 nir_frcp(b, nir_ssa_for_src(b, tex->src[proj_index].src, 1));
53
54 /* Walk through the sources projecting the arguments. */
55 for (unsigned i = 0; i < tex->num_srcs; i++) {
56 switch (tex->src[i].src_type) {
57 case nir_tex_src_coord:
58 case nir_tex_src_comparator:
59 break;
60 default:
61 continue;
62 }
63 nir_ssa_def *unprojected =
64 nir_ssa_for_src(b, tex->src[i].src, nir_tex_instr_src_size(tex, i));
65 nir_ssa_def *projected = nir_fmul(b, unprojected, inv_proj);
66
67 /* Array indices don't get projected, so make an new vector with the
68 * coordinate's array index untouched.
69 */
70 if (tex->is_array && tex->src[i].src_type == nir_tex_src_coord) {
71 switch (tex->coord_components) {
72 case 4:
73 projected = nir_vec4(b,
74 nir_channel(b, projected, 0),
75 nir_channel(b, projected, 1),
76 nir_channel(b, projected, 2),
77 nir_channel(b, unprojected, 3));
78 break;
79 case 3:
80 projected = nir_vec3(b,
81 nir_channel(b, projected, 0),
82 nir_channel(b, projected, 1),
83 nir_channel(b, unprojected, 2));
84 break;
85 case 2:
86 projected = nir_vec2(b,
87 nir_channel(b, projected, 0),
88 nir_channel(b, unprojected, 1));
89 break;
90 default:
91 unreachable("bad texture coord count for array");
92 break;
93 }
94 }
95
96 nir_instr_rewrite_src(&tex->instr,
97 &tex->src[i].src,
98 nir_src_for_ssa(projected));
99 }
100
101 nir_tex_instr_remove_src(tex, proj_index);
102 }
103
104 static bool
lower_offset(nir_builder * b,nir_tex_instr * tex)105 lower_offset(nir_builder *b, nir_tex_instr *tex)
106 {
107 int offset_index = nir_tex_instr_src_index(tex, nir_tex_src_offset);
108 if (offset_index < 0)
109 return false;
110
111 int coord_index = nir_tex_instr_src_index(tex, nir_tex_src_coord);
112 assert(coord_index >= 0);
113
114 assert(tex->src[offset_index].src.is_ssa);
115 assert(tex->src[coord_index].src.is_ssa);
116 nir_ssa_def *offset = tex->src[offset_index].src.ssa;
117 nir_ssa_def *coord = tex->src[coord_index].src.ssa;
118
119 b->cursor = nir_before_instr(&tex->instr);
120
121 nir_ssa_def *offset_coord;
122 if (nir_tex_instr_src_type(tex, coord_index) == nir_type_float) {
123 assert(tex->sampler_dim == GLSL_SAMPLER_DIM_RECT);
124 offset_coord = nir_fadd(b, coord, nir_i2f(b, offset));
125 } else {
126 offset_coord = nir_iadd(b, coord, offset);
127 }
128
129 if (tex->is_array) {
130 /* The offset is not applied to the array index */
131 if (tex->coord_components == 2) {
132 offset_coord = nir_vec2(b, nir_channel(b, offset_coord, 0),
133 nir_channel(b, coord, 1));
134 } else if (tex->coord_components == 3) {
135 offset_coord = nir_vec3(b, nir_channel(b, offset_coord, 0),
136 nir_channel(b, offset_coord, 1),
137 nir_channel(b, coord, 2));
138 } else {
139 unreachable("Invalid number of components");
140 }
141 }
142
143 nir_instr_rewrite_src(&tex->instr, &tex->src[coord_index].src,
144 nir_src_for_ssa(offset_coord));
145
146 nir_tex_instr_remove_src(tex, offset_index);
147
148 return true;
149 }
150
151
152 static nir_ssa_def *
get_texture_size(nir_builder * b,nir_tex_instr * tex)153 get_texture_size(nir_builder *b, nir_tex_instr *tex)
154 {
155 b->cursor = nir_before_instr(&tex->instr);
156
157 nir_tex_instr *txs;
158
159 txs = nir_tex_instr_create(b->shader, 1);
160 txs->op = nir_texop_txs;
161 txs->sampler_dim = tex->sampler_dim;
162 txs->is_array = tex->is_array;
163 txs->is_shadow = tex->is_shadow;
164 txs->is_new_style_shadow = tex->is_new_style_shadow;
165 txs->texture_index = tex->texture_index;
166 txs->texture = nir_deref_var_clone(tex->texture, txs);
167 txs->sampler_index = tex->sampler_index;
168 txs->sampler = nir_deref_var_clone(tex->sampler, txs);
169 txs->dest_type = nir_type_int;
170
171 /* only single src, the lod: */
172 txs->src[0].src = nir_src_for_ssa(nir_imm_int(b, 0));
173 txs->src[0].src_type = nir_tex_src_lod;
174
175 nir_ssa_dest_init(&txs->instr, &txs->dest, tex->coord_components, 32, NULL);
176 nir_builder_instr_insert(b, &txs->instr);
177
178 return nir_i2f(b, &txs->dest.ssa);
179 }
180
181 static void
lower_rect(nir_builder * b,nir_tex_instr * tex)182 lower_rect(nir_builder *b, nir_tex_instr *tex)
183 {
184 nir_ssa_def *txs = get_texture_size(b, tex);
185 nir_ssa_def *scale = nir_frcp(b, txs);
186
187 /* Walk through the sources normalizing the requested arguments. */
188 for (unsigned i = 0; i < tex->num_srcs; i++) {
189 if (tex->src[i].src_type != nir_tex_src_coord)
190 continue;
191
192 nir_ssa_def *coords =
193 nir_ssa_for_src(b, tex->src[i].src, tex->coord_components);
194 nir_instr_rewrite_src(&tex->instr,
195 &tex->src[i].src,
196 nir_src_for_ssa(nir_fmul(b, coords, scale)));
197 }
198
199 tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
200 }
201
202 static nir_ssa_def *
sample_plane(nir_builder * b,nir_tex_instr * tex,int plane)203 sample_plane(nir_builder *b, nir_tex_instr *tex, int plane)
204 {
205 assert(tex->dest.is_ssa);
206 assert(nir_tex_instr_dest_size(tex) == 4);
207 assert(nir_alu_type_get_base_type(tex->dest_type) == nir_type_float);
208 assert(tex->op == nir_texop_tex);
209 assert(tex->coord_components == 2);
210
211 nir_tex_instr *plane_tex = nir_tex_instr_create(b->shader, 2);
212 nir_src_copy(&plane_tex->src[0].src, &tex->src[0].src, plane_tex);
213 plane_tex->src[0].src_type = nir_tex_src_coord;
214 plane_tex->src[1].src = nir_src_for_ssa(nir_imm_int(b, plane));
215 plane_tex->src[1].src_type = nir_tex_src_plane;
216 plane_tex->op = nir_texop_tex;
217 plane_tex->sampler_dim = GLSL_SAMPLER_DIM_2D;
218 plane_tex->dest_type = nir_type_float;
219 plane_tex->coord_components = 2;
220
221 plane_tex->texture_index = tex->texture_index;
222 plane_tex->texture = nir_deref_var_clone(tex->texture, plane_tex);
223 plane_tex->sampler_index = tex->sampler_index;
224 plane_tex->sampler = nir_deref_var_clone(tex->sampler, plane_tex);
225
226 nir_ssa_dest_init(&plane_tex->instr, &plane_tex->dest, 4, 32, NULL);
227
228 nir_builder_instr_insert(b, &plane_tex->instr);
229
230 return &plane_tex->dest.ssa;
231 }
232
233 static void
convert_yuv_to_rgb(nir_builder * b,nir_tex_instr * tex,nir_ssa_def * y,nir_ssa_def * u,nir_ssa_def * v)234 convert_yuv_to_rgb(nir_builder *b, nir_tex_instr *tex,
235 nir_ssa_def *y, nir_ssa_def *u, nir_ssa_def *v)
236 {
237 nir_const_value m[3] = {
238 { .f32 = { 1.0f, 0.0f, 1.59602678f, 0.0f } },
239 { .f32 = { 1.0f, -0.39176229f, -0.81296764f, 0.0f } },
240 { .f32 = { 1.0f, 2.01723214f, 0.0f, 0.0f } }
241 };
242
243 nir_ssa_def *yuv =
244 nir_vec4(b,
245 nir_fmul(b, nir_imm_float(b, 1.16438356f),
246 nir_fadd(b, y, nir_imm_float(b, -0.0625f))),
247 nir_channel(b, nir_fadd(b, u, nir_imm_float(b, -0.5f)), 0),
248 nir_channel(b, nir_fadd(b, v, nir_imm_float(b, -0.5f)), 0),
249 nir_imm_float(b, 0.0));
250
251 nir_ssa_def *red = nir_fdot4(b, yuv, nir_build_imm(b, 4, 32, m[0]));
252 nir_ssa_def *green = nir_fdot4(b, yuv, nir_build_imm(b, 4, 32, m[1]));
253 nir_ssa_def *blue = nir_fdot4(b, yuv, nir_build_imm(b, 4, 32, m[2]));
254
255 nir_ssa_def *result = nir_vec4(b, red, green, blue, nir_imm_float(b, 1.0f));
256
257 nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(result));
258 }
259
260 static void
lower_y_uv_external(nir_builder * b,nir_tex_instr * tex)261 lower_y_uv_external(nir_builder *b, nir_tex_instr *tex)
262 {
263 b->cursor = nir_after_instr(&tex->instr);
264
265 nir_ssa_def *y = sample_plane(b, tex, 0);
266 nir_ssa_def *uv = sample_plane(b, tex, 1);
267
268 convert_yuv_to_rgb(b, tex,
269 nir_channel(b, y, 0),
270 nir_channel(b, uv, 0),
271 nir_channel(b, uv, 1));
272 }
273
274 static void
lower_y_u_v_external(nir_builder * b,nir_tex_instr * tex)275 lower_y_u_v_external(nir_builder *b, nir_tex_instr *tex)
276 {
277 b->cursor = nir_after_instr(&tex->instr);
278
279 nir_ssa_def *y = sample_plane(b, tex, 0);
280 nir_ssa_def *u = sample_plane(b, tex, 1);
281 nir_ssa_def *v = sample_plane(b, tex, 2);
282
283 convert_yuv_to_rgb(b, tex,
284 nir_channel(b, y, 0),
285 nir_channel(b, u, 0),
286 nir_channel(b, v, 0));
287 }
288
289 static void
lower_yx_xuxv_external(nir_builder * b,nir_tex_instr * tex)290 lower_yx_xuxv_external(nir_builder *b, nir_tex_instr *tex)
291 {
292 b->cursor = nir_after_instr(&tex->instr);
293
294 nir_ssa_def *y = sample_plane(b, tex, 0);
295 nir_ssa_def *xuxv = sample_plane(b, tex, 1);
296
297 convert_yuv_to_rgb(b, tex,
298 nir_channel(b, y, 0),
299 nir_channel(b, xuxv, 1),
300 nir_channel(b, xuxv, 3));
301 }
302
303 /*
304 * Emits a textureLod operation used to replace an existing
305 * textureGrad instruction.
306 */
307 static void
replace_gradient_with_lod(nir_builder * b,nir_ssa_def * lod,nir_tex_instr * tex)308 replace_gradient_with_lod(nir_builder *b, nir_ssa_def *lod, nir_tex_instr *tex)
309 {
310 /* We are going to emit a textureLod() with the same parameters except that
311 * we replace ddx/ddy with lod.
312 */
313 int num_srcs = tex->num_srcs - 1;
314 nir_tex_instr *txl = nir_tex_instr_create(b->shader, num_srcs);
315
316 txl->op = nir_texop_txl;
317 txl->sampler_dim = tex->sampler_dim;
318 txl->texture_index = tex->texture_index;
319 txl->dest_type = tex->dest_type;
320 txl->is_array = tex->is_array;
321 txl->is_shadow = tex->is_shadow;
322 txl->is_new_style_shadow = tex->is_new_style_shadow;
323 txl->sampler_index = tex->sampler_index;
324 txl->texture = nir_deref_var_clone(tex->texture, txl);
325 txl->sampler = nir_deref_var_clone(tex->sampler, txl);
326 txl->coord_components = tex->coord_components;
327
328 nir_ssa_dest_init(&txl->instr, &txl->dest, 4, 32, NULL);
329
330 int src_num = 0;
331 for (int i = 0; i < tex->num_srcs; i++) {
332 if (tex->src[i].src_type == nir_tex_src_ddx ||
333 tex->src[i].src_type == nir_tex_src_ddy)
334 continue;
335 nir_src_copy(&txl->src[src_num].src, &tex->src[i].src, txl);
336 txl->src[src_num].src_type = tex->src[i].src_type;
337 src_num++;
338 }
339
340 txl->src[src_num].src = nir_src_for_ssa(lod);
341 txl->src[src_num].src_type = nir_tex_src_lod;
342 src_num++;
343
344 assert(src_num == num_srcs);
345
346 nir_ssa_dest_init(&txl->instr, &txl->dest,
347 tex->dest.ssa.num_components, 32, NULL);
348 nir_builder_instr_insert(b, &txl->instr);
349
350 nir_ssa_def_rewrite_uses(&tex->dest.ssa, nir_src_for_ssa(&txl->dest.ssa));
351
352 nir_instr_remove(&tex->instr);
353 }
354
355 static void
lower_gradient_cube_map(nir_builder * b,nir_tex_instr * tex)356 lower_gradient_cube_map(nir_builder *b, nir_tex_instr *tex)
357 {
358 assert(tex->sampler_dim == GLSL_SAMPLER_DIM_CUBE);
359 assert(tex->op == nir_texop_txd);
360 assert(tex->dest.is_ssa);
361
362 /* Use textureSize() to get the width and height of LOD 0 */
363 nir_ssa_def *size = get_texture_size(b, tex);
364
365 /* Cubemap texture lookups first generate a texture coordinate normalized
366 * to [-1, 1] on the appropiate face. The appropiate face is determined
367 * by which component has largest magnitude and its sign. The texture
368 * coordinate is the quotient of the remaining texture coordinates against
369 * that absolute value of the component of largest magnitude. This
370 * division requires that the computing of the derivative of the texel
371 * coordinate must use the quotient rule. The high level GLSL code is as
372 * follows:
373 *
374 * Step 1: selection
375 *
376 * vec3 abs_p, Q, dQdx, dQdy;
377 * abs_p = abs(ir->coordinate);
378 * if (abs_p.x >= max(abs_p.y, abs_p.z)) {
379 * Q = ir->coordinate.yzx;
380 * dQdx = ir->lod_info.grad.dPdx.yzx;
381 * dQdy = ir->lod_info.grad.dPdy.yzx;
382 * }
383 * if (abs_p.y >= max(abs_p.x, abs_p.z)) {
384 * Q = ir->coordinate.xzy;
385 * dQdx = ir->lod_info.grad.dPdx.xzy;
386 * dQdy = ir->lod_info.grad.dPdy.xzy;
387 * }
388 * if (abs_p.z >= max(abs_p.x, abs_p.y)) {
389 * Q = ir->coordinate;
390 * dQdx = ir->lod_info.grad.dPdx;
391 * dQdy = ir->lod_info.grad.dPdy;
392 * }
393 *
394 * Step 2: use quotient rule to compute derivative. The normalized to
395 * [-1, 1] texel coordinate is given by Q.xy / (sign(Q.z) * Q.z). We are
396 * only concerned with the magnitudes of the derivatives whose values are
397 * not affected by the sign. We drop the sign from the computation.
398 *
399 * vec2 dx, dy;
400 * float recip;
401 *
402 * recip = 1.0 / Q.z;
403 * dx = recip * ( dQdx.xy - Q.xy * (dQdx.z * recip) );
404 * dy = recip * ( dQdy.xy - Q.xy * (dQdy.z * recip) );
405 *
406 * Step 3: compute LOD. At this point we have the derivatives of the
407 * texture coordinates normalized to [-1,1]. We take the LOD to be
408 * result = log2(max(sqrt(dot(dx, dx)), sqrt(dy, dy)) * 0.5 * L)
409 * = -1.0 + log2(max(sqrt(dot(dx, dx)), sqrt(dy, dy)) * L)
410 * = -1.0 + log2(sqrt(max(dot(dx, dx), dot(dy,dy))) * L)
411 * = -1.0 + log2(sqrt(L * L * max(dot(dx, dx), dot(dy,dy))))
412 * = -1.0 + 0.5 * log2(L * L * max(dot(dx, dx), dot(dy,dy)))
413 * where L is the dimension of the cubemap. The code is:
414 *
415 * float M, result;
416 * M = max(dot(dx, dx), dot(dy, dy));
417 * L = textureSize(sampler, 0).x;
418 * result = -1.0 + 0.5 * log2(L * L * M);
419 */
420
421 /* coordinate */
422 nir_ssa_def *p =
423 tex->src[nir_tex_instr_src_index(tex, nir_tex_src_coord)].src.ssa;
424
425 /* unmodified dPdx, dPdy values */
426 nir_ssa_def *dPdx =
427 tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddx)].src.ssa;
428 nir_ssa_def *dPdy =
429 tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddy)].src.ssa;
430
431 nir_ssa_def *abs_p = nir_fabs(b, p);
432 nir_ssa_def *abs_p_x = nir_channel(b, abs_p, 0);
433 nir_ssa_def *abs_p_y = nir_channel(b, abs_p, 1);
434 nir_ssa_def *abs_p_z = nir_channel(b, abs_p, 2);
435
436 /* 1. compute selector */
437 nir_ssa_def *Q, *dQdx, *dQdy;
438
439 nir_ssa_def *cond_z = nir_fge(b, abs_p_z, nir_fmax(b, abs_p_x, abs_p_y));
440 nir_ssa_def *cond_y = nir_fge(b, abs_p_y, nir_fmax(b, abs_p_x, abs_p_z));
441
442 unsigned yzx[4] = { 1, 2, 0, 0 };
443 unsigned xzy[4] = { 0, 2, 1, 0 };
444
445 Q = nir_bcsel(b, cond_z,
446 p,
447 nir_bcsel(b, cond_y,
448 nir_swizzle(b, p, xzy, 3, false),
449 nir_swizzle(b, p, yzx, 3, false)));
450
451 dQdx = nir_bcsel(b, cond_z,
452 dPdx,
453 nir_bcsel(b, cond_y,
454 nir_swizzle(b, dPdx, xzy, 3, false),
455 nir_swizzle(b, dPdx, yzx, 3, false)));
456
457 dQdy = nir_bcsel(b, cond_z,
458 dPdy,
459 nir_bcsel(b, cond_y,
460 nir_swizzle(b, dPdy, xzy, 3, false),
461 nir_swizzle(b, dPdy, yzx, 3, false)));
462
463 /* 2. quotient rule */
464
465 /* tmp = Q.xy * recip;
466 * dx = recip * ( dQdx.xy - (tmp * dQdx.z) );
467 * dy = recip * ( dQdy.xy - (tmp * dQdy.z) );
468 */
469 nir_ssa_def *rcp_Q_z = nir_frcp(b, nir_channel(b, Q, 2));
470
471 unsigned xy[4] = { 0, 1, 0, 0 };
472 nir_ssa_def *Q_xy = nir_swizzle(b, Q, xy, 2, false);
473 nir_ssa_def *tmp = nir_fmul(b, Q_xy, rcp_Q_z);
474
475 nir_ssa_def *dQdx_xy = nir_swizzle(b, dQdx, xy, 2, false);
476 nir_ssa_def *dQdx_z = nir_channel(b, dQdx, 2);
477 nir_ssa_def *dx =
478 nir_fmul(b, rcp_Q_z, nir_fsub(b, dQdx_xy, nir_fmul(b, tmp, dQdx_z)));
479
480 nir_ssa_def *dQdy_xy = nir_swizzle(b, dQdy, xy, 2, false);
481 nir_ssa_def *dQdy_z = nir_channel(b, dQdy, 2);
482 nir_ssa_def *dy =
483 nir_fmul(b, rcp_Q_z, nir_fsub(b, dQdy_xy, nir_fmul(b, tmp, dQdy_z)));
484
485 /* M = max(dot(dx, dx), dot(dy, dy)); */
486 nir_ssa_def *M = nir_fmax(b, nir_fdot(b, dx, dx), nir_fdot(b, dy, dy));
487
488 /* size has textureSize() of LOD 0 */
489 nir_ssa_def *L = nir_channel(b, size, 0);
490
491 /* lod = -1.0 + 0.5 * log2(L * L * M); */
492 nir_ssa_def *lod =
493 nir_fadd(b,
494 nir_imm_float(b, -1.0f),
495 nir_fmul(b,
496 nir_imm_float(b, 0.5f),
497 nir_flog2(b, nir_fmul(b, L, nir_fmul(b, L, M)))));
498
499 /* 3. Replace the gradient instruction with an equivalent lod instruction */
500 replace_gradient_with_lod(b, lod, tex);
501 }
502
503 static void
lower_gradient_shadow(nir_builder * b,nir_tex_instr * tex)504 lower_gradient_shadow(nir_builder *b, nir_tex_instr *tex)
505 {
506 assert(tex->sampler_dim != GLSL_SAMPLER_DIM_CUBE);
507 assert(tex->is_shadow);
508 assert(tex->op == nir_texop_txd);
509 assert(tex->dest.is_ssa);
510
511 /* Use textureSize() to get the width and height of LOD 0 */
512 unsigned component_mask;
513 switch (tex->sampler_dim) {
514 case GLSL_SAMPLER_DIM_3D:
515 component_mask = 7;
516 break;
517 case GLSL_SAMPLER_DIM_1D:
518 component_mask = 1;
519 break;
520 default:
521 component_mask = 3;
522 break;
523 }
524
525 nir_ssa_def *size =
526 nir_channels(b, get_texture_size(b, tex), component_mask);
527
528 /* Scale the gradients by width and height. Effectively, the incoming
529 * gradients are s'(x,y), t'(x,y), and r'(x,y) from equation 3.19 in the
530 * GL 3.0 spec; we want u'(x,y), which is w_t * s'(x,y).
531 */
532 nir_ssa_def *ddx =
533 tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddx)].src.ssa;
534 nir_ssa_def *ddy =
535 tex->src[nir_tex_instr_src_index(tex, nir_tex_src_ddy)].src.ssa;
536
537 nir_ssa_def *dPdx = nir_fmul(b, ddx, size);
538 nir_ssa_def *dPdy = nir_fmul(b, ddy, size);
539
540 nir_ssa_def *rho;
541 if (dPdx->num_components == 1) {
542 rho = nir_fmax(b, nir_fabs(b, dPdx), nir_fabs(b, dPdy));
543 } else {
544 rho = nir_fmax(b,
545 nir_fsqrt(b, nir_fdot(b, dPdx, dPdx)),
546 nir_fsqrt(b, nir_fdot(b, dPdy, dPdy)));
547 }
548
549 /* lod = log2(rho). We're ignoring GL state biases for now. */
550 nir_ssa_def *lod = nir_flog2(b, rho);
551
552 /* Replace the gradient instruction with an equivalent lod instruction */
553 replace_gradient_with_lod(b, lod, tex);
554 }
555
556 static void
saturate_src(nir_builder * b,nir_tex_instr * tex,unsigned sat_mask)557 saturate_src(nir_builder *b, nir_tex_instr *tex, unsigned sat_mask)
558 {
559 b->cursor = nir_before_instr(&tex->instr);
560
561 /* Walk through the sources saturating the requested arguments. */
562 for (unsigned i = 0; i < tex->num_srcs; i++) {
563 if (tex->src[i].src_type != nir_tex_src_coord)
564 continue;
565
566 nir_ssa_def *src =
567 nir_ssa_for_src(b, tex->src[i].src, tex->coord_components);
568
569 /* split src into components: */
570 nir_ssa_def *comp[4];
571
572 assume(tex->coord_components >= 1);
573
574 for (unsigned j = 0; j < tex->coord_components; j++)
575 comp[j] = nir_channel(b, src, j);
576
577 /* clamp requested components, array index does not get clamped: */
578 unsigned ncomp = tex->coord_components;
579 if (tex->is_array)
580 ncomp--;
581
582 for (unsigned j = 0; j < ncomp; j++) {
583 if ((1 << j) & sat_mask) {
584 if (tex->sampler_dim == GLSL_SAMPLER_DIM_RECT) {
585 /* non-normalized texture coords, so clamp to texture
586 * size rather than [0.0, 1.0]
587 */
588 nir_ssa_def *txs = get_texture_size(b, tex);
589 comp[j] = nir_fmax(b, comp[j], nir_imm_float(b, 0.0));
590 comp[j] = nir_fmin(b, comp[j], nir_channel(b, txs, j));
591 } else {
592 comp[j] = nir_fsat(b, comp[j]);
593 }
594 }
595 }
596
597 /* and move the result back into a single vecN: */
598 src = nir_vec(b, comp, tex->coord_components);
599
600 nir_instr_rewrite_src(&tex->instr,
601 &tex->src[i].src,
602 nir_src_for_ssa(src));
603 }
604 }
605
606 static nir_ssa_def *
get_zero_or_one(nir_builder * b,nir_alu_type type,uint8_t swizzle_val)607 get_zero_or_one(nir_builder *b, nir_alu_type type, uint8_t swizzle_val)
608 {
609 nir_const_value v;
610
611 memset(&v, 0, sizeof(v));
612
613 if (swizzle_val == 4) {
614 v.u32[0] = v.u32[1] = v.u32[2] = v.u32[3] = 0;
615 } else {
616 assert(swizzle_val == 5);
617 if (type == nir_type_float)
618 v.f32[0] = v.f32[1] = v.f32[2] = v.f32[3] = 1.0;
619 else
620 v.u32[0] = v.u32[1] = v.u32[2] = v.u32[3] = 1;
621 }
622
623 return nir_build_imm(b, 4, 32, v);
624 }
625
626 static void
swizzle_result(nir_builder * b,nir_tex_instr * tex,const uint8_t swizzle[4])627 swizzle_result(nir_builder *b, nir_tex_instr *tex, const uint8_t swizzle[4])
628 {
629 assert(tex->dest.is_ssa);
630
631 b->cursor = nir_after_instr(&tex->instr);
632
633 nir_ssa_def *swizzled;
634 if (tex->op == nir_texop_tg4) {
635 if (swizzle[tex->component] < 4) {
636 /* This one's easy */
637 tex->component = swizzle[tex->component];
638 return;
639 } else {
640 swizzled = get_zero_or_one(b, tex->dest_type, swizzle[tex->component]);
641 }
642 } else {
643 assert(nir_tex_instr_dest_size(tex) == 4);
644 if (swizzle[0] < 4 && swizzle[1] < 4 &&
645 swizzle[2] < 4 && swizzle[3] < 4) {
646 unsigned swiz[4] = { swizzle[0], swizzle[1], swizzle[2], swizzle[3] };
647 /* We have no 0's or 1's, just emit a swizzling MOV */
648 swizzled = nir_swizzle(b, &tex->dest.ssa, swiz, 4, false);
649 } else {
650 nir_ssa_def *srcs[4];
651 for (unsigned i = 0; i < 4; i++) {
652 if (swizzle[i] < 4) {
653 srcs[i] = nir_channel(b, &tex->dest.ssa, swizzle[i]);
654 } else {
655 srcs[i] = get_zero_or_one(b, tex->dest_type, swizzle[i]);
656 }
657 }
658 swizzled = nir_vec(b, srcs, 4);
659 }
660 }
661
662 nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(swizzled),
663 swizzled->parent_instr);
664 }
665
666 static void
linearize_srgb_result(nir_builder * b,nir_tex_instr * tex)667 linearize_srgb_result(nir_builder *b, nir_tex_instr *tex)
668 {
669 assert(tex->dest.is_ssa);
670 assert(nir_tex_instr_dest_size(tex) == 4);
671 assert(nir_alu_type_get_base_type(tex->dest_type) == nir_type_float);
672
673 b->cursor = nir_after_instr(&tex->instr);
674
675 static const unsigned swiz[4] = {0, 1, 2, 0};
676 nir_ssa_def *comp = nir_swizzle(b, &tex->dest.ssa, swiz, 3, true);
677
678 /* Formula is:
679 * (comp <= 0.04045) ?
680 * (comp / 12.92) :
681 * pow((comp + 0.055) / 1.055, 2.4)
682 */
683 nir_ssa_def *low = nir_fmul(b, comp, nir_imm_float(b, 1.0 / 12.92));
684 nir_ssa_def *high = nir_fpow(b,
685 nir_fmul(b,
686 nir_fadd(b,
687 comp,
688 nir_imm_float(b, 0.055)),
689 nir_imm_float(b, 1.0 / 1.055)),
690 nir_imm_float(b, 2.4));
691 nir_ssa_def *cond = nir_fge(b, nir_imm_float(b, 0.04045), comp);
692 nir_ssa_def *rgb = nir_bcsel(b, cond, low, high);
693
694 /* alpha is untouched: */
695 nir_ssa_def *result = nir_vec4(b,
696 nir_channel(b, rgb, 0),
697 nir_channel(b, rgb, 1),
698 nir_channel(b, rgb, 2),
699 nir_channel(b, &tex->dest.ssa, 3));
700
701 nir_ssa_def_rewrite_uses_after(&tex->dest.ssa, nir_src_for_ssa(result),
702 result->parent_instr);
703 }
704
705 static bool
nir_lower_tex_block(nir_block * block,nir_builder * b,const nir_lower_tex_options * options)706 nir_lower_tex_block(nir_block *block, nir_builder *b,
707 const nir_lower_tex_options *options)
708 {
709 bool progress = false;
710
711 nir_foreach_instr_safe(instr, block) {
712 if (instr->type != nir_instr_type_tex)
713 continue;
714
715 nir_tex_instr *tex = nir_instr_as_tex(instr);
716 bool lower_txp = !!(options->lower_txp & (1 << tex->sampler_dim));
717
718 /* mask of src coords to saturate (clamp): */
719 unsigned sat_mask = 0;
720
721 if ((1 << tex->sampler_index) & options->saturate_r)
722 sat_mask |= (1 << 2); /* .z */
723 if ((1 << tex->sampler_index) & options->saturate_t)
724 sat_mask |= (1 << 1); /* .y */
725 if ((1 << tex->sampler_index) & options->saturate_s)
726 sat_mask |= (1 << 0); /* .x */
727
728 /* If we are clamping any coords, we must lower projector first
729 * as clamping happens *after* projection:
730 */
731 if (lower_txp || sat_mask) {
732 project_src(b, tex);
733 progress = true;
734 }
735
736 if ((tex->op == nir_texop_txf && options->lower_txf_offset) ||
737 (tex->sampler_dim == GLSL_SAMPLER_DIM_RECT &&
738 options->lower_rect_offset)) {
739 progress = lower_offset(b, tex) || progress;
740 }
741
742 if ((tex->sampler_dim == GLSL_SAMPLER_DIM_RECT) && options->lower_rect) {
743 lower_rect(b, tex);
744 progress = true;
745 }
746
747 if ((1 << tex->texture_index) & options->lower_y_uv_external) {
748 lower_y_uv_external(b, tex);
749 progress = true;
750 }
751
752 if ((1 << tex->texture_index) & options->lower_y_u_v_external) {
753 lower_y_u_v_external(b, tex);
754 progress = true;
755 }
756
757 if ((1 << tex->texture_index) & options->lower_yx_xuxv_external) {
758 lower_yx_xuxv_external(b, tex);
759 progress = true;
760 }
761
762
763 if (sat_mask) {
764 saturate_src(b, tex, sat_mask);
765 progress = true;
766 }
767
768 if (((1 << tex->texture_index) & options->swizzle_result) &&
769 !nir_tex_instr_is_query(tex) &&
770 !(tex->is_shadow && tex->is_new_style_shadow)) {
771 swizzle_result(b, tex, options->swizzles[tex->texture_index]);
772 progress = true;
773 }
774
775 /* should be after swizzle so we know which channels are rgb: */
776 if (((1 << tex->texture_index) & options->lower_srgb) &&
777 !nir_tex_instr_is_query(tex) && !tex->is_shadow) {
778 linearize_srgb_result(b, tex);
779 progress = true;
780 }
781
782 if (tex->op == nir_texop_txd &&
783 tex->sampler_dim == GLSL_SAMPLER_DIM_CUBE &&
784 (options->lower_txd_cube_map ||
785 (tex->is_shadow && options->lower_txd_shadow))) {
786 lower_gradient_cube_map(b, tex);
787 progress = true;
788 continue;
789 }
790
791 if (tex->op == nir_texop_txd && options->lower_txd_shadow &&
792 tex->is_shadow && tex->sampler_dim != GLSL_SAMPLER_DIM_CUBE) {
793 lower_gradient_shadow(b, tex);
794 progress = true;
795 continue;
796 }
797 }
798
799 return progress;
800 }
801
802 static bool
nir_lower_tex_impl(nir_function_impl * impl,const nir_lower_tex_options * options)803 nir_lower_tex_impl(nir_function_impl *impl,
804 const nir_lower_tex_options *options)
805 {
806 bool progress = false;
807 nir_builder builder;
808 nir_builder_init(&builder, impl);
809
810 nir_foreach_block(block, impl) {
811 progress |= nir_lower_tex_block(block, &builder, options);
812 }
813
814 nir_metadata_preserve(impl, nir_metadata_block_index |
815 nir_metadata_dominance);
816 return progress;
817 }
818
819 bool
nir_lower_tex(nir_shader * shader,const nir_lower_tex_options * options)820 nir_lower_tex(nir_shader *shader, const nir_lower_tex_options *options)
821 {
822 bool progress = false;
823
824 nir_foreach_function(function, shader) {
825 if (function->impl)
826 progress |= nir_lower_tex_impl(function->impl, options);
827 }
828
829 return progress;
830 }
831