static boolean
try_setup_line( struct lp_setup_context *setup,
const float (*v1)[4],
const float (*v2)[4])
{
struct llvmpipe_context *lp_context = (struct llvmpipe_context *)setup->pipe;
struct lp_scene *scene = setup->scene;
const struct lp_setup_variant_key *key = &setup->setup.variant->key;
struct lp_rast_triangle *line;
struct lp_rast_plane *plane;
struct lp_line_info info;
float width = MAX2(1.0, setup->line_width);
const struct u_rect *scissor;
struct u_rect bbox, bboxpos;
boolean s_planes[4];
unsigned tri_bytes;
int x[4];
int y[4];
int i;
int nr_planes = 4;
unsigned viewport_index = 0;
unsigned layer = 0;
/* linewidth should be interpreted as integer */
int fixed_width = util_iround(width) * FIXED_ONE;
float x_offset=0;
float y_offset=0;
float x_offset_end=0;
float y_offset_end=0;
float x1diff;
float y1diff;
float x2diff;
float y2diff;
float dx, dy;
float area;
const float (*pv)[4];
boolean draw_start;
boolean draw_end;
boolean will_draw_start;
boolean will_draw_end;
if (0)
print_line(setup, v1, v2);
if (setup->flatshade_first) {
pv = v1;
}
else {
pv = v2;
}
if (setup->viewport_index_slot > 0) {
unsigned *udata = (unsigned*)pv[setup->viewport_index_slot];
viewport_index = lp_clamp_viewport_idx(*udata);
}
if (setup->layer_slot > 0) {
layer = *(unsigned*)pv[setup->layer_slot];
layer = MIN2(layer, scene->fb_max_layer);
}
dx = v1[0][0] - v2[0][0];
dy = v1[0][1] - v2[0][1];
area = (dx * dx + dy * dy);
if (area == 0) {
LP_COUNT(nr_culled_tris);
return TRUE;
}
info.oneoverarea = 1.0f / area;
info.dx = dx;
info.dy = dy;
info.v1 = v1;
info.v2 = v2;
/* X-MAJOR LINE */
if (fabsf(dx) >= fabsf(dy)) {
float dydx = dy / dx;
x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5;
y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5;
x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5;
y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5;
if (y2diff==-0.5 && dy<0){
y2diff = 0.5;
}
/*
* Diamond exit rule test for starting point
*/
if (fabsf(x1diff) + fabsf(y1diff) < 0.5) {
draw_start = TRUE;
}
else if (sign(x1diff) == sign(-dx)) {
draw_start = FALSE;
}
else if (sign(-y1diff) != sign(dy)) {
draw_start = TRUE;
}
else {
/* do intersection test */
float yintersect = fracf(v1[0][1]) + x1diff * dydx;
draw_start = (yintersect < 1.0 && yintersect > 0.0);
}
/*
* Diamond exit rule test for ending point
*/
if (fabsf(x2diff) + fabsf(y2diff) < 0.5) {
draw_end = FALSE;
}
else if (sign(x2diff) != sign(-dx)) {
draw_end = FALSE;
}
else if (sign(-y2diff) == sign(dy)) {
draw_end = TRUE;
}
else {
/* do intersection test */
float yintersect = fracf(v2[0][1]) + x2diff * dydx;
draw_end = (yintersect < 1.0 && yintersect > 0.0);
}
/* Are we already drawing start/end?
*/
will_draw_start = sign(-x1diff) != sign(dx);
will_draw_end = (sign(x2diff) == sign(-dx)) || x2diff==0;
if (dx < 0) {
/* if v2 is to the right of v1, swap pointers */
const float (*temp)[4] = v1;
v1 = v2;
v2 = temp;
dx = -dx;
dy = -dy;
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
x_offset_end = - x1diff - 0.5;
y_offset_end = x_offset_end * dydx;
}
if (will_draw_end != draw_end) {
x_offset = - x2diff - 0.5;
y_offset = x_offset * dydx;
}
}
else{
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
x_offset = - x1diff + 0.5;
y_offset = x_offset * dydx;
}
if (will_draw_end != draw_end) {
x_offset_end = - x2diff + 0.5;
y_offset_end = x_offset_end * dydx;
}
}
/* x/y positions in fixed point */
x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset);
x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset);
x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset);
x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset);
y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) - fixed_width/2;
y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) - fixed_width/2;
y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) + fixed_width/2;
y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) + fixed_width/2;
}
else {
const float dxdy = dx / dy;
/* Y-MAJOR LINE */
x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5;
y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5;
x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5;
y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5;
if (x2diff==-0.5 && dx<0) {
x2diff = 0.5;
}
/*
* Diamond exit rule test for starting point
*/
if (fabsf(x1diff) + fabsf(y1diff) < 0.5) {
draw_start = TRUE;
}
else if (sign(-y1diff) == sign(dy)) {
draw_start = FALSE;
}
else if (sign(x1diff) != sign(-dx)) {
draw_start = TRUE;
}
else {
/* do intersection test */
float xintersect = fracf(v1[0][0]) + y1diff * dxdy;
draw_start = (xintersect < 1.0 && xintersect > 0.0);
}
/*
* Diamond exit rule test for ending point
*/
if (fabsf(x2diff) + fabsf(y2diff) < 0.5) {
draw_end = FALSE;
}
else if (sign(-y2diff) != sign(dy) ) {
draw_end = FALSE;
}
else if (sign(x2diff) == sign(-dx) ) {
draw_end = TRUE;
}
else {
/* do intersection test */
float xintersect = fracf(v2[0][0]) + y2diff * dxdy;
draw_end = (xintersect < 1.0 && xintersect >= 0.0);
}
/* Are we already drawing start/end?
*/
will_draw_start = sign(y1diff) == sign(dy);
will_draw_end = (sign(-y2diff) == sign(dy)) || y2diff==0;
if (dy > 0) {
/* if v2 is on top of v1, swap pointers */
const float (*temp)[4] = v1;
v1 = v2;
v2 = temp;
dx = -dx;
dy = -dy;
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
y_offset_end = - y1diff + 0.5;
x_offset_end = y_offset_end * dxdy;
}
if (will_draw_end != draw_end) {
y_offset = - y2diff + 0.5;
x_offset = y_offset * dxdy;
}
}
else {
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
y_offset = - y1diff - 0.5;
x_offset = y_offset * dxdy;
}
if (will_draw_end != draw_end) {
y_offset_end = - y2diff - 0.5;
x_offset_end = y_offset_end * dxdy;
}
}
/* x/y positions in fixed point */
x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) - fixed_width/2;
x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) - fixed_width/2;
x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) + fixed_width/2;
x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) + fixed_width/2;
y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset);
y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset);
y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset);
y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset);
}
/* Bounding rectangle (in pixels) */
{
/* Yes this is necessary to accurately calculate bounding boxes
* with the two fill-conventions we support. GL (normally) ends
* up needing a bottom-left fill convention, which requires
* slightly different rounding.
*/
int adj = (setup->bottom_edge_rule != 0) ? 1 : 0;
bbox.x0 = (MIN4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER;
bbox.x1 = (MAX4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER;
bbox.y0 = (MIN4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER;
bbox.y1 = (MAX4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER;
/* Inclusive coordinates:
*/
bbox.x1--;
bbox.y1--;
}
if (bbox.x1 < bbox.x0 ||
bbox.y1 < bbox.y0) {
if (0) debug_printf("empty bounding box\n");
LP_COUNT(nr_culled_tris);
return TRUE;
}
if (!u_rect_test_intersection(&setup->draw_regions[viewport_index], &bbox)) {
if (0) debug_printf("offscreen\n");
LP_COUNT(nr_culled_tris);
return TRUE;
}
bboxpos = bbox;
/* Can safely discard negative regions:
*/
bboxpos.x0 = MAX2(bboxpos.x0, 0);
bboxpos.y0 = MAX2(bboxpos.y0, 0);
nr_planes = 4;
/*
* Determine how many scissor planes we need, that is drop scissor
* edges if the bounding box of the tri is fully inside that edge.
*/
if (setup->scissor_test) {
/* why not just use draw_regions */
scissor = &setup->scissors[viewport_index];
scissor_planes_needed(s_planes, &bboxpos, scissor);
nr_planes += s_planes[0] + s_planes[1] + s_planes[2] + s_planes[3];
}
line = lp_setup_alloc_triangle(scene,
key->num_inputs,
nr_planes,
&tri_bytes);
if (!line)
return FALSE;
#ifdef DEBUG
line->v[0][0] = v1[0][0];
line->v[1][0] = v2[0][0];
line->v[0][1] = v1[0][1];
line->v[1][1] = v2[0][1];
#endif
LP_COUNT(nr_tris);
if (lp_context->active_statistics_queries &&
!llvmpipe_rasterization_disabled(lp_context)) {
lp_context->pipeline_statistics.c_primitives++;
}
/* calculate the deltas */
plane = GET_PLANES(line);
plane[0].dcdy = x[0] - x[1];
plane[1].dcdy = x[1] - x[2];
plane[2].dcdy = x[2] - x[3];
plane[3].dcdy = x[3] - x[0];
plane[0].dcdx = y[0] - y[1];
plane[1].dcdx = y[1] - y[2];
plane[2].dcdx = y[2] - y[3];
plane[3].dcdx = y[3] - y[0];
if (draw_will_inject_frontface(lp_context->draw) &&
setup->face_slot > 0) {
line->inputs.frontfacing = v1[setup->face_slot][0];
} else {
line->inputs.frontfacing = TRUE;
}
/* Setup parameter interpolants:
*/
info.a0 = GET_A0(&line->inputs);
info.dadx = GET_DADX(&line->inputs);
info.dady = GET_DADY(&line->inputs);
info.frontfacing = line->inputs.frontfacing;
setup_line_coefficients(setup, &info);
line->inputs.disable = FALSE;
line->inputs.opaque = FALSE;
line->inputs.layer = layer;
line->inputs.viewport_index = viewport_index;
/*
* XXX: this code is mostly identical to the one in lp_setup_tri, except it
* uses 4 planes instead of 3. Could share the code (including the sse
* assembly, in fact we'd get the 4th plane for free).
* The only difference apart from storing the 4th plane would be some
* different shuffle for calculating dcdx/dcdy.
*/
for (i = 0; i < 4; i++) {
/* half-edge constants, will be iterated over the whole render
* target.
*/
plane[i].c = IMUL64(plane[i].dcdx, x[i]) - IMUL64(plane[i].dcdy, y[i]);
/* correct for top-left vs. bottom-left fill convention.
*/
if (plane[i].dcdx < 0) {
/* both fill conventions want this - adjust for left edges */
plane[i].c++;
}
else if (plane[i].dcdx == 0) {
if (setup->pixel_offset == 0) {
/* correct for top-left fill convention:
*/
if (plane[i].dcdy > 0) plane[i].c++;
}
else {
/* correct for bottom-left fill convention:
*/
if (plane[i].dcdy < 0) plane[i].c++;
}
}
plane[i].dcdx *= FIXED_ONE;
plane[i].dcdy *= FIXED_ONE;
/* find trivial reject offsets for each edge for a single-pixel
* sized block. These will be scaled up at each recursive level to
* match the active blocksize. Scaling in this way works best if
* the blocks are square.
*/
plane[i].eo = 0;
if (plane[i].dcdx < 0) plane[i].eo -= plane[i].dcdx;
if (plane[i].dcdy > 0) plane[i].eo += plane[i].dcdy;
}
/*
* When rasterizing scissored tris, use the intersection of the
* triangle bounding box and the scissor rect to generate the
* scissor planes.
*
* This permits us to cut off the triangle "tails" that are present
* in the intermediate recursive levels caused when two of the
* triangles edges don't diverge quickly enough to trivially reject
* exterior blocks from the triangle.
*
* It's not really clear if it's worth worrying about these tails,
* but since we generate the planes for each scissored tri, it's
* free to trim them in this case.
*
* Note that otherwise, the scissor planes only vary in 'C' value,
* and even then only on state-changes. Could alternatively store
* these planes elsewhere.
* (Or only store the c value together with a bit indicating which
* scissor edge this is, so rasterization would treat them differently
* (easier to evaluate) to ordinary planes.)
*/
if (nr_planes > 4) {
struct lp_rast_plane *plane_s = &plane[4];
if (s_planes[0]) {
plane_s->dcdx = -1 << 8;
plane_s->dcdy = 0;
plane_s->c = (1-scissor->x0) << 8;
plane_s->eo = 1 << 8;
plane_s++;
}
if (s_planes[1]) {
plane_s->dcdx = 1 << 8;
plane_s->dcdy = 0;
plane_s->c = (scissor->x1+1) << 8;
plane_s->eo = 0 << 8;
plane_s++;
}
if (s_planes[2]) {
plane_s->dcdx = 0;
plane_s->dcdy = 1 << 8;
plane_s->c = (1-scissor->y0) << 8;
plane_s->eo = 1 << 8;
plane_s++;
}
if (s_planes[3]) {
plane_s->dcdx = 0;
plane_s->dcdy = -1 << 8;
plane_s->c = (scissor->y1+1) << 8;
plane_s->eo = 0;
plane_s++;
}
assert(plane_s == &plane[nr_planes]);
}
return lp_setup_bin_triangle(setup, line, &bbox, &bboxpos, nr_planes, viewport_index);
}
static inline int subpixel_snap( float a )
{
return util_iround(FIXED_ONE * a);
}
static boolean
try_setup_line( struct lp_setup_context *setup,
const float (*v1)[4],
const float (*v2)[4])
{
struct lp_scene *scene = setup->scene;
const struct lp_setup_variant_key *key = &setup->setup.variant->key;
struct lp_rast_triangle *line;
struct lp_rast_plane *plane;
struct lp_line_info info;
float width = MAX2(1.0, setup->line_width);
struct u_rect bbox;
unsigned tri_bytes;
int x[4];
int y[4];
int i;
int nr_planes = 4;
/* linewidth should be interpreted as integer */
int fixed_width = util_iround(width) * FIXED_ONE;
float x_offset=0;
float y_offset=0;
float x_offset_end=0;
float y_offset_end=0;
float x1diff;
float y1diff;
float x2diff;
float y2diff;
float dx, dy;
float area;
boolean draw_start;
boolean draw_end;
boolean will_draw_start;
boolean will_draw_end;
if (0)
print_line(setup, v1, v2);
if (setup->scissor_test) {
nr_planes = 8;
}
else {
nr_planes = 4;
}
dx = v1[0][0] - v2[0][0];
dy = v1[0][1] - v2[0][1];
area = (dx * dx + dy * dy);
if (area == 0) {
LP_COUNT(nr_culled_tris);
return TRUE;
}
info.oneoverarea = 1.0f / area;
info.dx = dx;
info.dy = dy;
info.v1 = v1;
info.v2 = v2;
/* X-MAJOR LINE */
if (fabsf(dx) >= fabsf(dy)) {
float dydx = dy / dx;
x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5;
y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5;
x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5;
y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5;
if (y2diff==-0.5 && dy<0){
y2diff = 0.5;
}
/*
* Diamond exit rule test for starting point
*/
if (fabsf(x1diff) + fabsf(y1diff) < 0.5) {
draw_start = TRUE;
}
else if (sign(x1diff) == sign(-dx)) {
draw_start = FALSE;
}
else if (sign(-y1diff) != sign(dy)) {
draw_start = TRUE;
}
else {
/* do intersection test */
float yintersect = fracf(v1[0][1]) + x1diff * dydx;
draw_start = (yintersect < 1.0 && yintersect > 0.0);
}
/*
* Diamond exit rule test for ending point
*/
if (fabsf(x2diff) + fabsf(y2diff) < 0.5) {
draw_end = FALSE;
}
else if (sign(x2diff) != sign(-dx)) {
draw_end = FALSE;
}
else if (sign(-y2diff) == sign(dy)) {
draw_end = TRUE;
}
else {
/* do intersection test */
float yintersect = fracf(v2[0][1]) + x2diff * dydx;
draw_end = (yintersect < 1.0 && yintersect > 0.0);
}
/* Are we already drawing start/end?
*/
will_draw_start = sign(-x1diff) != sign(dx);
will_draw_end = (sign(x2diff) == sign(-dx)) || x2diff==0;
if (dx < 0) {
/* if v2 is to the right of v1, swap pointers */
const float (*temp)[4] = v1;
v1 = v2;
v2 = temp;
dx = -dx;
dy = -dy;
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
x_offset_end = - x1diff - 0.5;
y_offset_end = x_offset_end * dydx;
}
if (will_draw_end != draw_end) {
x_offset = - x2diff - 0.5;
y_offset = x_offset * dydx;
}
}
else{
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
x_offset = - x1diff + 0.5;
y_offset = x_offset * dydx;
}
if (will_draw_end != draw_end) {
x_offset_end = - x2diff + 0.5;
y_offset_end = x_offset_end * dydx;
}
}
/* x/y positions in fixed point */
x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset);
x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset);
x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset);
x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset);
y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) - fixed_width/2;
y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) - fixed_width/2;
y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset) + fixed_width/2;
y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset) + fixed_width/2;
}
else {
const float dxdy = dx / dy;
/* Y-MAJOR LINE */
x1diff = v1[0][0] - (float) floor(v1[0][0]) - 0.5;
y1diff = v1[0][1] - (float) floor(v1[0][1]) - 0.5;
x2diff = v2[0][0] - (float) floor(v2[0][0]) - 0.5;
y2diff = v2[0][1] - (float) floor(v2[0][1]) - 0.5;
if (x2diff==-0.5 && dx<0) {
x2diff = 0.5;
}
/*
* Diamond exit rule test for starting point
*/
if (fabsf(x1diff) + fabsf(y1diff) < 0.5) {
draw_start = TRUE;
}
else if (sign(-y1diff) == sign(dy)) {
draw_start = FALSE;
}
else if (sign(x1diff) != sign(-dx)) {
draw_start = TRUE;
}
else {
/* do intersection test */
float xintersect = fracf(v1[0][0]) + y1diff * dxdy;
draw_start = (xintersect < 1.0 && xintersect > 0.0);
}
/*
* Diamond exit rule test for ending point
*/
if (fabsf(x2diff) + fabsf(y2diff) < 0.5) {
draw_end = FALSE;
}
else if (sign(-y2diff) != sign(dy) ) {
draw_end = FALSE;
}
else if (sign(x2diff) == sign(-dx) ) {
draw_end = TRUE;
}
else {
/* do intersection test */
float xintersect = fracf(v2[0][0]) + y2diff * dxdy;
draw_end = (xintersect < 1.0 && xintersect >= 0.0);
}
/* Are we already drawing start/end?
*/
will_draw_start = sign(y1diff) == sign(dy);
will_draw_end = (sign(-y2diff) == sign(dy)) || y2diff==0;
if (dy > 0) {
/* if v2 is on top of v1, swap pointers */
const float (*temp)[4] = v1;
v1 = v2;
v2 = temp;
dx = -dx;
dy = -dy;
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
y_offset_end = - y1diff + 0.5;
x_offset_end = y_offset_end * dxdy;
}
if (will_draw_end != draw_end) {
y_offset = - y2diff + 0.5;
x_offset = y_offset * dxdy;
}
}
else {
/* Otherwise shift planes appropriately */
if (will_draw_start != draw_start) {
y_offset = - y1diff - 0.5;
x_offset = y_offset * dxdy;
}
if (will_draw_end != draw_end) {
y_offset_end = - y2diff - 0.5;
x_offset_end = y_offset_end * dxdy;
}
}
/* x/y positions in fixed point */
x[0] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) - fixed_width/2;
x[1] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) - fixed_width/2;
x[2] = subpixel_snap(v2[0][0] + x_offset_end - setup->pixel_offset) + fixed_width/2;
x[3] = subpixel_snap(v1[0][0] + x_offset - setup->pixel_offset) + fixed_width/2;
y[0] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset);
y[1] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset);
y[2] = subpixel_snap(v2[0][1] + y_offset_end - setup->pixel_offset);
y[3] = subpixel_snap(v1[0][1] + y_offset - setup->pixel_offset);
}
LP_COUNT(nr_tris);
/* Bounding rectangle (in pixels) */
{
/* Yes this is necessary to accurately calculate bounding boxes
* with the two fill-conventions we support. GL (normally) ends
* up needing a bottom-left fill convention, which requires
* slightly different rounding.
*/
int adj = (setup->pixel_offset != 0) ? 1 : 0;
bbox.x0 = (MIN4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER;
bbox.x1 = (MAX4(x[0], x[1], x[2], x[3]) + (FIXED_ONE-1)) >> FIXED_ORDER;
bbox.y0 = (MIN4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER;
bbox.y1 = (MAX4(y[0], y[1], y[2], y[3]) + (FIXED_ONE-1) + adj) >> FIXED_ORDER;
/* Inclusive coordinates:
*/
bbox.x1--;
bbox.y1--;
}
if (bbox.x1 < bbox.x0 ||
bbox.y1 < bbox.y0) {
if (0) debug_printf("empty bounding box\n");
LP_COUNT(nr_culled_tris);
return TRUE;
}
if (!u_rect_test_intersection(&setup->draw_region, &bbox)) {
if (0) debug_printf("offscreen\n");
LP_COUNT(nr_culled_tris);
return TRUE;
}
/* Can safely discard negative regions:
*/
bbox.x0 = MAX2(bbox.x0, 0);
bbox.y0 = MAX2(bbox.y0, 0);
line = lp_setup_alloc_triangle(scene,
key->num_inputs,
nr_planes,
&tri_bytes);
if (!line)
return FALSE;
#ifdef DEBUG
line->v[0][0] = v1[0][0];
line->v[1][0] = v2[0][0];
line->v[0][1] = v1[0][1];
line->v[1][1] = v2[0][1];
#endif
/* calculate the deltas */
plane = GET_PLANES(line);
plane[0].dcdy = x[0] - x[1];
plane[1].dcdy = x[1] - x[2];
plane[2].dcdy = x[2] - x[3];
plane[3].dcdy = x[3] - x[0];
plane[0].dcdx = y[0] - y[1];
plane[1].dcdx = y[1] - y[2];
plane[2].dcdx = y[2] - y[3];
plane[3].dcdx = y[3] - y[0];
/* Setup parameter interpolants:
*/
info.a0 = GET_A0(&line->inputs);
info.dadx = GET_DADX(&line->inputs);
info.dady = GET_DADY(&line->inputs);
setup_line_coefficients(setup, &info);
line->inputs.frontfacing = TRUE;
line->inputs.disable = FALSE;
line->inputs.opaque = FALSE;
for (i = 0; i < 4; i++) {
/* half-edge constants, will be interated over the whole render
* target.
*/
plane[i].c = plane[i].dcdx * x[i] - plane[i].dcdy * y[i];
/* correct for top-left vs. bottom-left fill convention.
*
* note that we're overloading gl_rasterization_rules to mean
* both (0.5,0.5) pixel centers *and* bottom-left filling
* convention.
*
* GL actually has a top-left filling convention, but GL's
* notion of "top" differs from gallium's...
*
* Also, sometimes (in FBO cases) GL will render upside down
* to its usual method, in which case it will probably want
* to use the opposite, top-left convention.
*/
if (plane[i].dcdx < 0) {
/* both fill conventions want this - adjust for left edges */
plane[i].c++;
}
else if (plane[i].dcdx == 0) {
if (setup->pixel_offset == 0) {
/* correct for top-left fill convention:
*/
if (plane[i].dcdy > 0) plane[i].c++;
}
else {
/* correct for bottom-left fill convention:
*/
if (plane[i].dcdy < 0) plane[i].c++;
}
}
plane[i].dcdx *= FIXED_ONE;
plane[i].dcdy *= FIXED_ONE;
/* find trivial reject offsets for each edge for a single-pixel
* sized block. These will be scaled up at each recursive level to
* match the active blocksize. Scaling in this way works best if
* the blocks are square.
*/
plane[i].eo = 0;
if (plane[i].dcdx < 0) plane[i].eo -= plane[i].dcdx;
if (plane[i].dcdy > 0) plane[i].eo += plane[i].dcdy;
}
/*
* When rasterizing scissored tris, use the intersection of the
* triangle bounding box and the scissor rect to generate the
* scissor planes.
*
* This permits us to cut off the triangle "tails" that are present
* in the intermediate recursive levels caused when two of the
* triangles edges don't diverge quickly enough to trivially reject
* exterior blocks from the triangle.
*
* It's not really clear if it's worth worrying about these tails,
* but since we generate the planes for each scissored tri, it's
* free to trim them in this case.
*
* Note that otherwise, the scissor planes only vary in 'C' value,
* and even then only on state-changes. Could alternatively store
* these planes elsewhere.
*/
if (nr_planes == 8) {
const struct u_rect *scissor = &setup->scissor;
plane[4].dcdx = -1;
plane[4].dcdy = 0;
plane[4].c = 1-scissor->x0;
plane[4].eo = 1;
plane[5].dcdx = 1;
plane[5].dcdy = 0;
plane[5].c = scissor->x1+1;
plane[5].eo = 0;
plane[6].dcdx = 0;
plane[6].dcdy = 1;
plane[6].c = 1-scissor->y0;
plane[6].eo = 1;
plane[7].dcdx = 0;
plane[7].dcdy = -1;
plane[7].c = scissor->y1+1;
plane[7].eo = 0;
}
return lp_setup_bin_triangle(setup, line, &bbox, nr_planes);
}
static INLINE int
subpixel_snap(float a)
{
return util_iround(FIXED_ONE * a);
}
bool radv_format_pack_clear_color(VkFormat format,
uint32_t clear_vals[2],
VkClearColorValue *value)
{
uint8_t r = 0, g = 0, b = 0, a = 0;
const struct vk_format_description *desc = vk_format_description(format);
if (vk_format_get_component_bits(format, VK_FORMAT_COLORSPACE_RGB, 0) <= 8) {
if (desc->colorspace == VK_FORMAT_COLORSPACE_RGB) {
r = float_to_ubyte(value->float32[0]);
g = float_to_ubyte(value->float32[1]);
b = float_to_ubyte(value->float32[2]);
a = float_to_ubyte(value->float32[3]);
} else if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) {
r = util_format_linear_float_to_srgb_8unorm(value->float32[0]);
g = util_format_linear_float_to_srgb_8unorm(value->float32[1]);
b = util_format_linear_float_to_srgb_8unorm(value->float32[2]);
a = float_to_ubyte(value->float32[3]);
}
}
switch (format) {
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_SRGB:
clear_vals[0] = r;
clear_vals[1] = 0;
break;
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8_SRGB:
clear_vals[0] = r | g << 8;
clear_vals[1] = 0;
break;
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_R8G8B8A8_UNORM:
clear_vals[0] = r | g << 8 | b << 16 | a << 24;
clear_vals[1] = 0;
break;
case VK_FORMAT_B8G8R8A8_SRGB:
case VK_FORMAT_B8G8R8A8_UNORM:
clear_vals[0] = b | g << 8 | r << 16 | a << 24;
clear_vals[1] = 0;
break;
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
clear_vals[0] = r | g << 8 | b << 16 | a << 24;
clear_vals[1] = 0;
break;
case VK_FORMAT_R8_UINT:
clear_vals[0] = value->uint32[0] & 0xff;
clear_vals[1] = 0;
break;
case VK_FORMAT_R16_UINT:
clear_vals[0] = value->uint32[0] & 0xffff;
clear_vals[1] = 0;
break;
case VK_FORMAT_R8G8_UINT:
clear_vals[0] = value->uint32[0] & 0xff;
clear_vals[0] |= (value->uint32[1] & 0xff) << 8;
clear_vals[1] = 0;
break;
case VK_FORMAT_R8G8B8A8_UINT:
clear_vals[0] = value->uint32[0] & 0xff;
clear_vals[0] |= (value->uint32[1] & 0xff) << 8;
clear_vals[0] |= (value->uint32[2] & 0xff) << 16;
clear_vals[0] |= (value->uint32[3] & 0xff) << 24;
clear_vals[1] = 0;
break;
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
clear_vals[0] = value->uint32[0] & 0xff;
clear_vals[0] |= (value->uint32[1] & 0xff) << 8;
clear_vals[0] |= (value->uint32[2] & 0xff) << 16;
clear_vals[0] |= (value->uint32[3] & 0xff) << 24;
clear_vals[1] = 0;
break;
case VK_FORMAT_R16G16_UINT:
clear_vals[0] = value->uint32[0] & 0xffff;
clear_vals[0] |= (value->uint32[1] & 0xffff) << 16;
clear_vals[1] = 0;
break;
case VK_FORMAT_R16G16B16A16_UINT:
clear_vals[0] = value->uint32[0] & 0xffff;
clear_vals[0] |= (value->uint32[1] & 0xffff) << 16;
clear_vals[1] = value->uint32[2] & 0xffff;
clear_vals[1] |= (value->uint32[3] & 0xffff) << 16;
break;
case VK_FORMAT_R32_UINT:
clear_vals[0] = value->uint32[0];
clear_vals[1] = 0;
break;
case VK_FORMAT_R32G32_UINT:
clear_vals[0] = value->uint32[0];
clear_vals[1] = value->uint32[1];
break;
case VK_FORMAT_R32_SINT:
clear_vals[0] = value->int32[0];
clear_vals[1] = 0;
break;
case VK_FORMAT_R16_SFLOAT:
clear_vals[0] = util_float_to_half(value->float32[0]);
clear_vals[1] = 0;
break;
case VK_FORMAT_R16G16_SFLOAT:
clear_vals[0] = util_float_to_half(value->float32[0]);
clear_vals[0] |= (uint32_t)util_float_to_half(value->float32[1]) << 16;
clear_vals[1] = 0;
break;
case VK_FORMAT_R16G16B16A16_SFLOAT:
clear_vals[0] = util_float_to_half(value->float32[0]);
clear_vals[0] |= (uint32_t)util_float_to_half(value->float32[1]) << 16;
clear_vals[1] = util_float_to_half(value->float32[2]);
clear_vals[1] |= (uint32_t)util_float_to_half(value->float32[3]) << 16;
break;
case VK_FORMAT_R16_UNORM:
clear_vals[0] = ((uint16_t)util_iround(CLAMP(value->float32[0], 0.0f, 1.0f) * 0xffff)) & 0xffff;
clear_vals[1] = 0;
break;
case VK_FORMAT_R16G16_UNORM:
clear_vals[0] = ((uint16_t)util_iround(CLAMP(value->float32[0], 0.0f, 1.0f) * 0xffff)) & 0xffff;
clear_vals[0] |= ((uint16_t)util_iround(CLAMP(value->float32[1], 0.0f, 1.0f) * 0xffff)) << 16;
clear_vals[1] = 0;
break;
case VK_FORMAT_R16G16B16A16_UNORM:
clear_vals[0] = ((uint16_t)util_iround(CLAMP(value->float32[0], 0.0f, 1.0f) * 0xffff)) & 0xffff;
clear_vals[0] |= ((uint16_t)util_iround(CLAMP(value->float32[1], 0.0f, 1.0f) * 0xffff)) << 16;
clear_vals[1] = ((uint16_t)util_iround(CLAMP(value->float32[2], 0.0f, 1.0f) * 0xffff)) & 0xffff;
clear_vals[1] |= ((uint16_t)util_iround(CLAMP(value->float32[3], 0.0f, 1.0f) * 0xffff)) << 16;
break;
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
/* TODO */
return false;
case VK_FORMAT_R32G32_SFLOAT:
clear_vals[0] = fui(value->float32[0]);
clear_vals[1] = fui(value->float32[1]);
break;
case VK_FORMAT_R32_SFLOAT:
clear_vals[1] = 0;
clear_vals[0] = fui(value->float32[0]);
break;
default:
fprintf(stderr, "failed to fast clear %d\n", format);
return false;
}
return true;
}
