← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/draw/draw_pt_so_emit.c

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/auxiliary/draw/draw_pt_so_emit.c
1
 
/**************************************************************************
2
 
 *
3
 
 * Copyright 2010 VMware, Inc.
4
 
 * All Rights Reserved.
5
 
 *
6
 
 * Permission is hereby granted, free of charge, to any person obtaining a
7
 
 * copy of this software and associated documentation files (the
8
 
 * "Software"), to deal in the Software without restriction, including
9
 
 * without limitation the rights to use, copy, modify, merge, publish,
10
 
 * distribute, sub license, and/or sell copies of the Software, and to
11
 
 * permit persons to whom the Software is furnished to do so, subject to
12
 
 * the following conditions:
13
 
 *
14
 
 * The above copyright notice and this permission notice (including the
15
 
 * next paragraph) shall be included in all copies or substantial portions
16
 
 * of the Software.
17
 
 *
18
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19
 
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20
 
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21
 
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22
 
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23
 
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24
 
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
 
 *
26
 
 **************************************************************************/
27
 
 
28
 
#include "draw/draw_private.h"
29
 
#include "draw/draw_vs.h"
30
 
#include "draw/draw_gs.h"
31
 
#include "draw/draw_tess.h"
32
 
#include "draw/draw_context.h"
33
 
#include "draw/draw_vbuf.h"
34
 
#include "draw/draw_vertex.h"
35
 
#include "draw/draw_pt.h"
36
 
 
37
 
#include "pipe/p_state.h"
38
 
 
39
 
#include "util/u_math.h"
40
 
#include "util/u_prim.h"
41
 
#include "util/u_memory.h"
42
 
 
43
 
struct pt_so_emit {
44
 
   struct draw_context *draw;
45
 
 
46
 
   unsigned input_vertex_stride;
47
 
   const float (*inputs)[4];
48
 
   const float *pre_clip_pos;
49
 
   boolean has_so;
50
 
   boolean use_pre_clip_pos;
51
 
   int pos_idx;
52
 
   unsigned emitted_primitives;
53
 
   unsigned generated_primitives;
54
 
   unsigned stream;
55
 
};
56
 
 
57
 
static const struct pipe_stream_output_info *
58
 
draw_so_info(const struct draw_context *draw)
59
 
{
60
 
   const struct pipe_stream_output_info *state = NULL;
61
 
 
62
 
   if (draw->gs.geometry_shader) {
63
 
      state = &draw->gs.geometry_shader->state.stream_output;
64
 
   } else if (draw->tes.tess_eval_shader) {
65
 
      state = &draw->tes.tess_eval_shader->state.stream_output;
66
 
   } else {
67
 
      state = &draw->vs.vertex_shader->state.stream_output;
68
 
   }
69
 
 
70
 
   return state;
71
 
}
72
 
 
73
 
static inline boolean
74
 
draw_has_so(const struct draw_context *draw)
75
 
{
76
 
   const struct pipe_stream_output_info *state = draw_so_info(draw);
77
 
 
78
 
   if (state && state->num_outputs > 0)
79
 
      return TRUE;
80
 
 
81
 
   return FALSE;
82
 
}
83
 
 
84
 
void draw_pt_so_emit_prepare(struct pt_so_emit *emit, boolean use_pre_clip_pos)
85
 
{
86
 
   struct draw_context *draw = emit->draw;
87
 
 
88
 
   emit->use_pre_clip_pos = use_pre_clip_pos;
89
 
   emit->has_so = draw_has_so(draw);
90
 
   if (use_pre_clip_pos)
91
 
      emit->pos_idx = draw_current_shader_position_output(draw);
92
 
 
93
 
   /* if we have a state with outputs make sure we have
94
 
    * buffers to output to */
95
 
   if (emit->has_so) {
96
 
      boolean has_valid_buffer = FALSE;
97
 
      unsigned i;
98
 
      for (i = 0; i < draw->so.num_targets; ++i) {
99
 
         if (draw->so.targets[i]) {
100
 
            has_valid_buffer = TRUE;
101
 
            break;
102
 
         }
103
 
      }
104
 
      emit->has_so = has_valid_buffer;
105
 
   }
106
 
 
107
 
   if (!emit->has_so)
108
 
      return;
109
 
 
110
 
   /* XXX: need to flush to get prim_vbuf.c to release its allocation??
111
 
    */
112
 
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
113
 
}
114
 
 
115
 
static void so_emit_prim(struct pt_so_emit *so,
116
 
                         unsigned *indices,
117
 
                         unsigned num_vertices)
118
 
