← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/compiler/nir/nir_passthrough_gs.c

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/compiler/nir/nir_passthrough_gs.c
27
27
#include "util/u_memory.h"
28
28
 
29
29
static unsigned int
30
 
gs_in_prim_for_topology(enum shader_prim prim)
 
30
gs_in_prim_for_topology(enum mesa_prim prim)
31
31
{
32
32
   switch (prim) {
33
 
   case SHADER_PRIM_QUADS:
34
 
      return SHADER_PRIM_LINES_ADJACENCY;
 
33
   case MESA_PRIM_QUADS:
 
34
      return MESA_PRIM_LINES_ADJACENCY;
35
35
   default:
36
36
      return prim;
37
37
   }
38
38
}
39
39
 
40
 
static enum shader_prim
41
 
gs_out_prim_for_topology(enum shader_prim prim)
 
40
static enum mesa_prim
 
41
gs_out_prim_for_topology(enum mesa_prim prim)
42
42
{
43
43
   switch (prim) {
44
 
   case SHADER_PRIM_POINTS:
45
 
      return SHADER_PRIM_POINTS;
46
 
   case SHADER_PRIM_LINES:
47
 
   case SHADER_PRIM_LINE_LOOP:
48
 
   case SHADER_PRIM_LINES_ADJACENCY:
49
 
   case SHADER_PRIM_LINE_STRIP_ADJACENCY:
50
 
   case SHADER_PRIM_LINE_STRIP:
51
 
      return SHADER_PRIM_LINE_STRIP;
52
 
   case SHADER_PRIM_TRIANGLES:
53
 
   case SHADER_PRIM_TRIANGLE_STRIP:
54
 
   case SHADER_PRIM_TRIANGLE_FAN:
55
 
   case SHADER_PRIM_TRIANGLES_ADJACENCY:
56
 
   case SHADER_PRIM_TRIANGLE_STRIP_ADJACENCY:
57
 
   case SHADER_PRIM_POLYGON:
58
 
      return SHADER_PRIM_TRIANGLE_STRIP;
59
 
   case SHADER_PRIM_QUADS:
60
 
   case SHADER_PRIM_QUAD_STRIP:
61
 
   case SHADER_PRIM_PATCHES:
 
44
   case MESA_PRIM_POINTS:
 
45
      return MESA_PRIM_POINTS;
 
46
   case MESA_PRIM_LINES:
 
47
   case MESA_PRIM_LINE_LOOP:
 
48
   case MESA_PRIM_LINES_ADJACENCY:
 
49
   case MESA_PRIM_LINE_STRIP_ADJACENCY:
 
50
   case MESA_PRIM_LINE_STRIP:
 
51
      return MESA_PRIM_LINE_STRIP;
 
52
   case MESA_PRIM_TRIANGLES:
 
53
   case MESA_PRIM_TRIANGLE_STRIP:
 
54
   case MESA_PRIM_TRIANGLE_FAN:
 
55
   case MESA_PRIM_TRIANGLES_ADJACENCY:
 
56
   case MESA_PRIM_TRIANGLE_STRIP_ADJACENCY:
 
57
   case MESA_PRIM_POLYGON:
 
58
      return MESA_PRIM_TRIANGLE_STRIP;
 
59
   case MESA_PRIM_QUADS:
 
60
   case MESA_PRIM_QUAD_STRIP:
 
61
   case MESA_PRIM_PATCHES:
62
62
   default:
63
 
      return SHADER_PRIM_QUADS;
 
63
      return MESA_PRIM_QUADS;
64
64
   }
65
65
}
66
66
 
67
67
static unsigned int
68
 
vertices_for_prim(enum shader_prim prim)
 
68
vertices_for_prim(enum mesa_prim prim)
69
69
{
70
70
   switch (prim) {
71
 
   case SHADER_PRIM_POINTS:
 
71
   case MESA_PRIM_POINTS:
72
72
      return 1;
73
 
   case SHADER_PRIM_LINES:
74
 
   case SHADER_PRIM_LINE_LOOP:
75
 
   case SHADER_PRIM_LINES_ADJACENCY:
76
 
   case SHADER_PRIM_LINE_STRIP_ADJACENCY:
77
 
   case SHADER_PRIM_LINE_STRIP:
 
73
   case MESA_PRIM_LINES:
 
74
   case MESA_PRIM_LINE_LOOP:
 
75
   case MESA_PRIM_LINES_ADJACENCY:
 
76
   case MESA_PRIM_LINE_STRIP_ADJACENCY:
 
77
   case MESA_PRIM_LINE_STRIP:
78
78
      return 2;
79
 
   case SHADER_PRIM_TRIANGLES:
80
 
   case SHADER_PRIM_TRIANGLE_STRIP:
81
 
   case SHADER_PRIM_TRIANGLE_FAN:
82
 
   case SHADER_PRIM_TRIANGLES_ADJACENCY:
83
 
   case SHADER_PRIM_TRIANGLE_STRIP_ADJACENCY:
84
 
   case SHADER_PRIM_POLYGON:
 
79
   case MESA_PRIM_TRIANGLES:
 
80
   case MESA_PRIM_TRIANGLE_STRIP:
 
81
   case MESA_PRIM_TRIANGLE_FAN:
 
82
   case MESA_PRIM_TRIANGLES_ADJACENCY:
 
83
   case MESA_PRIM_TRIANGLE_STRIP_ADJACENCY:
 
84
   case MESA_PRIM_POLYGON:
85
85
      return 3;
86
 
   case SHADER_PRIM_QUADS:
87
 
   case SHADER_PRIM_QUAD_STRIP:
 
86
   case MESA_PRIM_QUADS:
 
87
   case MESA_PRIM_QUAD_STRIP:
88
88
      return 4;
89
 
   case SHADER_PRIM_PATCHES:
 
89
   case MESA_PRIM_PATCHES:
90
90
   default:
91
91
      unreachable("unsupported primitive for gs input");
92
92
   }
93
93
}
94
94
 
