← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/draw/draw_pipe_flatshade.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_pipe_flatshade.c
1
 
/**************************************************************************
2
 
 * 
3
 
 * Copyright 2007 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
 
/* Authors:  Keith Whitwell <keithw@vmware.com>
29
 
 */
30
 
 
31
 
#include "util/u_math.h"
32
 
#include "util/u_memory.h"
33
 
 
34
 
#include "pipe/p_shader_tokens.h"
35
 
#include "draw_vs.h"
36
 
#include "draw_fs.h"
37
 
#include "draw_pipe.h"
38
 
 
39
 
 
40
 
/** subclass of draw_stage */
41
 
struct flat_stage
42
 
{
43
 
   struct draw_stage stage;
44
 
 
45
 
   uint num_flat_attribs;
46
 
   uint flat_attribs[PIPE_MAX_SHADER_OUTPUTS];  /* flatshaded attribs */
47
 
};
48
 
 
49
 
 
50
 
static inline struct flat_stage *
51
 
flat_stage(struct draw_stage *stage)
52
 
{
53
 
   return (struct flat_stage *) stage;
54
 
}
55
 
 
56
 
 
57
 
/** Copy all the constant attributes from 'src' vertex to 'dst' vertex */
58
 
static inline void copy_flats( struct draw_stage *stage,
59
 
                               struct vertex_header *dst,
60
 
                               const struct vertex_header *src )
61
 
{
62
 
   const struct flat_stage *flat = flat_stage(stage);
63
 
   uint i;
64
 
 
65
 
   for (i = 0; i < flat->num_flat_attribs; i++) {
66
 
      const uint attr = flat->flat_attribs[i];
67
 
      COPY_4FV(dst->data[attr], src->data[attr]);
68
 
   }
69
 
}
70
 
 
71
 
 
72
 
/** Copy all the color attributes from src vertex to dst0 & dst1 vertices */
73
 
static inline void copy_flats2( struct draw_stage *stage,
74
 
                                struct vertex_header *dst0,
75
 
                                struct vertex_header *dst1,
76
 
                                const struct vertex_header *src )
77
 
{
78
 
   const struct flat_stage *flat = flat_stage(stage);
79
 
   uint i;
80
 
   for (i = 0; i < flat->num_flat_attribs; i++) {
81
 
      const uint attr = flat->flat_attribs[i];
82
 
      COPY_4FV(dst0->data[attr], src->data[attr]);
83
 
      COPY_4FV(dst1->data[attr], src->data[attr]);
84
 
   }
85
 
}
86
 
 
87
 
 
88
 
/**
89
 
 * Flatshade tri. Not required for clipping which handles this on its own,
90
 
 * but required for unfilled tris and other primitive-changing stages
91
 
 * (like widelines). If no such stages are active, handled by hardware.
92
 
 */
93
 
static void flatshade_tri_0( struct draw_stage *stage,
94
 
                             struct prim_header *header )
95
 
{
96
 
   struct prim_header tmp;
97
 
 
98
 
   tmp.det = header->det;
99
 
   tmp.flags = header->flags;
100
 
   tmp.pad = header->pad;
101
 
   tmp.v[0] = header->v[0];
102
 
   tmp.v[1] = dup_vert(stage, header->v[1], 0);
103
 
   tmp.v[2] = dup_vert(stage, header->v[2], 1);
104
 
 
105
 
   copy_flats2(stage, tmp.v[1], tmp.v[2], tmp.v[0]);
106
 
 
107
 
   stage->next->tri( stage->next, &tmp );
108
 
}
109
 
 
110
 
 
111
 
static void flatshade_tri_2( struct draw_stage *stage,
112
 
                             struct prim_header *header )
113
 
{
114
 
   struct prim_header tmp;
115
 
 
116
 
   tmp.det = header->det;
117
 
   tmp.flags = header->flags;
118
 
   tmp.pad = header->pad;
119
 
   tmp.v[0] = dup_vert(stage, header->v[0], 0);
120
 
   tmp.v[1] = dup_vert(stage, header->v[1], 1);
121
 
   tmp.v[2] = header->v[2];
122
 
 
123
 
   copy_flats2(stage, tmp.v[0], tmp.v[1], tmp.v[2]);
124
 
 
125
 
   stage->next->tri( stage->next, &tmp );
126
 
}
127
 
 
128
 
 
129
 
/**
130
 
 * Flatshade line.
131
 
 */
132
 
static void flatshade_line_0( struct draw_stage *stage,
133
 
                              struct prim_header *header )