{
119
 
   unsigned slot, i;
120
 
   unsigned input_vertex_stride = so->input_vertex_stride;
121
 
   struct draw_context *draw = so->draw;
122
 
   const float (*input_ptr)[4];
123
 
   const float *pcp_ptr = NULL;
124
 
   const struct pipe_stream_output_info *state = draw_so_info(draw);
125
 
   float *buffer;
126
 
   int buffer_total_bytes[PIPE_MAX_SO_BUFFERS];
127
 
   boolean buffer_written[PIPE_MAX_SO_BUFFERS] = {0};
128
 
 
129
 
   input_ptr = so->inputs;
130
 
   if (so->use_pre_clip_pos)
131
 
      pcp_ptr = so->pre_clip_pos;
132
 
 
133
 
   ++so->generated_primitives;
134
 
 
135
 
   for (i = 0; i < draw->so.num_targets; i++) {
136
 
      struct draw_so_target *target = draw->so.targets[i];
137
 
      if (target) {
138
 
         buffer_total_bytes[i] = target->internal_offset;
139
 
      } else {
140
 
         buffer_total_bytes[i] = 0;
141
 
      }
142
 
   }
143
 
 
144
 
   /* check have we space to emit prim first - if not don't do anything */
145
 
   for (i = 0; i < num_vertices; ++i) {
146
 
      unsigned ob;
147
 
      for (slot = 0; slot < state->num_outputs; ++slot) {
148
 
         unsigned num_comps = state->output[slot].num_components;
149
 
         int ob = state->output[slot].output_buffer;
150
 
         unsigned dst_offset = state->output[slot].dst_offset * sizeof(float);
151
 
         unsigned write_size = num_comps * sizeof(float);
152
 
 
153
 
         if (state->output[slot].stream != so->stream)
154
 
            continue;
155
 
         /* If a buffer is missing then that's equivalent to
156
 
          * an overflow */
157
 
         if (!draw->so.targets[ob]) {
158
 
            return;
159
 
         }
160
 
         if ((buffer_total_bytes[ob] + write_size + dst_offset) >
161
 
             draw->so.targets[ob]->target.buffer_size) {
162
 
            return;
163
 
         }
164
 
      }
165
 
      for (ob = 0; ob < draw->so.num_targets; ++ob) {
166
 
         buffer_total_bytes[ob] += state->stride[ob] * sizeof(float);
167
 
      }
168
 
   }
169
 
 
170
 
   for (i = 0; i < num_vertices; ++i) {
171
 
      const float (*input)[4];
172
 
      const float *pre_clip_pos = NULL;
173
 
      unsigned  ob;
174
 
 
175
 
      input = (const float (*)[4])(
176
 
         (const char *)input_ptr + (indices[i] * input_vertex_stride));
177
 
 
178
 
      if (pcp_ptr)
179
 
         pre_clip_pos = (const float *)(
180
 
         (const char *)pcp_ptr + (indices[i] * input_vertex_stride));
181
 
 
182
 
      for (slot = 0; slot < state->num_outputs; ++slot) {
183
 
         unsigned idx = state->output[slot].register_index;
184
 
         unsigned start_comp = state->output[slot].start_component;
185
 
         unsigned num_comps = state->output[slot].num_components;
186
 
         unsigned stream = state->output[slot].stream;
187
 
 
188
 
         if (stream != so->stream)
189
 
            continue;
190
 
         ob = state->output[slot].output_buffer;
191
 
         buffer_written[ob] = TRUE;
192
 
 
193
 
         buffer = (float *)((char *)draw->so.targets[ob]->mapping +
194
 
                            draw->so.targets[ob]->target.buffer_offset +
195
 
                            draw->so.targets[ob]->internal_offset) +
196
 
            state->output[slot].dst_offset;
197
 
         
198
 
         if (idx == so->pos_idx && pcp_ptr && so->stream == 0)
199
 
            memcpy(buffer, &pre_clip_pos[start_comp],
200
 
                   num_comps * sizeof(float));
201
 
         else
202
 
            memcpy(buffer, &input[idx][start_comp],
203
 
                   num_comps * sizeof(float));
204
 
#if 0
205
 
         {
206
 
            int j;
207
 
            debug_printf("VERT[%d], stream = %d, offset = %d, slot[%d] sc = %d, num_c = %d, idx = %d = [",
208
 
                         i, stream,
209
 
                         draw->so.targets[ob]->internal_offset,
210
 
                         slot, start_comp, num_comps, idx);
211
 
            for (j = 0; j < num_comps; ++j) {
212
 
               unsigned *ubuffer = (unsigned*)buffer;
213
 
               debug_printf("%d (0x%x), ", ubuffer[j], ubuffer[j]);
214
 
            }
215
 
            debug_printf("]\n");
216
 
         }
217
 
#endif
218
 
      }
219
 
      for (ob = 0; ob < draw->so.num_targets; ++ob) {
220
 
         struct draw_so_target *target = draw->so.targets[ob];
221
 
         if (target && buffer_written[ob]) {
222
 
            target->internal_offset += state->stride[ob] * sizeof(float);
223
 
         }
224
 
      }
225
 
   }
226
 
   ++so->emitted_primitives;
227
 
}
228
 
 
229
 
