#include "draw_vs.h"
#include "draw_pipe.h"
+#include "draw_fs.h"
+#include "draw_gs.h"
+
+
+/** Set to 1 to enable printing of coords before/after clipping */
+#define DEBUG_CLIP 0
#ifndef IS_NEGATIVE
struct clip_stage {
struct draw_stage stage; /**< base class */
- /* Basically duplicate some of the flatshading logic here:
- */
- boolean flat;
- uint num_color_attribs;
- uint color_attribs[4]; /* front/back primary/secondary colors */
+ /* List of the attributes to be flatshaded. */
+ uint num_flat_attribs;
+ uint flat_attribs[PIPE_MAX_SHADER_OUTPUTS];
+
+ /* Mask of attributes in noperspective mode */
+ boolean noperspective_attribs[PIPE_MAX_SHADER_OUTPUTS];
float (*plane)[4];
};
/**
- * Copy front/back, primary/secondary colors from src vertex to dst vertex.
- * Used when flat shading.
+ * Copy flat shaded attributes src vertex to dst vertex.
*/
-static void copy_colors( struct draw_stage *stage,
- struct vertex_header *dst,
- const struct vertex_header *src )
+static void copy_flat( struct draw_stage *stage,
+ struct vertex_header *dst,
+ const struct vertex_header *src )
{
const struct clip_stage *clipper = clip_stage(stage);
uint i;
- for (i = 0; i < clipper->num_color_attribs; i++) {
- const uint attr = clipper->color_attribs[i];
+ for (i = 0; i < clipper->num_flat_attribs; i++) {
+ const uint attr = clipper->flat_attribs[i];
COPY_4FV(dst->data[attr], src->data[attr]);
}
}
{
const unsigned nr_attrs = draw_current_shader_outputs(clip->stage.draw);
const unsigned pos_attr = draw_current_shader_position_output(clip->stage.draw);
+ const unsigned clip_attr = draw_current_shader_clipvertex_output(clip->stage.draw);
unsigned j;
+ float t_nopersp;
/* Vertex header.
*/
dst->clipmask = 0;
dst->edgeflag = 0; /* will get overwritten later */
- dst->pad = 0;
+ dst->have_clipdist = in->have_clipdist;
dst->vertex_id = UNDEFINED_VERTEX_ID;
/* Interpolate the clip-space coords.
*/
interp_attr(dst->clip, t, in->clip, out->clip);
+ /* interpolate the clip-space position */
+ interp_attr(dst->pre_clip_pos, t, in->pre_clip_pos, out->pre_clip_pos);
/* Do the projective divide and viewport transformation to get
* new window coordinates:
*/
{
- const float *pos = dst->clip;
+ const float *pos = dst->pre_clip_pos;
const float *scale = clip->stage.draw->viewport.scale;
const float *trans = clip->stage.draw->viewport.translate;
const float oow = 1.0f / pos[3];
dst->data[pos_attr][2] = pos[2] * oow * scale[2] + trans[2];
dst->data[pos_attr][3] = oow;
}
+
+ /**
+ * Compute the t in screen-space instead of 3d space to use
+ * for noperspective interpolation.
+ *
+ * The points can be aligned with the X axis, so in that case try
+ * the Y. When both points are at the same screen position, we can
+ * pick whatever value (the interpolated point won't be in front
+ * anyway), so just use the 3d t.
+ */
+ {
+ int k;
+ t_nopersp = t;
+ /* find either in.x != out.x or in.y != out.y */
+ for (k = 0; k < 2; k++) {
+ if (in->clip[k] != out->clip[k]) {
+ /* do divide by W, then compute linear interpolation factor */
+ float in_coord = in->clip[k] / in->clip[3];
+ float out_coord = out->clip[k] / out->clip[3];
+ float dst_coord = dst->clip[k] / dst->clip[3];
+ t_nopersp = (dst_coord - out_coord) / (in_coord - out_coord);
+ break;
+ }
+ }
+ }
/* Other attributes
*/
for (j = 0; j < nr_attrs; j++) {
- if (j != pos_attr)
- interp_attr(dst->data[j], t, in->data[j], out->data[j]);
+ if (j != pos_attr && j != clip_attr) {
+ if (clip->noperspective_attribs[j])
+ interp_attr(dst->data[j], t_nopersp, in->data[j], out->data[j]);
+ else
+ interp_attr(dst->data[j], t, in->data[j], out->data[j]);
+ }
}
}
if (i == n - 1 && edgeflags[i])
header.flags |= edge_last;
- if (0) {
+ if (DEBUG_CLIP) {
const struct draw_vertex_shader *vs = stage->draw->vs.vertex_shader;
uint j, k;
debug_printf("Clipped tri: (flat-shade-first = %d)\n",
stage->draw->rasterizer->flatshade_first);
for (j = 0; j < 3; j++) {
+ debug_printf(" Vert %d: clip: %f %f %f %f\n", j,
+ header.v[j]->clip[0],
+ header.v[j]->clip[1],
+ header.v[j]->clip[2],
+ header.v[j]->clip[3]);
for (k = 0; k < vs->info.num_outputs; k++) {
debug_printf(" Vert %d: Attr %d: %f %f %f %f\n", j, k,
header.v[j]->data[k][0],
a[3] * b[3]);
}
+/*
+ * this function extracts the clip distance for the current plane,
+ * it first checks if the shader provided a clip distance, otherwise
+ * it works out the value using the clipvertex
+ */
+static INLINE float getclipdist(const struct clip_stage *clipper,
+ struct vertex_header *vert,
+ int plane_idx)
+{
+ const float *plane;
+ float dp;
+ if (vert->have_clipdist && plane_idx >= 6) {
+ /* pick the correct clipdistance element from the output vectors */
+ int _idx = plane_idx - 6;
+ int cdi = _idx >= 4;
+ int vidx = cdi ? _idx - 4 : _idx;
+ dp = vert->data[draw_current_shader_clipdistance_output(clipper->stage.draw, cdi)][vidx];
+ } else {
+ plane = clipper->plane[plane_idx];
+ dp = dot4(vert->clip, plane);
+ }
+ return dp;
+}
/* Clip a triangle against the viewport and user clip planes.
*/
inlist[1] = header->v[1];
inlist[2] = header->v[2];
+ if (DEBUG_CLIP) {
+ const float *v0 = header->v[0]->clip;
+ const float *v1 = header->v[1]->clip;
+ const float *v2 = header->v[2]->clip;
+ debug_printf("Clip triangle:\n");
+ debug_printf(" %f, %f, %f, %f\n", v0[0], v0[1], v0[2], v0[3]);
+ debug_printf(" %f, %f, %f, %f\n", v1[0], v1[1], v1[2], v1[3]);
+ debug_printf(" %f, %f, %f, %f\n", v2[0], v2[1], v2[2], v2[3]);
+ }
+
/*
* Note: at this point we can't just use the per-vertex edge flags.
* We have to observe the edge flag bits set in header->flags which
while (clipmask && n >= 3) {
const unsigned plane_idx = ffs(clipmask)-1;
const boolean is_user_clip_plane = plane_idx >= 6;
- const float *plane = clipper->plane[plane_idx];
struct vertex_header *vert_prev = inlist[0];
boolean *edge_prev = &inEdges[0];
- float dp_prev = dot4( vert_prev->clip, plane );
+ float dp_prev;
unsigned outcount = 0;
+ dp_prev = getclipdist(clipper, vert_prev, plane_idx);
clipmask &= ~(1<<plane_idx);
assert(n < MAX_CLIPPED_VERTICES);
struct vertex_header *vert = inlist[i];
boolean *edge = &inEdges[i];
- float dp = dot4( vert->clip, plane );
+ float dp = getclipdist(clipper, vert, plane_idx);
if (!IS_NEGATIVE(dp_prev)) {
assert(outcount < MAX_CLIPPED_VERTICES);
/* If flat-shading, copy provoking vertex color to polygon vertex[0]
*/
if (n >= 3) {
- if (clipper->flat) {
+ if (clipper->num_flat_attribs) {
if (stage->draw->rasterizer->flatshade_first) {
if (inlist[0] != header->v[0]) {
assert(tmpnr < MAX_CLIPPED_VERTICES + 1);
if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
return;
inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
- copy_colors(stage, inlist[0], header->v[0]);
+ copy_flat(stage, inlist[0], header->v[0]);
}
}
else {
if (tmpnr >= MAX_CLIPPED_VERTICES + 1)
return;
inlist[0] = dup_vert(stage, inlist[0], tmpnr++);
- copy_colors(stage, inlist[0], header->v[2]);
+ copy_flat(stage, inlist[0], header->v[2]);
}
}
}
const struct clip_stage *clipper = clip_stage( stage );
struct vertex_header *v0 = header->v[0];
struct vertex_header *v1 = header->v[1];
- const float *pos0 = v0->clip;
- const float *pos1 = v1->clip;
float t0 = 0.0F;
float t1 = 0.0F;
struct prim_header newprim;
while (clipmask) {
const unsigned plane_idx = ffs(clipmask)-1;
- const float *plane = clipper->plane[plane_idx];
- const float dp0 = dot4( pos0, plane );
- const float dp1 = dot4( pos1, plane );
+ const float dp0 = getclipdist(clipper, v0, plane_idx);
+ const float dp1 = getclipdist(clipper, v1, plane_idx);
if (dp1 < 0.0F) {
float t = dp1 / (dp1 - dp0);
if (v0->clipmask) {
interp( clipper, stage->tmp[0], t0, v0, v1 );
-
- if (clipper->flat)
- copy_colors(stage, stage->tmp[0], v0);
-
+ copy_flat(stage, stage->tmp[0], v0);
newprim.v[0] = stage->tmp[0];
}
else {
clip_init_state( struct draw_stage *stage )
{
struct clip_stage *clipper = clip_stage( stage );
+ const struct draw_vertex_shader *vs = stage->draw->vs.vertex_shader;
+ const struct draw_geometry_shader *gs = stage->draw->gs.geometry_shader;
+ const struct draw_fragment_shader *fs = stage->draw->fs.fragment_shader;
+ uint i;
+ const struct tgsi_shader_info *vs_info = gs ? &gs->info : &vs->info;
+
+ /* We need to know for each attribute what kind of interpolation is
+ * done on it (flat, smooth or noperspective). But the information
+ * is not directly accessible for outputs, only for inputs. So we
+ * have to match semantic name and index between the VS (or GS/ES)
+ * outputs and the FS inputs to get to the interpolation mode.
+ *
+ * The only hitch is with gl_FrontColor/gl_BackColor which map to
+ * gl_Color, and their Secondary versions. First there are (up to)
+ * two outputs for one input, so we tuck the information in a
+ * specific array. Second if they don't have qualifiers, the
+ * default value has to be picked from the global shade mode.
+ *
+ * Of course, if we don't have a fragment shader in the first
+ * place, defaults should be used.
+ */
- clipper->flat = stage->draw->rasterizer->flatshade ? TRUE : FALSE;
+ /* First pick up the interpolation mode for
+ * gl_Color/gl_SecondaryColor, with the correct default.
+ */
+ int indexed_interp[2];
+ indexed_interp[0] = indexed_interp[1] = stage->draw->rasterizer->flatshade ?
+ TGSI_INTERPOLATE_CONSTANT : TGSI_INTERPOLATE_PERSPECTIVE;
+
+ if (fs) {
+ for (i = 0; i < fs->info.num_inputs; i++) {
+ if (fs->info.input_semantic_name[i] == TGSI_SEMANTIC_COLOR) {
+ if (fs->info.input_interpolate[i] != TGSI_INTERPOLATE_COLOR)
+ indexed_interp[fs->info.input_semantic_index[i]] = fs->info.input_interpolate[i];
+ }
+ }
+ }
- if (clipper->flat) {
- const struct draw_vertex_shader *vs = stage->draw->vs.vertex_shader;
- uint i;
+ /* Then resolve the interpolation mode for every output attribute.
+ *
+ * Given how the rest of the code, the most efficient way is to
+ * have a vector of flat-mode attributes, and a mask for
+ * noperspective attributes.
+ */
- clipper->num_color_attribs = 0;
- for (i = 0; i < vs->info.num_outputs; i++) {
- if (vs->info.output_semantic_name[i] == TGSI_SEMANTIC_COLOR ||
- vs->info.output_semantic_name[i] == TGSI_SEMANTIC_BCOLOR) {
- clipper->color_attribs[clipper->num_color_attribs++] = i;
- }
+ clipper->num_flat_attribs = 0;
+ memset(clipper->noperspective_attribs, 0, sizeof(clipper->noperspective_attribs));
+ for (i = 0; i < vs_info->num_outputs; i++) {
+ /* Find the interpolation mode for a specific attribute
+ */
+ int interp;
+
+ /* If it's gl_{Front,Back}{,Secondary}Color, pick up the mode
+ * from the array we've filled before. */
+ if (vs_info->output_semantic_name[i] == TGSI_SEMANTIC_COLOR ||
+ vs_info->output_semantic_name[i] == TGSI_SEMANTIC_BCOLOR) {
+ interp = indexed_interp[vs_info->output_semantic_index[i]];
+ } else {
+ /* Otherwise, search in the FS inputs, with a decent default
+ * if we don't find it.
+ */
+ uint j;
+ interp = TGSI_INTERPOLATE_PERSPECTIVE;
+ if (fs) {
+ for (j = 0; j < fs->info.num_inputs; j++) {
+ if (vs_info->output_semantic_name[i] == fs->info.input_semantic_name[j] &&
+ vs_info->output_semantic_index[i] == fs->info.input_semantic_index[j]) {
+ interp = fs->info.input_interpolate[j];
+ break;
+ }
+ }
+ }
}
+
+ /* If it's flat, add it to the flat vector. Otherwise update
+ * the noperspective mask.
+ */
+ if (interp == TGSI_INTERPOLATE_CONSTANT) {
+ clipper->flat_attribs[clipper->num_flat_attribs] = i;
+ clipper->num_flat_attribs++;
+ } else
+ clipper->noperspective_attribs[i] = interp == TGSI_INTERPOLATE_LINEAR;
}
stage->tri = clip_tri;
projects / mesa.git / blobdiff