• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 *
flat_stage(struct draw_stage * 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 */
copy_flats(struct draw_stage * stage,struct vertex_header * dst,const struct vertex_header * src)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 */
copy_flats2(struct draw_stage * stage,struct vertex_header * dst0,struct vertex_header * dst1,const struct vertex_header * src)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  */
flatshade_tri_0(struct draw_stage * stage,struct prim_header * header)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 
flatshade_tri_2(struct draw_stage * stage,struct prim_header * header)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  */
flatshade_line_0(struct draw_stage * stage,struct prim_header * header)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 
flatshade_line_1(struct draw_stage * stage,struct prim_header * header)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
find_interp(const struct draw_fragment_shader * fs,int * indexed_interp,uint semantic_name,uint semantic_index)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       interp = indexed_interp[semantic_index];
176    } else {
177       /* Otherwise, search in the FS inputs, with a decent default
178        * if we don't find it.
179        */
180       uint j;
181       interp = TGSI_INTERPOLATE_PERSPECTIVE;
182       if (fs) {
183          for (j = 0; j < fs->info.num_inputs; j++) {
184             if (semantic_name == fs->info.input_semantic_name[j] &&
185                 semantic_index == fs->info.input_semantic_index[j]) {
186                interp = fs->info.input_interpolate[j];
187                break;
188             }
189          }
190       }
191    }
192    return interp;
193 }
194 
195 
flatshade_init_state(struct draw_stage * stage)196 static void flatshade_init_state( struct draw_stage *stage )
197 {
198    struct flat_stage *flat = flat_stage(stage);
199    const struct draw_context *draw = stage->draw;
200    const struct draw_fragment_shader *fs = draw->fs.fragment_shader;
201    const struct tgsi_shader_info *info = draw_get_shader_info(draw);
202    uint i, j;
203 
204    /* Find which vertex shader outputs need constant interpolation, make a list */
205 
206    /* XXX: this code is a near exact copy of the one in clip_init_state.
207     * The latter also cares about perspective though.
208     */
209 
210    /* First pick up the interpolation mode for
211     * gl_Color/gl_SecondaryColor, with the correct default.
212     */
213    int indexed_interp[2];
214    indexed_interp[0] = indexed_interp[1] = draw->rasterizer->flatshade ?
215       TGSI_INTERPOLATE_CONSTANT : TGSI_INTERPOLATE_PERSPECTIVE;
216 
217    if (fs) {
218       for (i = 0; i < fs->info.num_inputs; i++) {
219          if (fs->info.input_semantic_name[i] == TGSI_SEMANTIC_COLOR) {
220             if (fs->info.input_interpolate[i] != TGSI_INTERPOLATE_COLOR)
221                indexed_interp[fs->info.input_semantic_index[i]] = fs->info.input_interpolate[i];
222          }
223       }
224    }
225 
226    /* Then resolve the interpolation mode for every output attribute.
227     *
228     * Given how the rest of the code, the most efficient way is to
229     * have a vector of flat-mode attributes.
230     */
231    flat->num_flat_attribs = 0;
232    for (i = 0; i < info->num_outputs; i++) {
233       /* Find the interpolation mode for a specific attribute */
234       int interp = find_interp(fs, indexed_interp,
235                                info->output_semantic_name[i],
236                                info->output_semantic_index[i]);
237       /* If it's flat, add it to the flat vector. */
238 
239       if (interp == TGSI_INTERPOLATE_CONSTANT) {
240          flat->flat_attribs[flat->num_flat_attribs] = i;
241          flat->num_flat_attribs++;
242       }
243    }
244    /* Search the extra vertex attributes */
245    for (j = 0; j < draw->extra_shader_outputs.num; j++) {
246       /* Find the interpolation mode for a specific attribute */
247       int interp = find_interp(fs, indexed_interp,
248                                draw->extra_shader_outputs.semantic_name[j],
249                                draw->extra_shader_outputs.semantic_index[j]);
250       /* If it's flat, add it to the flat vector. */
251       if (interp == TGSI_INTERPOLATE_CONSTANT) {
252          flat->flat_attribs[flat->num_flat_attribs] = i + j;
253          flat->num_flat_attribs++;
254       }
255    }
256 
257    /* Choose flatshade routine according to provoking vertex:
258     */
259    if (draw->rasterizer->flatshade_first) {
260       stage->line = flatshade_line_0;
261       stage->tri = flatshade_tri_0;
262    }
263    else {
264       stage->line = flatshade_line_1;
265       stage->tri = flatshade_tri_2;
266    }
267 }
268 
flatshade_first_tri(struct draw_stage * stage,struct prim_header * header)269 static void flatshade_first_tri( struct draw_stage *stage,
270                                  struct prim_header *header )
271 {
272    flatshade_init_state( stage );
273    stage->tri( stage, header );
274 }
275 
flatshade_first_line(struct draw_stage * stage,struct prim_header * header)276 static void flatshade_first_line( struct draw_stage *stage,
277                                   struct prim_header *header )
278 {
279    flatshade_init_state( stage );
280    stage->line( stage, header );
281 }
282 
283 
flatshade_flush(struct draw_stage * stage,unsigned flags)284 static void flatshade_flush( struct draw_stage *stage,
285                              unsigned flags )
286 {
287    stage->tri = flatshade_first_tri;
288    stage->line = flatshade_first_line;
289    stage->next->flush( stage->next, flags );
290 }
291 
292 
flatshade_reset_stipple_counter(struct draw_stage * stage)293 static void flatshade_reset_stipple_counter( struct draw_stage *stage )
294 {
295    stage->next->reset_stipple_counter( stage->next );
296 }
297 
298 
flatshade_destroy(struct draw_stage * stage)299 static void flatshade_destroy( struct draw_stage *stage )
300 {
301    draw_free_temp_verts( stage );
302    FREE( stage );
303 }
304 
305 
306 /**
307  * Create flatshading drawing stage.
308  */
draw_flatshade_stage(struct draw_context * draw)309 struct draw_stage *draw_flatshade_stage( struct draw_context *draw )
310 {
311    struct flat_stage *flatshade = CALLOC_STRUCT(flat_stage);
312    if (!flatshade)
313       goto fail;
314 
315    flatshade->stage.draw = draw;
316    flatshade->stage.name = "flatshade";
317    flatshade->stage.next = NULL;
318    flatshade->stage.point = draw_pipe_passthrough_point;
319    flatshade->stage.line = flatshade_first_line;
320    flatshade->stage.tri = flatshade_first_tri;
321    flatshade->stage.flush = flatshade_flush;
322    flatshade->stage.reset_stipple_counter = flatshade_reset_stipple_counter;
323    flatshade->stage.destroy = flatshade_destroy;
324 
325    if (!draw_alloc_temp_verts( &flatshade->stage, 2 ))
326       goto fail;
327 
328    return &flatshade->stage;
329 
330  fail:
331    if (flatshade)
332       flatshade->stage.destroy( &flatshade->stage );
333 
334    return NULL;
335 }
336 
337 
338