134
 
{
135
 
   struct prim_header tmp;
136
 
 
137
 
   tmp.det = header->det;
138
 
   tmp.flags = header->flags;
139
 
   tmp.pad = header->pad;
140
 
   tmp.v[0] = header->v[0];
141
 
   tmp.v[1] = dup_vert(stage, header->v[1], 0);
142
 
 
143
 
   copy_flats(stage, tmp.v[1], tmp.v[0]);
144
 
 
145
 
   stage->next->line( stage->next, &tmp );
146
 
}
147
 
 
148
 
 
149
 
static void flatshade_line_1( struct draw_stage *stage,
150
 
                              struct prim_header *header )
151
 
{
152
 
   struct prim_header tmp;
153
 
 
154
 
   tmp.det = header->det;
155
 
   tmp.flags = header->flags;
156
 
   tmp.pad = header->pad;
157
 
   tmp.v[0] = dup_vert(stage, header->v[0], 0);
158
 
   tmp.v[1] = header->v[1];
159
 
 
160
 
   copy_flats(stage, tmp.v[0], tmp.v[1]);
161
 
 
162
 
   stage->next->line( stage->next, &tmp );
163
 
}
164
 
 
165
 
 
166
 
static int
167
 
find_interp(const struct draw_fragment_shader *fs, int *indexed_interp,
168
 
            uint semantic_name, uint semantic_index)
169
 
{
170
 
   int interp;
171
 
   /* If it's gl_{Front,Back}{,Secondary}Color, pick up the mode
172
 
    * from the array we've filled before. */
173
 
   if ((semantic_name == TGSI_SEMANTIC_COLOR ||
174
 
        semantic_name == TGSI_SEMANTIC_BCOLOR) &&
175
 
       semantic_index < 2) {
176
 
      interp = indexed_interp[semantic_index];
177
 
   } else {
178
 
      /* Otherwise, search in the FS inputs, with a decent default
179
 
       * if we don't find it.
180
 
       */
181
 
      uint j;
182
 
      interp = TGSI_INTERPOLATE_PERSPECTIVE;
183
 
      if (fs) {
184
 
         for (j = 0; j < fs->info.num_inputs; j++) {
185
 
            if (semantic_name == fs->info.input_semantic_name[j] &&
186
 
                semantic_index == fs->info.input_semantic_index[j]) {
187
 
               interp = fs->info.input_interpolate[j];
188
 
               break;
189
 
            }
190
 
         }
191
 
      }
192
 
   }
193
 
   return interp;
194
 
}
195
 
 
196
 
 
197
 
static void flatshade_init_state( struct draw_stage *stage )
198
 
