1 /*
2 * Copyright © 2016 Intel Corporation
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 #include "anv_nir.h"
25 #include "nir/nir_builder.h"
26
27 /**
28 * This file implements the lowering required for VK_KHR_multiview. We
29 * implement multiview using instanced rendering. The number of instances in
30 * each draw call is multiplied by the number of views in the subpass. Then,
31 * in the shader, we divide gl_InstanceId by the number of views and use
32 * gl_InstanceId % view_count to compute the actual ViewIndex.
33 */
34
35 struct lower_multiview_state {
36 nir_builder builder;
37
38 uint32_t view_mask;
39
40 nir_ssa_def *instance_id;
41 nir_ssa_def *view_index;
42 };
43
44 static nir_ssa_def *
build_instance_id(struct lower_multiview_state * state)45 build_instance_id(struct lower_multiview_state *state)
46 {
47 assert(state->builder.shader->info.stage == MESA_SHADER_VERTEX);
48
49 if (state->instance_id == NULL) {
50 nir_builder *b = &state->builder;
51
52 b->cursor = nir_before_block(nir_start_block(b->impl));
53
54 /* We use instancing for implementing multiview. The actual instance id
55 * is given by dividing instance_id by the number of views in this
56 * subpass.
57 */
58 state->instance_id =
59 nir_idiv(b, nir_load_instance_id(b),
60 nir_imm_int(b, _mesa_bitcount(state->view_mask)));
61 }
62
63 return state->instance_id;
64 }
65
66 static nir_ssa_def *
build_view_index(struct lower_multiview_state * state)67 build_view_index(struct lower_multiview_state *state)
68 {
69 if (state->view_index == NULL) {
70 nir_builder *b = &state->builder;
71
72 b->cursor = nir_before_block(nir_start_block(b->impl));
73
74 assert(state->view_mask != 0);
75 if (0 && _mesa_bitcount(state->view_mask) == 1) {
76 state->view_index = nir_imm_int(b, ffs(state->view_mask) - 1);
77 } else if (state->builder.shader->info.stage == MESA_SHADER_VERTEX) {
78 /* We only support 16 viewports */
79 assert((state->view_mask & 0xffff0000) == 0);
80
81 /* We use instancing for implementing multiview. The compacted view
82 * id is given by instance_id % view_count. We then have to convert
83 * that to an actual view id.
84 */
85 nir_ssa_def *compacted =
86 nir_umod(b, nir_load_instance_id(b),
87 nir_imm_int(b, _mesa_bitcount(state->view_mask)));
88
89 if (0 && util_is_power_of_two(state->view_mask + 1)) {
90 /* If we have a full view mask, then compacted is what we want */
91 state->view_index = compacted;
92 } else {
93 /* Now we define a map from compacted view index to the actual
94 * view index that's based on the view_mask. The map is given by
95 * 16 nibbles, each of which is a value from 0 to 15.
96 */
97 uint64_t remap = 0;
98 uint32_t bit, i = 0;
99 for_each_bit(bit, state->view_mask) {
100 assert(bit < 16);
101 remap |= (uint64_t)bit << (i++ * 4);
102 }
103
104 nir_ssa_def *shift = nir_imul(b, compacted, nir_imm_int(b, 4));
105
106 /* One of these days, when we have int64 everywhere, this will be
107 * easier.
108 */
109 nir_ssa_def *shifted;
110 if (remap <= UINT32_MAX) {
111 shifted = nir_ushr(b, nir_imm_int(b, remap), shift);
112 } else {
113 nir_ssa_def *shifted_low =
114 nir_ushr(b, nir_imm_int(b, remap), shift);
115 nir_ssa_def *shifted_high =
116 nir_ushr(b, nir_imm_int(b, remap >> 32),
117 nir_isub(b, shift, nir_imm_int(b, 32)));
118 shifted = nir_bcsel(b, nir_ilt(b, shift, nir_imm_int(b, 32)),
119 shifted_low, shifted_high);
120 }
121 state->view_index = nir_iand(b, shifted, nir_imm_int(b, 0xf));
122 }
123 } else {
124 const struct glsl_type *type = glsl_int_type();
125 if (b->shader->info.stage == MESA_SHADER_TESS_CTRL ||
126 b->shader->info.stage == MESA_SHADER_GEOMETRY)
127 type = glsl_array_type(type, 1);
128
129 nir_variable *idx_var =
130 nir_variable_create(b->shader, nir_var_shader_in,
131 type, "view index");
132 idx_var->data.location = VARYING_SLOT_VIEW_INDEX;
133 if (b->shader->info.stage == MESA_SHADER_FRAGMENT)
134 idx_var->data.interpolation = INTERP_MODE_FLAT;
135
136 if (glsl_type_is_array(type)) {
137 nir_deref_var *deref = nir_deref_var_create(b->shader, idx_var);
138 nir_deref_array *arr = nir_deref_array_create(b->shader);
139 arr->deref.type = glsl_int_type();
140 arr->deref_array_type = nir_deref_array_type_direct;
141 arr->base_offset = 0;
142 deref->deref.child = &arr->deref;
143
144 state->view_index = nir_load_deref_var(b, deref);
145 } else {
146 state->view_index = nir_load_var(b, idx_var);
147 }
148 }
149 }
150
151 return state->view_index;
152 }
153
154 bool
anv_nir_lower_multiview(nir_shader * shader,uint32_t view_mask)155 anv_nir_lower_multiview(nir_shader *shader, uint32_t view_mask)
156 {
157 assert(shader->info.stage != MESA_SHADER_COMPUTE);
158
159 /* If multiview isn't enabled, we have nothing to do. */
160 if (view_mask == 0)
161 return false;
162
163 struct lower_multiview_state state = {
164 .view_mask = view_mask,
165 };
166
167 /* This pass assumes a single entrypoint */
168 nir_function_impl *entrypoint = nir_shader_get_entrypoint(shader);
169
170 nir_builder_init(&state.builder, entrypoint);
171
172 bool progress = false;
173 nir_foreach_block(block, entrypoint) {
174 nir_foreach_instr_safe(instr, block) {
175 if (instr->type != nir_instr_type_intrinsic)
176 continue;
177
178 nir_intrinsic_instr *load = nir_instr_as_intrinsic(instr);
179
180 if (load->intrinsic != nir_intrinsic_load_instance_id &&
181 load->intrinsic != nir_intrinsic_load_view_index)
182 continue;
183
184 assert(load->dest.is_ssa);
185
186 nir_ssa_def *value;
187 if (load->intrinsic == nir_intrinsic_load_instance_id) {
188 value = build_instance_id(&state);
189 } else {
190 assert(load->intrinsic == nir_intrinsic_load_view_index);
191 value = build_view_index(&state);
192 }
193
194 nir_ssa_def_rewrite_uses(&load->dest.ssa, nir_src_for_ssa(value));
195
196 nir_instr_remove(&load->instr);
197 progress = true;
198 }
199 }
200
201 /* The view index is available in all stages but the instance id is only
202 * available in the VS. If it's not a fragment shader, we need to pass
203 * the view index on to the next stage.
204 */
205 if (shader->info.stage != MESA_SHADER_FRAGMENT) {
206 nir_ssa_def *view_index = build_view_index(&state);
207
208 nir_builder *b = &state.builder;
209
210 assert(view_index->parent_instr->block == nir_start_block(entrypoint));
211 b->cursor = nir_after_instr(view_index->parent_instr);
212
213 nir_variable *view_index_out =
214 nir_variable_create(shader, nir_var_shader_out,
215 glsl_int_type(), "view index");
216 view_index_out->data.location = VARYING_SLOT_VIEW_INDEX;
217 nir_store_var(b, view_index_out, view_index, 0x1);
218
219 nir_variable *layer_id_out =
220 nir_variable_create(shader, nir_var_shader_out,
221 glsl_int_type(), "layer ID");
222 layer_id_out->data.location = VARYING_SLOT_LAYER;
223 nir_store_var(b, layer_id_out, view_index, 0x1);
224
225 progress = true;
226 }
227
228 if (progress) {
229 nir_metadata_preserve(entrypoint, nir_metadata_block_index |
230 nir_metadata_dominance);
231 }
232
233 return progress;
234 }
235