95
95
static unsigned int
96
 
array_size_for_prim(enum shader_prim prim)
 
96
array_size_for_prim(enum mesa_prim prim)
97
97
{
98
98
   switch (prim) {
99
 
   case SHADER_PRIM_POINTS:
 
99
   case MESA_PRIM_POINTS:
100
100
      return 1;
101
 
   case SHADER_PRIM_LINES:
102
 
   case SHADER_PRIM_LINE_LOOP:
103
 
   case SHADER_PRIM_LINE_STRIP:
 
101
   case MESA_PRIM_LINES:
 
102
   case MESA_PRIM_LINE_LOOP:
 
103
   case MESA_PRIM_LINE_STRIP:
104
104
      return 2;
105
 
   case SHADER_PRIM_LINES_ADJACENCY:
106
 
   case SHADER_PRIM_LINE_STRIP_ADJACENCY:
 
105
   case MESA_PRIM_LINES_ADJACENCY:
 
106
   case MESA_PRIM_LINE_STRIP_ADJACENCY:
107
107
      return 4;
108
 
   case SHADER_PRIM_TRIANGLES:
109
 
   case SHADER_PRIM_TRIANGLE_STRIP:
110
 
   case SHADER_PRIM_TRIANGLE_FAN:
111
 
   case SHADER_PRIM_POLYGON:
 
108
   case MESA_PRIM_TRIANGLES:
 
109
   case MESA_PRIM_TRIANGLE_STRIP:
 
110
   case MESA_PRIM_TRIANGLE_FAN:
 
111
   case MESA_PRIM_POLYGON:
112
112
      return 3;
113
 
   case SHADER_PRIM_TRIANGLES_ADJACENCY:
114
 
   case SHADER_PRIM_TRIANGLE_STRIP_ADJACENCY:
 
113
   case MESA_PRIM_TRIANGLES_ADJACENCY:
 
114
   case MESA_PRIM_TRIANGLE_STRIP_ADJACENCY:
115
115
      return 6;
116
 
   case SHADER_PRIM_QUADS:
117
 
   case SHADER_PRIM_QUAD_STRIP:
 
116
   case MESA_PRIM_QUADS:
 
117
   case MESA_PRIM_QUAD_STRIP:
118
118
      return 4;
119
 
   case SHADER_PRIM_PATCHES:
 
119
   case MESA_PRIM_PATCHES:
120
120
   default:
121
121
      unreachable("unsupported primitive for gs input");
122
122
   }
149
149
nir_shader *
150
150
nir_create_passthrough_gs(const nir_shader_compiler_options *options,
151
151
                          const nir_shader *prev_stage,
152
 
                          enum shader_prim primitive_type,
153
 
                          int flat_interp_mask_offset,
154
 
                          int last_pv_vert_offset,
 
152
                          enum mesa_prim primitive_type,
155
153
                          bool emulate_edgeflags,
156
154
                          bool force_line_strip_out)
157
155
{
158
156
   unsigned int vertices_out = vertices_for_prim(primitive_type);
159
157
   emulate_edgeflags = emulate_edgeflags && (prev_stage->info.outputs_written & VARYING_BIT_EDGE);
160
158
   bool needs_closing = (force_line_strip_out || emulate_edgeflags) && vertices_out >= 3;
161
 
   enum shader_prim original_our_prim = gs_out_prim_for_topology(primitive_type);
 
159
   enum mesa_prim original_our_prim = gs_out_prim_for_topology(primitive_type);
162
160
   nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_GEOMETRY,
163
161
                                                  options,
164
162
                                                  "gs passthrough");
166
164
   nir_shader *nir = b.shader;
167
165
   nir->info.gs.input_primitive = gs_in_prim_for_topology(primitive_type);
168
166
   nir->info.gs.output_primitive = (force_line_strip_out || emulate_edgeflags) ?
169
 
      SHADER_PRIM_LINE_STRIP : original_our_prim;
 
167
      MESA_PRIM_LINE_STRIP : original_our_prim;
170
168
   nir->info.gs.vertices_in = vertices_out;
171
169
   nir->info.gs.vertices_out = needs_closing ? vertices_out + 1 : vertices_out;
172
170
   nir->info.gs.invocations = 1;
175
173
   nir->info.has_transform_feedback_varyings = prev_stage->info.has_transform_feedback_varyings;
176
174
   memcpy(nir->info.xfb_stride, prev_stage->info.xfb_stride, sizeof(prev_stage->info.xfb_stride));
177
175
   if (prev_stage->xfb_info) {
178
 
      nir->xfb_info = mem_dup(prev_stage->xfb_info, sizeof(nir_xfb_info));
 
176
      nir->xfb_info = mem_dup(prev_stage->xfb_info, nir_xfb_info_size(prev_stage->xfb_info->output_count));
179
177
   }
180
178
 
181
 
   bool handle_flat = nir->info.gs.output_primitive == SHADER_PRIM_LINE_STRIP &&
 
179
   bool handle_flat = nir->info.gs.output_primitive == MESA_PRIM_LINE_STRIP &&
182
180
                      nir->info.gs.output_primitive != original_our_prim;
183
181
   nir_variable *in_vars[VARYING_SLOT_MAX * 4];
184
182
   nir_variable *out_vars[VARYING_SLOT_MAX * 4];
202
200
      nir_variable *in = nir_variable_clone(var, nir);
203
201
      ralloc_free(in->name);
204
202
      in->name = ralloc_strdup(in, name);
205
 
      in->type = glsl_array_type(var->type, 4, false);
 
203
      in->type = glsl_array_type(var->type, 6, false);
206
204
      in->data.mode = nir_var_shader_in;
207
205
      nir_shader_add_variable(nir, in);
208
206
 
233
231
   unsigned int end_vert = vertices_out;
234
232
   unsigned int vert_step = 1;
235
233
   switch (primitive_type) {
236
 
   case PIPE_PRIM_LINES_ADJACENCY:
237
 
   case PIPE_PRIM_LINE_STRIP_ADJACENCY:
 
234
   case MESA_PRIM_LINES_ADJACENCY:
 
235
   case MESA_PRIM_LINE_STRIP_ADJACENCY:
238
236
      start_vert = 1;
239
237
      end_vert += 1;
240
238
      break;
241
 
   case PIPE_PRIM_TRIANGLES_ADJACENCY:
242
 
   case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
 
239
   case MESA_PRIM_TRIANGLES_ADJACENCY:
 
240
   case MESA_PRIM_TRIANGLE_STRIP_ADJACENCY:
243
241
      end_vert = 5;
244
242
      vert_step = 2;
245
243
      break;
248
246
   }
249
247
 
250
248
   nir_variable *edge_var = nir_find_variable_with_location(nir, nir_var_shader_in, VARYING_SLOT_EDGE);
251
 
   nir_ssa_def *flat_interp_mask_def = nir_load_ubo(&b, 1, 32,
252
 
                                                    nir_imm_int(&b, 0), nir_imm_int(&b, flat_interp_mask_offset),
253
 
                                                    .align_mul = 4, .align_offset = 0, .range_base = 0, .range = ~0);
254
 
   nir_ssa_def *last_pv_vert_def = nir_load_ubo(&b, 1, 32,
255
 
                                                nir_imm_int(&b, 0), nir_imm_int(&b, last_pv_vert_offset),
256
 
                                                .align_mul = 4, .align_offset = 0, .range_base = 0, .range = ~0);
 
249
   nir_ssa_def *flat_interp_mask_def = nir_load_flat_mask(&b);
 
250
   nir_ssa_def *last_pv_vert_def = nir_load_provoking_last(&b);
257
251
   last_pv_vert_def = nir_ine_imm(&b, last_pv_vert_def, 0);
258
252
   nir_ssa_def *start_vert_index = nir_imm_int(&b, start_vert);
259
253
   nir_ssa_def *end_vert_index = nir_imm_int(&b, end_vert - 1);
280
274
      nir_emit_vertex(&b, 0);
281
275
      if (emulate_edgeflags) {
282
276
         nir_ssa_def *edge_value = nir_channel(&b, nir_load_array_var_imm(&b, edge_var, idx), 0);
283
 
         nir_if *edge_if = nir_push_if(&b, nir_fneu(&b, edge_value, nir_imm_float(&b, 1.0)));
 
277
         nir_if *edge_if = nir_push_if(&b, nir_fneu_imm(&b, edge_value, 1.0));
284
278
         nir_end_primitive(&b, 0);
285
279
         nir_pop_if(&b, edge_if);
286
280
      }