{
199
 
   struct flat_stage *flat = flat_stage(stage);
200
 
   const struct draw_context *draw = stage->draw;
201
 
   const struct draw_fragment_shader *fs = draw->fs.fragment_shader;
202
 
   const struct tgsi_shader_info *info = draw_get_shader_info(draw);
203
 
   uint i, j;
204
 
 
205
 
   /* Find which vertex shader outputs need constant interpolation, make a list */
206
 
 
207
 
   /* XXX: this code is a near exact copy of the one in clip_init_state.
208
 
    * The latter also cares about perspective though.
209
 
    */
210
 
 
211
 
   /* First pick up the interpolation mode for
212
 
    * gl_Color/gl_SecondaryColor, with the correct default.
213
 
    */
214
 
   int indexed_interp[2];
215
 
   indexed_interp[0] = indexed_interp[1] = draw->rasterizer->flatshade ?
216
 
      TGSI_INTERPOLATE_CONSTANT : TGSI_INTERPOLATE_PERSPECTIVE;
217
 
 
218
 
   if (fs) {
219
 
      for (i = 0; i < fs->info.num_inputs; i++) {
220
 
         if (fs->info.input_semantic_name[i] == TGSI_SEMANTIC_COLOR &&
221
 
             fs->info.input_semantic_index[i] < 2) {
222
 
            if (fs->info.input_interpolate[i] != TGSI_INTERPOLATE_COLOR)
223
 
               indexed_interp[fs->info.input_semantic_index[i]] = fs->info.input_interpolate[i];
224
 
         }
225
 
      }
226
 
   }
227
 
 
228
 
   /* Then resolve the interpolation mode for every output attribute.
229
 
    *
230
 
    * Given how the rest of the code, the most efficient way is to
231
 
    * have a vector of flat-mode attributes.
232
 
    */
233
 
   flat->num_flat_attribs = 0;
234
 
   for (i = 0; i < info->num_outputs; i++) {
235
 
      /* Find the interpolation mode for a specific attribute */
236
 
      int interp = find_interp(fs, indexed_interp,
237
 
                               info->output_semantic_name[i],
238
 
                               info->output_semantic_index[i]);
239
 
      /* If it's flat, add it to the flat vector. */
240
 
 
241
 
      if (interp == TGSI_INTERPOLATE_CONSTANT ||
242
 
          (interp == TGSI_INTERPOLATE_COLOR && draw->rasterizer->flatshade)) {
243
 
         flat->flat_attribs[flat->num_flat_attribs] = i;
244
 
         flat->num_flat_attribs++;
245
 
      }
246
 
   }
247
 
   /* Search the extra vertex attributes */
248
 
   for (j = 0; j < draw->extra_shader_outputs.num; j++) {
249
 
      /* Find the interpolation mode for a specific attribute */
250
 
      int interp = find_interp(fs, indexed_interp,
251
 
                               draw->extra_shader_outputs.semantic_name[j],
252
 
                               draw->extra_shader_outputs.semantic_index[j]);
253
 
      /* If it's flat, add it to the flat vector. */
254
 
      if (interp == TGSI_INTERPOLATE_CONSTANT) {
255
 
         flat->flat_attribs[flat->num_flat_attribs] = i + j;
256
 
         flat->num_flat_attribs++;
257
 
      }
258
 
   }
259
 
 
260
 
   /* Choose flatshade routine according to provoking vertex:
261
 
    */
262
 
   if (draw->rasterizer->flatshade_first) {
263
 
      stage->line = flatshade_line_0;
264
 
      stage->tri = flatshade_tri_0;
265
 
   }
266
 
   else {
267
 
      stage->line = flatshade_line_1;
268
 
      stage->tri = flatshade_tri_2;
269
 
   }
270
 
}
271
 
 
272
 
static void flatshade_first_tri( struct draw_stage *stage,
273
 
                                 struct prim_header *header )
274
 
{
275
 
   flatshade_init_state( stage );
276
 
   stage->tri( stage, header );
277
 
}
278
 
 
279
 
static void flatshade_first_line( struct draw_stage *stage,
280
 
                                  struct prim_header *header )
281
 
{
282
 
   flatshade_init_state( stage );
283
 
   stage->line( stage, header );
284
 
}
285
 
 
286
 
 
287
 
static void flatshade_flush( struct draw_stage *stage, 
288
 
                             unsigned flags )
289
 
{
290
 
   stage->tri = flatshade_first_tri;
291
 
   stage->line = flatshade_first_line;
292
 
   stage->next->flush( stage->next, flags );
293
 
}
294
 
 
295
 
 
296
 
static void flatshade_reset_stipple_counter( struct draw_stage *stage )
297
 
{
298
 
   stage->next->reset_stipple_counter( stage->next );
299
 
}
300
 
 
301
 
 
302
 
static void flatshade_destroy( struct draw_stage *stage )
303
 
{
304
 
   draw_free_temp_verts( stage );
305
 
   FREE( stage );
306
 
}
307
 
 
308
 
 
309
 
/**
310
 
 * Create flatshading drawing stage.
311
 
 */
312
 
struct draw_stage *draw_flatshade_stage( struct draw_context *draw )
313
 
{
314
 
   struct flat_stage *flatshade = CALLOC_STRUCT(flat_stage);
315
 
   if (!flatshade)
316
 
      goto fail;
317
 
 
318
 
   flatshade->stage.draw = draw;
319
 
   flatshade->stage.name = "flatshade";
320
 
   flatshade->stage.next = NULL;
321
 
   flatshade->stage.point = draw_pipe_passthrough_point;
322
 
   flatshade->stage.line = flatshade_first_line;
323
 
   flatshade->stage.tri = flatshade_first_tri;
324
 
   flatshade->stage.flush = flatshade_flush;
325
 
   flatshade->stage.reset_stipple_counter = flatshade_reset_stipple_counter;
326
 
   flatshade->stage.destroy = flatshade_destroy;
327
 
 
328
 
   if (!draw_alloc_temp_verts( &flatshade->stage, 2 ))
329
 
      goto fail;
330
 
 
331
 
   return &flatshade->stage;
332
 
 
333
 
 fail:
334
 
   if (flatshade)
335
 
      flatshade->stage.destroy( &flatshade->stage );
336
 
 
337
 
   return NULL;
338
 
}
339
 
 
340