static void so_point(struct pt_so_emit *so, int idx)
230
 
{
231
 
   unsigned indices[1];
232
 
 
233
 
   indices[0] = idx;
234
 
 
235
 
   so_emit_prim(so, indices, 1);
236
 
}
237
 
 
238
 
static void so_line(struct pt_so_emit *so, int i0, int i1)
239
 
{
240
 
   unsigned indices[2];
241
 
 
242
 
   indices[0] = i0;
243
 
   indices[1] = i1;
244
 
 
245
 
   so_emit_prim(so, indices, 2);
246
 
}
247
 
 
248
 
static void so_tri(struct pt_so_emit *so, int i0, int i1, int i2)
249
 
{
250
 
   unsigned indices[3];
251
 
 
252
 
   indices[0] = i0;
253
 
   indices[1] = i1;
254
 
   indices[2] = i2;
255
 
 
256
 
   so_emit_prim(so, indices, 3);
257
 
}
258
 
 
259
 
 
260
 
#define FUNC         so_run_linear
261
 
#define GET_ELT(idx) (start + (idx))
262
 
#include "draw_so_emit_tmp.h"
263
 
 
264
 
 
265
 
#define FUNC         so_run_elts
266
 
#define LOCAL_VARS   const ushort *elts = input_prims->elts;
267
 
#define GET_ELT(idx) (elts[start + (idx)])
268
 
#include "draw_so_emit_tmp.h"
269
 
 
270
 
 
271
 
void draw_pt_so_emit( struct pt_so_emit *emit,
272
 
                      int num_vertex_streams,
273
 
                      const struct draw_vertex_info *input_verts,
274
 
                      const struct draw_prim_info *input_prims )
275
 
{
276
 
   struct draw_context *draw = emit->draw;
277
 
   struct vbuf_render *render = draw->render;
278
 
   unsigned start, i, stream;
279
 
 
280
 
   if (!emit->has_so && num_vertex_streams == 1) {
281
 
      if (draw->collect_primgen) {
282
 
         unsigned i;
283
 
         unsigned total = 0;
284
 
         for (i = 0; i < input_prims->primitive_count; i++) {
285
 
            total +=
286
 
               u_decomposed_prims_for_vertices(input_prims->prim,
287
 
                                               input_prims->primitive_lengths[i]);
288
 
         }
289
 
         render->set_stream_output_info(render,
290
 
                                        0, 0, total);
291
 
      }
292
 
      return;
293
 
   }
294
 
 
295
 
   if (!emit->has_so && !draw->collect_primgen)
296
 
      return;
297
 
 
298
 
   /* XXX: need to flush to get prim_vbuf.c to release its allocation??*/
299
 
   draw_do_flush( draw, DRAW_FLUSH_BACKEND );
300
 
 
301
 
   for (stream = 0; stream < num_vertex_streams; stream++) {
302
 
      emit->emitted_primitives = 0;
303
 
      emit->generated_primitives = 0;
304
 
      if (emit->use_pre_clip_pos)
305
 
         emit->pre_clip_pos = input_verts[stream].verts->clip_pos;
306
 
 
307
 
      emit->input_vertex_stride = input_verts[stream].stride;
308
 
      emit->inputs = (const float (*)[4])input_verts[stream].verts->data;
309
 
      emit->stream = stream;
310
 
      for (start = i = 0; i < input_prims[stream].primitive_count;
311
 
           start += input_prims[stream].primitive_lengths[i], i++)
312
 
      {
313
 
         unsigned count = input_prims[stream].primitive_lengths[i];
314
 
 
315
 
         if (input_prims->linear) {
316
 
            so_run_linear(emit, &input_prims[stream], &input_verts[stream],
317
 
                          start, count);
318
 
         } else {
319
 
            so_run_elts(emit, &input_prims[stream], &input_verts[stream],
320
 
                        start, count);
321
 
         }
322
 
      }
323
 
      render->set_stream_output_info(render,
324
 
                                     stream,
325
 
                                     emit->has_so ? emit->emitted_primitives : 0,
326
 
                                     emit->generated_primitives);
327
 
   }
328
 
}
329
 
 
330
 
 
331
 
struct pt_so_emit *draw_pt_so_emit_create( struct draw_context *draw )
332
 
{
333
 
   struct pt_so_emit *emit = CALLOC_STRUCT(pt_so_emit);
334
 
   if (!emit)
335
 
      return NULL;
336
 
 
337
 
   emit->draw = draw;
338
 
 
339
 
   return emit;
340
 
}
341
 
 
342
 
void draw_pt_so_emit_destroy( struct pt_so_emit *emit )
343
 
{
344
 
   FREE(emit);
345
 
}