| /* |
| * Copyright 2022 Advanced Micro Devices, Inc. |
| * All Rights Reserved. |
| * |
| * 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 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. |
| */ |
| |
| #include "main/enums.h" |
| #include "main/context.h" |
| |
| #include "st_context.h" |
| #include "st_nir.h" |
| #include "st_draw.h" |
| |
| #include "nir.h" |
| #include "nir_builtin_builder.h" |
| |
| #include "util/u_memory.h" |
| |
| union state_key { |
| struct { |
| unsigned num_user_clip_planes:4; |
| unsigned face_culling_enabled:1; |
| unsigned result_offset_from_attribute:1; |
| unsigned primitive:4; |
| }; |
| uint32_t u32; |
| }; |
| |
| enum primitive_state { |
| HW_SELECT_PRIM_NONE, |
| HW_SELECT_PRIM_POINTS, |
| HW_SELECT_PRIM_LINES, |
| HW_SELECT_PRIM_TRIANGLES, |
| HW_SELECT_PRIM_QUADS, |
| }; |
| |
| struct geometry_constant { |
| float depth_scale; |
| float depth_transport; |
| uint32_t culling_config; |
| uint32_t result_offset; |
| float clip_planes[MAX_CLIP_PLANES][4]; |
| }; |
| |
| #define set_uniform_location(var, field, packed) \ |
| do { \ |
| unsigned offset = offsetof(struct geometry_constant, field); \ |
| var->data.driver_location = offset >> (packed ? 2 : 4); \ |
| var->data.location_frac = (offset >> 2) & 0x3; \ |
| } while (0) |
| |
| static nir_def * |
| has_nan_or_inf(nir_builder *b, nir_def *v) |
| { |
| nir_def *nan = nir_bany_fnequal4(b, v, v); |
| |
| nir_def *inf = nir_bany(b, nir_feq_imm(b, nir_fabs(b, v), INFINITY)); |
| |
| return nir_ior(b, nan, inf); |
| } |
| |
| static void |
| return_if_true(nir_builder *b, nir_def *cond) |
| { |
| nir_if *if_cond = nir_push_if(b, cond); |
| nir_jump(b, nir_jump_return); |
| nir_pop_if(b, if_cond); |
| } |
| |
| static void |
| get_input_vertices(nir_builder *b, nir_def **v) |
| { |
| const int num_in_vert = b->shader->info.gs.vertices_in; |
| |
| nir_variable *in_pos = nir_variable_create( |
| b->shader, nir_var_shader_in, glsl_array_type(glsl_vec4_type(), num_in_vert, 0), |
| "gl_Position"); |
| in_pos->data.location = VARYING_SLOT_POS; |
| |
| nir_def *is_nan_or_inf = NULL; |
| for (int i = 0; i < num_in_vert; i++) { |
| v[i] = nir_load_array_var_imm(b, in_pos, i); |
| nir_def *r = has_nan_or_inf(b, v[i]); |
| is_nan_or_inf = i ? nir_ior(b, is_nan_or_inf, r) : r; |
| } |
| return_if_true(b, is_nan_or_inf); |
| } |
| |
| static void |
| face_culling(nir_builder *b, nir_def **v, bool packed) |
| { |
| /* use the z value of the face normal to determine if the face points to us: |
| * Nz = (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0) |
| * |
| * it should be in NDC (Normalized Device Coordinate), but now we are in clip |
| * space (Vd = Vc / Vc.w), so multiply Nz with w0*w1*w2 to get the clip space |
| * value: |
| * det = x0 * (y1 * w2 - y2 * w1) + |
| * x1 * (y2 * w0 - y0 * w2) + |
| * x2 * (y0 * w1 - y1 * w0) |
| * |
| * we only care about the sign of the det, but also need to count the sign of |
| * w0/w1/w2 as a negtive w would change the direction of Nz < 0 |
| */ |
| nir_def *y1w2 = nir_fmul(b, nir_channel(b, v[1], 1), nir_channel(b, v[2], 3)); |
| nir_def *y2w1 = nir_fmul(b, nir_channel(b, v[2], 1), nir_channel(b, v[1], 3)); |
| nir_def *y2w0 = nir_fmul(b, nir_channel(b, v[2], 1), nir_channel(b, v[0], 3)); |
| nir_def *y0w2 = nir_fmul(b, nir_channel(b, v[0], 1), nir_channel(b, v[2], 3)); |
| nir_def *y0w1 = nir_fmul(b, nir_channel(b, v[0], 1), nir_channel(b, v[1], 3)); |
| nir_def *y1w0 = nir_fmul(b, nir_channel(b, v[1], 1), nir_channel(b, v[0], 3)); |
| nir_def *t0 = nir_fmul(b, nir_channel(b, v[0], 0), nir_fsub(b, y1w2, y2w1)); |
| nir_def *t1 = nir_fmul(b, nir_channel(b, v[1], 0), nir_fsub(b, y2w0, y0w2)); |
| nir_def *t2 = nir_fmul(b, nir_channel(b, v[2], 0), nir_fsub(b, y0w1, y1w0)); |
| nir_def *det = nir_fadd(b, nir_fadd(b, t0, t1), t2); |
| |
| /* invert det sign once any vertex w < 0 */ |
| nir_def *n0 = nir_flt_imm(b, nir_channel(b, v[0], 3), 0); |
| nir_def *n1 = nir_flt_imm(b, nir_channel(b, v[1], 3), 0); |
| nir_def *n2 = nir_flt_imm(b, nir_channel(b, v[2], 3), 0); |
| nir_def *cond = nir_ixor(b, nir_ixor(b, n0, n1), n2); |
| det = nir_bcsel(b, cond, nir_fneg(b, det), det); |
| |
| nir_variable *culling_config = nir_variable_create( |
| b->shader, nir_var_uniform, glsl_uint_type(), "culling_config"); |
| set_uniform_location(culling_config, culling_config, packed); |
| nir_def *config = nir_i2b(b, nir_load_var(b, culling_config)); |
| |
| /* det < 0 then z points to camera */ |
| nir_def *zero = nir_imm_zero(b, 1, det->bit_size); |
| nir_def *is_zero = nir_feq(b, det, zero); |
| nir_def *is_neg = nir_flt(b, det, zero); |
| nir_def *cull = nir_ixor(b, is_neg, config); |
| return_if_true(b, nir_ior(b, is_zero, cull)); |
| } |
| |
| static void |
| fast_frustum_culling(nir_builder *b, nir_def **v) |
| { |
| nir_def *cull = NULL; |
| |
| /* there are six culling planes for the visible volume: |
| * 1. x + w = 0 |
| * 2. -x + w = 0 |
| * 3. y + w = 0 |
| * 4. -y + w = 0 |
| * 5. z + w = 0 |
| * 6. -z + w = 0 |
| * |
| * if all vertices of the primitive are outside (plane equation <0) of |
| * any plane, the primitive must be invisible. |
| */ |
| for (int i = 0; i < 6; i++) { |
| nir_def *outside = NULL; |
| |
| for (int j = 0; j < b->shader->info.gs.vertices_in; j++) { |
| nir_def *c = nir_channel(b, v[j], i >> 1); |
| if (i & 1) |
| c = nir_fneg(b, c); |
| |
| nir_def *r = nir_flt(b, nir_channel(b, v[j], 3), c); |
| outside = j ? nir_iand(b, outside, r) : r; |
| } |
| |
| cull = i ? nir_ior(b, cull, outside) : outside; |
| } |
| |
| return_if_true(b, cull); |
| } |
| |
| static nir_def * |
| get_intersection(nir_builder *b, nir_def *v1, nir_def *v2, |
| nir_def *d1, nir_def *d2) |
| { |
| nir_def *factor = nir_fdiv(b, d1, nir_fsub(b, d1, d2)); |
| return nir_fmad(b, nir_fsub(b, v2, v1), factor, v1); |
| } |
| |
| #define begin_for_loop(name, max) \ |
| nir_variable *name##_index = \ |
| nir_local_variable_create(b->impl, glsl_int_type(), #name "_i"); \ |
| nir_store_var(b, name##_index, nir_imm_int(b, 0), 1); \ |
| \ |
| nir_loop *name = nir_push_loop(b); \ |
| { \ |
| nir_def *idx = nir_load_var(b, name##_index); \ |
| nir_if *if_in_loop = nir_push_if(b, nir_ilt(b, idx, max)); |
| |
| #define end_for_loop(name) \ |
| nir_store_var(b, name##_index, nir_iadd_imm(b, idx, 1), 1); \ |
| nir_push_else(b, if_in_loop); \ |
| nir_jump(b, nir_jump_break); \ |
| nir_pop_if(b, if_in_loop); \ |
| } \ |
| nir_pop_loop(b, name); |
| |
| static void |
| clip_with_plane(nir_builder *b, nir_variable *vert, nir_variable *num_vert, |
| int max_vert, nir_def *plane) |
| { |
| nir_variable *all_clipped = nir_local_variable_create( |
| b->impl, glsl_bool_type(), "all_clipped"); |
| nir_store_var(b, all_clipped, nir_imm_true(b), 1); |
| |
| nir_variable *dist = nir_local_variable_create( |
| b->impl, glsl_array_type(glsl_float_type(), max_vert, 0), "dist"); |
| |
| nir_def *num = nir_load_var(b, num_vert); |
| begin_for_loop(dist_loop, num) |
| { |
| nir_def *v = nir_load_array_var(b, vert, idx); |
| nir_def *d = nir_fdot(b, v, plane); |
| nir_store_array_var(b, dist, idx, d, 1); |
| |
| nir_def *clipped = nir_flt_imm(b, d, 0); |
| nir_store_var(b, all_clipped, |
| nir_iand(b, nir_load_var(b, all_clipped), clipped), 1); |
| } |
| end_for_loop(dist_loop) |
| |
| return_if_true(b, nir_load_var(b, all_clipped)); |
| |
| /* Use +/0/- to denote the dist[i] sign, which means: |
| * +: inside plane |
| * -: outside plane |
| * 0: just on the plane |
| * |
| * Some example: |
| * ++++: all vertex not clipped |
| * ----: all vertex clipped |
| * +-++: one vertex clipped, need to insert two vertex at '-', array grow |
| * +--+: two vertex clipped, need to insert two vertex at '--', array same |
| * +---: three vertex clipped, need to insert two vertex at '---', array trim |
| * +-0+: one vertex clipped, need to insert one vertex at '-', array same |
| * |
| * Plane clip only produce convex polygon, so '-' must be contigous, there's |
| * no '+-+-', so one clip plane can only grow array by 1. |
| */ |
| |
| /* when array grow or '-' has been replaced with inserted vertex, save the |
| * original vert to be used by following calculation. |
| */ |
| nir_variable *saved = |
| nir_local_variable_create(b->impl, glsl_vec4_type(), "saved"); |
| |
| nir_variable *vert_index = |
| nir_local_variable_create(b->impl, glsl_int_type(), "vert_index"); |
| nir_store_var(b, vert_index, nir_imm_int(b, 0), 1); |
| |
| begin_for_loop(vert_loop, num) |
| { |
| nir_def *di = nir_load_array_var(b, dist, idx); |
| nir_if *if_clipped = nir_push_if(b, nir_flt_imm(b, di, 0)); |
| { |
| /* - case, we need to take care of sign change and insert vertex */ |
| |
| nir_def *prev = nir_bcsel(b, nir_ieq_imm(b, idx, 0), |
| nir_iadd_imm(b, num, -1), |
| nir_iadd_imm(b, idx, -1)); |
| nir_def *dp = nir_load_array_var(b, dist, prev); |
| nir_if *prev_if = nir_push_if(b, nir_fgt_imm(b, dp, 0)); |
| { |
| /* +- case, replace - with inserted vertex |
| * assert(vert_index <= idx), array is sure to not grow here |
| * but need to save vert[idx] when vert_index==idx |
| */ |
| |
| nir_def *vi = nir_load_array_var(b, vert, idx); |
| nir_store_var(b, saved, vi, 0xf); |
| |
| nir_def *vp = nir_load_array_var(b, vert, prev); |
| nir_def *iv = get_intersection(b, vp, vi, dp, di); |
| nir_def *index = nir_load_var(b, vert_index); |
| nir_store_array_var(b, vert, index, iv, 0xf); |
| |
| nir_store_var(b, vert_index, nir_iadd_imm(b, index, 1), 1); |
| } |
| nir_pop_if(b, prev_if); |
| |
| nir_def *next = nir_bcsel(b, nir_ieq(b, idx, nir_iadd_imm(b, num, -1)), |
| nir_imm_int(b, 0), nir_iadd_imm(b, idx, 1)); |
| nir_def *dn = nir_load_array_var(b, dist, next); |
| nir_if *next_if = nir_push_if(b, nir_fgt_imm(b, dn, 0)); |
| { |
| /* -+ case, may grow array: |
| * vert_index > idx: +-+ case, grow array, current vertex in 'saved', |
| * save next + to 'saved', will replace it with inserted vertex. |
| * vert_index <= idx: --+ case, will replace last - with inserted vertex, |
| * no need to save last -, because + case won't use - value. |
| */ |
| |
| nir_def *index = nir_load_var(b, vert_index); |
| nir_def *vi = nir_bcsel(b, nir_flt(b, idx, index), |
| nir_load_var(b, saved), |
| nir_load_array_var(b, vert, idx)); |
| nir_def *vn = nir_load_array_var(b, vert, next); |
| nir_def *iv = get_intersection(b, vn, vi, dn, di); |
| |
| nir_store_var(b, saved, nir_load_array_var(b, vert, index), 0xf); |
| nir_store_array_var(b, vert, index, iv, 0xf); |
| |
| nir_store_var(b, vert_index, nir_iadd_imm(b, index, 1), 1); |
| } |
| nir_pop_if(b, next_if); |
| } |
| nir_push_else(b, if_clipped); |
| { |
| /* +/0 case, just keep the vert |
| * vert_index > idx: array grew case, vert[idx] is inserted vertex or prev |
| * +/0 vertex, current vertex is in 'saved', need to save next vertex |
| * vert_index < idx: array trim case |
| */ |
| |
| nir_def *index = nir_load_var(b, vert_index); |
| nir_def *vi = nir_bcsel(b, nir_flt(b, idx, index), |
| nir_load_var(b, saved), |
| nir_load_array_var(b, vert, idx)); |
| |
| nir_store_var(b, saved, nir_load_array_var(b, vert, index), 0xf); |
| nir_store_array_var(b, vert, index, vi, 0xf); |
| |
| nir_store_var(b, vert_index, nir_iadd_imm(b, index, 1), 1); |
| } |
| nir_pop_if(b, if_clipped); |
| } |
| end_for_loop(vert_loop); |
| |
| nir_copy_var(b, num_vert, vert_index); |
| } |
| |
| static nir_def * |
| get_user_clip_plane(nir_builder *b, int index, bool packed) |
| { |
| char name[16]; |
| snprintf(name, sizeof(name), "gl_ClipPlane%d", index); |
| nir_variable *plane = nir_variable_create( |
| b->shader, nir_var_uniform, glsl_vec4_type(), name); |
| |
| set_uniform_location(plane, clip_planes[index][0], packed); |
| |
| return nir_load_var(b, plane); |
| } |
| |
| static void |
| get_depth_range_transform(nir_builder *b, bool packed, nir_def **trans) |
| { |
| nir_variable *depth_scale = nir_variable_create( |
| b->shader, nir_var_uniform, glsl_float_type(), "depth_scale"); |
| set_uniform_location(depth_scale, depth_scale, packed); |
| |
| nir_variable *depth_transport = nir_variable_create( |
| b->shader, nir_var_uniform, glsl_float_type(), "depth_transport"); |
| set_uniform_location(depth_transport, depth_transport, packed); |
| |
| trans[0] = nir_load_var(b, depth_scale); |
| trans[1] = nir_load_var(b, depth_transport); |
| } |
| |
| static nir_def * |
| get_window_space_depth(nir_builder *b, nir_def *v, nir_def **trans) |
| { |
| nir_def *z = nir_channel(b, v, 2); |
| nir_def *w = nir_channel(b, v, 3); |
| |
| /* do perspective division, if w==0, xyz must be 0 too (otherwise can't pass |
| * the clip test), 0/0=NaN, but we want it to be the nearest point. |
| */ |
| nir_def *c = nir_feq_imm(b, w, 0); |
| nir_def *d = nir_bcsel(b, c, nir_imm_float(b, -1), nir_fdiv(b, z, w)); |
| |
| /* map [-1, 1] to [near, far] set by glDepthRange(near, far) */ |
| return nir_fmad(b, trans[0], d, trans[1]); |
| } |
| |
| static void |
| update_result_buffer(nir_builder *b, nir_def *dmin, nir_def *dmax, |
| bool offset_from_attribute, bool packed) |
| { |
| nir_def *offset; |
| if (offset_from_attribute) { |
| nir_variable *in_offset = nir_variable_create( |
| b->shader, nir_var_shader_in, |
| glsl_array_type(glsl_uint_type(), b->shader->info.gs.vertices_in, 0), |
| "result_offset"); |
| in_offset->data.location = VARYING_SLOT_VAR0; |
| offset = nir_load_array_var_imm(b, in_offset, 0); |
| } else { |
| nir_variable *uni_offset = nir_variable_create( |
| b->shader, nir_var_uniform, glsl_uint_type(), "result_offset"); |
| set_uniform_location(uni_offset, result_offset, packed); |
| offset = nir_load_var(b, uni_offset); |
| } |
| |
| nir_variable_create(b->shader, nir_var_mem_ssbo, |
| glsl_array_type(glsl_uint_type(), 0, 0), "result"); |
| /* driver_location = 0 (slot 0) */ |
| |
| nir_def *ssbo = nir_imm_int(b, 0); |
| nir_ssbo_atomic(b, 32, ssbo, offset, nir_imm_int(b, 1), |
| .atomic_op = nir_atomic_op_xchg); |
| nir_ssbo_atomic(b, 32, ssbo, nir_iadd_imm(b, offset, 4), dmin, |
| .atomic_op = nir_atomic_op_umin); |
| nir_ssbo_atomic(b, 32, ssbo, nir_iadd_imm(b, offset, 8), dmax, |
| .atomic_op = nir_atomic_op_umax); |
| } |
| |
| static void |
| build_point_nir_shader(nir_builder *b, union state_key state, bool packed) |
| { |
| assert(b->shader->info.gs.vertices_in == 1); |
| |
| nir_def *v; |
| get_input_vertices(b, &v); |
| |
| fast_frustum_culling(b, &v); |
| |
| nir_def *outside = NULL; |
| for (int i = 0; i < state.num_user_clip_planes; i++) { |
| nir_def *p = get_user_clip_plane(b, i, packed); |
| nir_def *d = nir_fdot(b, v, p); |
| nir_def *r = nir_flt_imm(b, d, 0); |
| outside = i ? nir_ior(b, outside, r) : r; |
| } |
| if (outside) |
| return_if_true(b, outside); |
| |
| nir_def *trans[2]; |
| get_depth_range_transform(b, packed, trans); |
| |
| nir_def *depth = get_window_space_depth(b, v, trans); |
| nir_def *fdepth = nir_fmul_imm(b, depth, 4294967295.0); |
| nir_def *idepth = nir_f2uN(b, fdepth, 32); |
| |
| update_result_buffer(b, idepth, idepth, state.result_offset_from_attribute, packed); |
| } |
| |
| static nir_variable * |
| create_clip_planes(nir_builder *b, int num_clip_planes, bool packed) |
| { |
| nir_variable *clip_planes = nir_local_variable_create( |
| b->impl, glsl_array_type(glsl_vec4_type(), num_clip_planes, 0), "clip_planes"); |
| |
| nir_def *unit_clip_planes[6] = { |
| nir_imm_vec4(b, 1, 0, 0, 1), |
| nir_imm_vec4(b, -1, 0, 0, 1), |
| nir_imm_vec4(b, 0, 1, 0, 1), |
| nir_imm_vec4(b, 0, -1, 0, 1), |
| nir_imm_vec4(b, 0, 0, 1, 1), |
| nir_imm_vec4(b, 0, 0, -1, 1), |
| }; |
| for (int i = 0; i < 6; i++) |
| nir_store_array_var_imm(b, clip_planes, i, unit_clip_planes[i], 0xf); |
| |
| for (int i = 6; i < num_clip_planes; i++) { |
| nir_def *p = get_user_clip_plane(b, i - 6, packed); |
| nir_store_array_var_imm(b, clip_planes, i, p, 0xf); |
| } |
| |
| return clip_planes; |
| } |
| |
| static void |
| build_line_nir_shader(nir_builder *b, union state_key state, bool packed) |
| { |
| assert(b->shader->info.gs.vertices_in == 2); |
| |
| nir_def *v[2]; |
| get_input_vertices(b, v); |
| |
| fast_frustum_culling(b, v); |
| |
| nir_variable *vert0 = nir_local_variable_create(b->impl, glsl_vec4_type(), "vert0"); |
| nir_store_var(b, vert0, v[0], 0xf); |
| |
| nir_variable *vert1 = nir_local_variable_create(b->impl, glsl_vec4_type(), "vert1"); |
| nir_store_var(b, vert1, v[1], 0xf); |
| |
| const int num_clip_planes = 6 + state.num_user_clip_planes; |
| nir_variable *clip_planes = create_clip_planes(b, num_clip_planes, packed); |
| |
| begin_for_loop(clip_loop, nir_imm_int(b, num_clip_planes)) |
| { |
| nir_def *plane = nir_load_array_var(b, clip_planes, idx); |
| nir_def *v0 = nir_load_var(b, vert0); |
| nir_def *v1 = nir_load_var(b, vert1); |
| nir_def *d0 = nir_fdot(b, v0, plane); |
| nir_def *d1 = nir_fdot(b, v1, plane); |
| nir_def *n0 = nir_flt_imm(b, d0, 0); |
| nir_def *n1 = nir_flt_imm(b, d1, 0); |
| |
| return_if_true(b, nir_iand(b, n0, n1)); |
| |
| nir_if *clip_if = nir_push_if(b, nir_ior(b, n0, n1)); |
| { |
| nir_def *iv = get_intersection(b, v0, v1, d0, d1); |
| nir_store_var(b, vert0, nir_bcsel(b, n0, iv, v0), 0xf); |
| nir_store_var(b, vert1, nir_bcsel(b, n1, iv, v1), 0xf); |
| } |
| nir_pop_if(b, clip_if); |
| } |
| end_for_loop(clip_loop) |
| |
| nir_def *trans[2]; |
| get_depth_range_transform(b, packed, trans); |
| |
| nir_def *d0 = get_window_space_depth(b, nir_load_var(b, vert0), trans); |
| nir_def *d1 = get_window_space_depth(b, nir_load_var(b, vert1), trans); |
| |
| nir_def *dmin = nir_fmin(b, d0, d1); |
| nir_def *dmax = nir_fmax(b, d0, d1); |
| |
| nir_def *fdmin = nir_fmul_imm(b, dmin, 4294967295.0); |
| nir_def *idmin = nir_f2uN(b, fdmin, 32); |
| |
| nir_def *fdmax = nir_fmul_imm(b, dmax, 4294967295.0); |
| nir_def *idmax = nir_f2uN(b, fdmax, 32); |
| |
| update_result_buffer(b, idmin, idmax, state.result_offset_from_attribute, packed); |
| } |
| |
| static void |
| build_planar_primitive_nir_shader(nir_builder *b, union state_key state, bool packed) |
| { |
| const int num_in_vert = b->shader->info.gs.vertices_in; |
| assert(num_in_vert == 3 || num_in_vert == 4); |
| |
| nir_def *v[4]; |
| get_input_vertices(b, v); |
| |
| if (state.face_culling_enabled) |
| face_culling(b, v, packed); |
| |
| /* fast frustum culling, this should filter out most primitives */ |
| fast_frustum_culling(b, v); |
| |
| const int num_clip_planes = 6 + state.num_user_clip_planes; |
| const int max_vert = num_in_vert + num_clip_planes; |
| |
| /* TODO: could use shared memory (ie. AMD GPU LDS) for this array |
| * to reduce register usage. |
| */ |
| nir_variable *vert = nir_local_variable_create( |
| b->impl, glsl_array_type(glsl_vec4_type(), max_vert, 0), "vert"); |
| for (int i = 0; i < num_in_vert; i++) |
| nir_store_array_var_imm(b, vert, i, v[i], 0xf); |
| |
| nir_variable *num_vert = |
| nir_local_variable_create(b->impl, glsl_int_type(), "num_vert"); |
| nir_store_var(b, num_vert, nir_imm_int(b, num_in_vert), 1); |
| |
| nir_variable *clip_planes = create_clip_planes(b, num_clip_planes, packed); |
| |
| /* accurate clipping with all clip planes */ |
| begin_for_loop(clip_loop, nir_imm_int(b, num_clip_planes)) |
| { |
| nir_def *plane = nir_load_array_var(b, clip_planes, idx); |
| clip_with_plane(b, vert, num_vert, max_vert, plane); |
| } |
| end_for_loop(clip_loop) |
| |
| nir_def *trans[2]; |
| get_depth_range_transform(b, packed, trans); |
| |
| nir_variable *dmin = |
| nir_local_variable_create(b->impl, glsl_float_type(), "dmin"); |
| nir_store_var(b, dmin, nir_imm_float(b, 1), 1); |
| |
| nir_variable *dmax = |
| nir_local_variable_create(b->impl, glsl_float_type(), "dmax"); |
| nir_store_var(b, dmax, nir_imm_float(b, 0), 1); |
| |
| begin_for_loop(depth_loop, nir_load_var(b, num_vert)) |
| { |
| nir_def *vtx = nir_load_array_var(b, vert, idx); |
| nir_def *depth = get_window_space_depth(b, vtx, trans); |
| nir_store_var(b, dmin, nir_fmin(b, nir_load_var(b, dmin), depth), 1); |
| nir_store_var(b, dmax, nir_fmax(b, nir_load_var(b, dmax), depth), 1); |
| } |
| end_for_loop(depth_loop) |
| |
| nir_def *fdmin = nir_fmul_imm(b, nir_load_var(b, dmin), 4294967295.0); |
| nir_def *idmin = nir_f2uN(b, fdmin, 32); |
| |
| nir_def *fdmax = nir_fmul_imm(b, nir_load_var(b, dmax), 4294967295.0); |
| nir_def *idmax = nir_f2uN(b, fdmax, 32); |
| |
| update_result_buffer(b, idmin, idmax, state.result_offset_from_attribute, packed); |
| } |
| |
| static void * |
| hw_select_create_gs(struct st_context *st, union state_key state) |
| { |
| const nir_shader_compiler_options *options = |
| st_get_nir_compiler_options(st, MESA_SHADER_GEOMETRY); |
| |
| nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_GEOMETRY, options, |
| "hw select GS"); |
| |
| nir_shader *nir = b.shader; |
| nir->info.inputs_read = VARYING_BIT_POS; |
| nir->num_uniforms = DIV_ROUND_UP(sizeof(struct geometry_constant), (4 * sizeof(float))); |
| nir->info.num_ssbos = 1; |
| nir->info.gs.output_primitive = MESA_PRIM_POINTS; |
| nir->info.gs.vertices_out = 1; |
| nir->info.gs.invocations = 1; |
| nir->info.gs.active_stream_mask = 1; |
| |
| if (state.result_offset_from_attribute) |
| nir->info.inputs_read |= VARYING_BIT_VAR(0); |
| |
| bool packed = st->ctx->Const.PackedDriverUniformStorage; |
| |
| switch (state.primitive) { |
| case HW_SELECT_PRIM_POINTS: |
| nir->info.gs.input_primitive = MESA_PRIM_POINTS; |
| nir->info.gs.vertices_in = 1; |
| build_point_nir_shader(&b, state, packed); |
| break; |
| case HW_SELECT_PRIM_LINES: |
| nir->info.gs.input_primitive = MESA_PRIM_LINES; |
| nir->info.gs.vertices_in = 2; |
| build_line_nir_shader(&b, state, packed); |
| break; |
| case HW_SELECT_PRIM_TRIANGLES: |
| nir->info.gs.input_primitive = MESA_PRIM_TRIANGLES; |
| nir->info.gs.vertices_in = 3; |
| build_planar_primitive_nir_shader(&b, state, packed); |
| break; |
| case HW_SELECT_PRIM_QUADS: |
| /* geometry shader has no quad primitive, use lines_adjacency instead */ |
| nir->info.gs.input_primitive = MESA_PRIM_LINES_ADJACENCY; |
| nir->info.gs.vertices_in = 4; |
| build_planar_primitive_nir_shader(&b, state, packed); |
| break; |
| default: |
| unreachable("unexpected primitive"); |
| } |
| |
| nir_lower_returns(nir); |
| |
| return st_nir_finish_builtin_shader(st, nir); |
| } |
| |
| bool |
| st_draw_hw_select_prepare_common(struct gl_context *ctx) |
| { |
| struct st_context *st = st_context(ctx); |
| if (ctx->GeometryProgram._Current || |
| ctx->TessCtrlProgram._Current || |
| ctx->TessEvalProgram._Current) { |
| fprintf(stderr, "HW GL_SELECT does not support user geometry/tessellation shader\n"); |
| return false; |
| } |
| |
| struct geometry_constant consts; |
| |
| float n = ctx->ViewportArray[0].Near; |
| float f = ctx->ViewportArray[0].Far; |
| consts.depth_scale = (f - n) / 2; |
| consts.depth_transport = (f + n) / 2; |
| |
| /* this field is not used when face culling disabled */ |
| consts.culling_config = |
| (ctx->Polygon.CullFaceMode == GL_BACK) ^ |
| (ctx->Polygon.FrontFace == GL_CCW); |
| |
| /* this field is not used when passing result offset by attribute */ |
| consts.result_offset = st->ctx->Select.ResultOffset; |
| |
| int num_planes = 0; |
| u_foreach_bit(i, ctx->Transform.ClipPlanesEnabled) { |
| COPY_4V(consts.clip_planes[num_planes], ctx->Transform._ClipUserPlane[i]); |
| num_planes++; |
| } |
| |
| struct pipe_constant_buffer cb; |
| cb.buffer = NULL; |
| cb.user_buffer = &consts; |
| cb.buffer_offset = 0; |
| cb.buffer_size = sizeof(consts) - (MAX_CLIP_PLANES - num_planes) * 4 * sizeof(float); |
| |
| struct pipe_context *pipe = st->pipe; |
| pipe->set_constant_buffer(pipe, PIPE_SHADER_GEOMETRY, 0, false, &cb); |
| |
| struct pipe_shader_buffer buffer; |
| memset(&buffer, 0, sizeof(buffer)); |
| buffer.buffer = ctx->Select.Result->buffer; |
| buffer.buffer_size = MAX_NAME_STACK_RESULT_NUM * 3 * sizeof(int); |
| |
| pipe->set_shader_buffers(pipe, PIPE_SHADER_GEOMETRY, 0, 1, &buffer, 0x1); |
| |
| return true; |
| } |
| |
| static union state_key |
| make_state_key(struct gl_context *ctx, int mode) |
| { |
| union state_key state = {0}; |
| |
| switch (mode) { |
| case GL_POINTS: |
| state.primitive = HW_SELECT_PRIM_POINTS; |
| break; |
| case GL_LINES: |
| case GL_LINE_STRIP: |
| case GL_LINE_LOOP: |
| state.primitive = HW_SELECT_PRIM_LINES; |
| break; |
| case GL_QUADS: |
| state.primitive = HW_SELECT_PRIM_QUADS; |
| break; |
| case GL_TRIANGLES: |
| case GL_TRIANGLE_STRIP: |
| case GL_TRIANGLE_FAN: |
| /* These will be broken into triangles. */ |
| case GL_QUAD_STRIP: |
| case GL_POLYGON: |
| state.primitive = HW_SELECT_PRIM_TRIANGLES; |
| break; |
| default: |
| fprintf(stderr, "HW GL_SELECT does not support draw mode %s\n", |
| _mesa_enum_to_string(mode)); |
| return (union state_key){0}; |
| } |
| |
| /* TODO: support gl_ClipDistance/gl_CullDistance, but it costs more regs */ |
| struct gl_program *vp = ctx->VertexProgram._Current; |
| if (vp->info.clip_distance_array_size || vp->info.cull_distance_array_size) { |
| fprintf(stderr, "HW GL_SELECT does not support gl_ClipDistance/gl_CullDistance\n"); |
| return (union state_key){0}; |
| } |
| |
| state.num_user_clip_planes = util_bitcount(ctx->Transform.ClipPlanesEnabled); |
| |
| /* face culling only apply to 2D primitives */ |
| if (state.primitive == HW_SELECT_PRIM_QUADS || |
| state.primitive == HW_SELECT_PRIM_TRIANGLES) |
| state.face_culling_enabled = ctx->Polygon.CullFlag; |
| |
| state.result_offset_from_attribute = |
| ctx->VertexProgram._VPMode == VP_MODE_FF && |
| (ctx->VertexProgram._VaryingInputs & VERT_BIT_SELECT_RESULT_OFFSET); |
| |
| return state; |
| } |
| |
| bool |
| st_draw_hw_select_prepare_mode(struct gl_context *ctx, struct pipe_draw_info *info) |
| { |
| union state_key key = make_state_key(ctx, info->mode); |
| if (!key.u32) |
| return false; |
| |
| struct st_context *st = st_context(ctx); |
| if (!st->hw_select_shaders) |
| st->hw_select_shaders = _mesa_hash_table_create_u32_keys(NULL); |
| |
| struct hash_entry *he = _mesa_hash_table_search(st->hw_select_shaders, |
| (void*)(uintptr_t)key.u32); |
| void *gs; |
| if (!he) { |
| gs = hw_select_create_gs(st, key); |
| if (!gs) |
| return false; |
| |
| _mesa_hash_table_insert(st->hw_select_shaders, (void*)(uintptr_t)key.u32, gs); |
| } else |
| gs = he->data; |
| |
| struct cso_context *cso = st->cso_context; |
| cso_set_geometry_shader_handle(cso, gs); |
| |
| /* Replace draw mode with equivalent one which geometry shader support. |
| * |
| * New mode consume same vertex buffer structure and produce primitive with |
| * same vertices (no need to be same type of primitive, because geometry shader |
| * operate on vertives and emit nothing). |
| * |
| * We can break QUAD and POLYGON to triangles with same shape. But we can't futher |
| * break them into single line or point because new primitive need to contain >=3 |
| * vertices so that it's still handled in 2D (planar) way instead of 1D (line) or |
| * 0D (point) way which have different algorithm. |
| */ |
| switch (info->mode) { |
| case GL_QUADS: |
| info->mode = GL_LINES_ADJACENCY; |
| break; |
| case GL_QUAD_STRIP: |
| info->mode = GL_TRIANGLE_STRIP; |
| break; |
| case GL_POLYGON: |
| info->mode = GL_TRIANGLE_FAN; |
| break; |
| default: |
| break; |
| } |
| |
| /* Only normal glBegin/End draws pass result offset by attribute to avoid flush |
| * vertices when change name stack, so multiple glBegin/End sections before/after |
| * name stack calls can be merged to a single draw call. To achieve this We mark |
| * name stack result buffer used in glEnd instead of the last draw call. |
| * |
| * Other case like glDrawArrays and display list replay won't merge draws cross |
| * name stack calls, so we just mark name stack result buffer used here. |
| */ |
| if (!key.result_offset_from_attribute) |
| ctx->Select.ResultUsed = GL_TRUE; |
| |
| return true; |
| } |
