1 /**************************************************************************
3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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 TUNGSTEN GRAPHICS 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.
26 **************************************************************************/
28 #include "util/u_inlines.h"
29 #include "util/u_math.h"
30 #include "util/u_memory.h"
31 #include "util/u_pstipple.h"
32 #include "pipe/p_shader_tokens.h"
33 #include "draw/draw_context.h"
34 #include "draw/draw_vertex.h"
35 #include "sp_context.h"
36 #include "sp_screen.h"
38 #include "sp_texture.h"
39 #include "sp_tex_tile_cache.h"
43 * Mark the current vertex layout as "invalid".
44 * We'll validate the vertex layout later, when we start to actually
45 * render a point or line or tri.
48 invalidate_vertex_layout(struct softpipe_context
*softpipe
)
50 softpipe
->vertex_info
.num_attribs
= 0;
55 * The vertex info describes how to convert the post-transformed vertices
56 * (simple float[][4]) used by the 'draw' module into vertices for
59 * This function validates the vertex layout and returns a pointer to a
63 softpipe_get_vertex_info(struct softpipe_context
*softpipe
)
65 struct vertex_info
*vinfo
= &softpipe
->vertex_info
;
67 if (vinfo
->num_attribs
== 0) {
68 /* compute vertex layout now */
69 const struct tgsi_shader_info
*fsInfo
= &softpipe
->fs_variant
->info
;
70 struct vertex_info
*vinfo_vbuf
= &softpipe
->vertex_info_vbuf
;
71 const uint num
= draw_num_shader_outputs(softpipe
->draw
);
74 /* Tell draw_vbuf to simply emit the whole post-xform vertex
75 * as-is. No longer any need to try and emit draw vertex_header
78 vinfo_vbuf
->num_attribs
= 0;
79 for (i
= 0; i
< num
; i
++) {
80 draw_emit_vertex_attr(vinfo_vbuf
, EMIT_4F
, INTERP_PERSPECTIVE
, i
);
82 draw_compute_vertex_size(vinfo_vbuf
);
85 * Loop over fragment shader inputs, searching for the matching output
86 * from the vertex shader.
88 vinfo
->num_attribs
= 0;
89 for (i
= 0; i
< fsInfo
->num_inputs
; i
++) {
91 enum interp_mode interp
;
93 switch (fsInfo
->input_interpolate
[i
]) {
94 case TGSI_INTERPOLATE_CONSTANT
:
95 interp
= INTERP_CONSTANT
;
97 case TGSI_INTERPOLATE_LINEAR
:
98 interp
= INTERP_LINEAR
;
100 case TGSI_INTERPOLATE_PERSPECTIVE
:
101 interp
= INTERP_PERSPECTIVE
;
103 case TGSI_INTERPOLATE_COLOR
:
104 assert(fsInfo
->input_semantic_name
[i
] == TGSI_SEMANTIC_COLOR
);
108 interp
= INTERP_LINEAR
;
111 switch (fsInfo
->input_semantic_name
[i
]) {
112 case TGSI_SEMANTIC_POSITION
:
116 case TGSI_SEMANTIC_COLOR
:
117 if (fsInfo
->input_interpolate
[i
] == TGSI_INTERPOLATE_COLOR
) {
118 if (softpipe
->rasterizer
->flatshade
)
119 interp
= INTERP_CONSTANT
;
121 interp
= INTERP_PERSPECTIVE
;
126 /* this includes texcoords and varying vars */
127 src
= draw_find_shader_output(softpipe
->draw
,
128 fsInfo
->input_semantic_name
[i
],
129 fsInfo
->input_semantic_index
[i
]);
130 if (fsInfo
->input_semantic_name
[i
] == TGSI_SEMANTIC_COLOR
&& src
== 0)
131 /* try and find a bcolor */
132 src
= draw_find_shader_output(softpipe
->draw
,
133 TGSI_SEMANTIC_BCOLOR
, fsInfo
->input_semantic_index
[i
]);
135 draw_emit_vertex_attr(vinfo
, EMIT_4F
, interp
, src
);
138 softpipe
->psize_slot
= draw_find_shader_output(softpipe
->draw
,
139 TGSI_SEMANTIC_PSIZE
, 0);
140 if (softpipe
->psize_slot
> 0) {
141 draw_emit_vertex_attr(vinfo
, EMIT_4F
, INTERP_CONSTANT
,
142 softpipe
->psize_slot
);
145 draw_compute_vertex_size(vinfo
);
153 * Called from vbuf module.
155 * Note that there's actually two different vertex layouts in softpipe.
157 * The normal one is computed in softpipe_get_vertex_info() above and is
158 * used by the point/line/tri "setup" code.
160 * The other one (this one) is only used by the vbuf module (which is
161 * not normally used by default but used in testing). For the vbuf module,
162 * we basically want to pass-through the draw module's vertex layout as-is.
163 * When the softpipe vbuf code begins drawing, the normal vertex layout
164 * will come into play again.
167 softpipe_get_vbuf_vertex_info(struct softpipe_context
*softpipe
)
169 (void) softpipe_get_vertex_info(softpipe
);
170 return &softpipe
->vertex_info_vbuf
;
175 * Recompute cliprect from scissor bounds, scissor enable and surface size.
178 compute_cliprect(struct softpipe_context
*sp
)
180 /* SP_NEW_FRAMEBUFFER
182 uint surfWidth
= sp
->framebuffer
.width
;
183 uint surfHeight
= sp
->framebuffer
.height
;
187 if (sp
->rasterizer
->scissor
) {
191 * clip to scissor rect:
193 sp
->cliprect
.minx
= MAX2(sp
->scissor
.minx
, 0);
194 sp
->cliprect
.miny
= MAX2(sp
->scissor
.miny
, 0);
195 sp
->cliprect
.maxx
= MIN2(sp
->scissor
.maxx
, surfWidth
);
196 sp
->cliprect
.maxy
= MIN2(sp
->scissor
.maxy
, surfHeight
);
199 /* clip to surface bounds */
200 sp
->cliprect
.minx
= 0;
201 sp
->cliprect
.miny
= 0;
202 sp
->cliprect
.maxx
= surfWidth
;
203 sp
->cliprect
.maxy
= surfHeight
;
209 update_tgsi_samplers( struct softpipe_context
*softpipe
)
213 softpipe_reset_sampler_variants( softpipe
);
215 for (i
= 0; i
< PIPE_MAX_SAMPLERS
; i
++) {
216 struct softpipe_tex_tile_cache
*tc
= softpipe
->fragment_tex_cache
[i
];
217 if (tc
&& tc
->texture
) {
218 struct softpipe_resource
*spt
= softpipe_resource(tc
->texture
);
219 if (spt
->timestamp
!= tc
->timestamp
) {
220 sp_tex_tile_cache_validate_texture( tc
);
222 _debug_printf("INV %d %d\n", tc->timestamp, spt->timestamp);
224 tc
->timestamp
= spt
->timestamp
;
229 for (i
= 0; i
< PIPE_MAX_VERTEX_SAMPLERS
; i
++) {
230 struct softpipe_tex_tile_cache
*tc
= softpipe
->vertex_tex_cache
[i
];
232 if (tc
&& tc
->texture
) {
233 struct softpipe_resource
*spt
= softpipe_resource(tc
->texture
);
235 if (spt
->timestamp
!= tc
->timestamp
) {
236 sp_tex_tile_cache_validate_texture(tc
);
237 tc
->timestamp
= spt
->timestamp
;
242 for (i
= 0; i
< PIPE_MAX_GEOMETRY_SAMPLERS
; i
++) {
243 struct softpipe_tex_tile_cache
*tc
= softpipe
->geometry_tex_cache
[i
];
245 if (tc
&& tc
->texture
) {
246 struct softpipe_resource
*spt
= softpipe_resource(tc
->texture
);
248 if (spt
->timestamp
!= tc
->timestamp
) {
249 sp_tex_tile_cache_validate_texture(tc
);
250 tc
->timestamp
= spt
->timestamp
;
258 update_fragment_shader(struct softpipe_context
*softpipe
, unsigned prim
)
260 struct sp_fragment_shader_variant_key key
;
262 memset(&key
, 0, sizeof(key
));
264 if (prim
== PIPE_PRIM_TRIANGLES
)
265 key
.polygon_stipple
= softpipe
->rasterizer
->poly_stipple_enable
;
268 softpipe
->fs_variant
= softpipe_find_fs_variant(softpipe
,
272 softpipe
->fs_variant
= NULL
;
275 /* This would be the logical place to pass the fragment shader
276 * to the draw module. However, doing this here, during state
277 * validation, causes problems with the 'draw' module helpers for
278 * wide/AA/stippled lines.
279 * In principle, the draw's fragment shader should be per-variant
280 * but that doesn't work. So we use a single draw fragment shader
281 * per fragment shader, not per variant.
284 if (softpipe
->fs_variant
) {
285 draw_bind_fragment_shader(softpipe
->draw
,
286 softpipe
->fs_variant
->draw_shader
);
289 draw_bind_fragment_shader(softpipe
->draw
, NULL
);
296 * This should be called when the polygon stipple pattern changes.
297 * We create a new texture from the stipple pattern and create a new
301 update_polygon_stipple_pattern(struct softpipe_context
*softpipe
)
303 struct pipe_resource
*tex
;
304 struct pipe_sampler_view
*view
;
306 tex
= util_pstipple_create_stipple_texture(&softpipe
->pipe
,
307 softpipe
->poly_stipple
.stipple
);
308 pipe_resource_reference(&softpipe
->pstipple
.texture
, tex
);
309 pipe_resource_reference(&tex
, NULL
);
311 view
= util_pstipple_create_sampler_view(&softpipe
->pipe
,
312 softpipe
->pstipple
.texture
);
313 pipe_sampler_view_reference(&softpipe
->pstipple
.sampler_view
, view
);
314 pipe_sampler_view_reference(&view
, NULL
);
319 * Should be called when polygon stipple is enabled/disabled or when
320 * the fragment shader changes.
321 * We add/update the fragment sampler and sampler views to sample from
322 * the polygon stipple texture. The texture unit that we use depends on
323 * the fragment shader (we need to use a unit not otherwise used by the
327 update_polygon_stipple_enable(struct softpipe_context
*softpipe
, unsigned prim
)
329 if (prim
== PIPE_PRIM_TRIANGLES
&&
330 softpipe
->fs_variant
->key
.polygon_stipple
) {
331 const unsigned unit
= softpipe
->fs_variant
->stipple_sampler_unit
;
333 assert(unit
>= softpipe
->num_fragment_samplers
);
336 softpipe
->fragment_samplers
[unit
] = softpipe
->pstipple
.sampler
;
339 pipe_sampler_view_reference(&softpipe
->fragment_sampler_views
[unit
],
340 softpipe
->pstipple
.sampler_view
);
342 sp_tex_tile_cache_set_sampler_view(softpipe
->fragment_tex_cache
[unit
],
343 softpipe
->pstipple
.sampler_view
);
345 softpipe
->dirty
|= SP_NEW_SAMPLER
;
350 /* Hopefully this will remain quite simple, otherwise need to pull in
351 * something like the state tracker mechanism.
354 softpipe_update_derived(struct softpipe_context
*softpipe
, unsigned prim
)
356 struct softpipe_screen
*sp_screen
= softpipe_screen(softpipe
->pipe
.screen
);
358 /* Check for updated textures.
360 if (softpipe
->tex_timestamp
!= sp_screen
->timestamp
) {
361 softpipe
->tex_timestamp
= sp_screen
->timestamp
;
362 softpipe
->dirty
|= SP_NEW_TEXTURE
;
365 #if DO_PSTIPPLE_IN_HELPER_MODULE
366 if (softpipe
->dirty
& SP_NEW_STIPPLE
)
367 /* before updating samplers! */
368 update_polygon_stipple_pattern(softpipe
);
371 if (softpipe
->dirty
& (SP_NEW_RASTERIZER
|
373 update_fragment_shader(softpipe
, prim
);
375 #if DO_PSTIPPLE_IN_HELPER_MODULE
376 if (softpipe
->dirty
& (SP_NEW_RASTERIZER
|
379 update_polygon_stipple_enable(softpipe
, prim
);
382 if (softpipe
->dirty
& (SP_NEW_SAMPLER
|
386 update_tgsi_samplers( softpipe
);
388 if (softpipe
->dirty
& (SP_NEW_RASTERIZER
|
391 invalidate_vertex_layout( softpipe
);
393 if (softpipe
->dirty
& (SP_NEW_SCISSOR
|
396 compute_cliprect(softpipe
);
398 if (softpipe
->dirty
& (SP_NEW_BLEND
|
399 SP_NEW_DEPTH_STENCIL_ALPHA
|
402 sp_build_quad_pipeline(softpipe
);