X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_setup_point.c;h=2192789bd4c347ae81159dc3dccf69fa06337cd1;hb=ce785f5ffd7dbed14a3909164e55a975a023ee97;hp=16d21df35e2e550e9df8ca0404ba2cbffee2b60f;hpb=8965f042b327ad8697963e757f4607f4bb13a045;p=mesa.git diff --git a/src/gallium/drivers/llvmpipe/lp_setup_point.c b/src/gallium/drivers/llvmpipe/lp_setup_point.c index 16d21df35e2..2192789bd4c 100644 --- a/src/gallium/drivers/llvmpipe/lp_setup_point.c +++ b/src/gallium/drivers/llvmpipe/lp_setup_point.c @@ -29,13 +29,16 @@ * Binning code for points */ -#include "lp_setup_context.h" #include "util/u_math.h" #include "util/u_memory.h" +#include "lp_setup_context.h" #include "lp_perf.h" #include "lp_rast.h" #include "lp_state_fs.h" +#include "lp_state_setup.h" +#include "lp_context.h" #include "tgsi/tgsi_scan.h" +#include "draw/draw_context.h" #define NUM_CHANNELS 4 @@ -49,6 +52,8 @@ struct point_info { float (*a0)[4]; float (*dadx)[4]; float (*dady)[4]; + + boolean frontfacing; }; @@ -205,17 +210,18 @@ static void setup_point_coefficients( struct lp_setup_context *setup, struct point_info *info) { + const struct lp_setup_variant_key *key = &setup->setup.variant->key; const struct lp_fragment_shader *shader = setup->fs.current.variant->shader; unsigned fragcoord_usage_mask = TGSI_WRITEMASK_XYZ; unsigned slot; /* setup interpolation for all the remaining attributes: */ - for (slot = 0; slot < setup->fs.nr_inputs; slot++) { - enum lp_interp interp = setup->fs.input[slot].interp; + for (slot = 0; slot < key->num_inputs; slot++) { + unsigned vert_attr = key->inputs[slot].src_index; + unsigned usage_mask = key->inputs[slot].usage_mask; + enum lp_interp interp = key->inputs[slot].interp; boolean perspective = !!(interp == LP_INTERP_PERSPECTIVE); - unsigned vert_attr = setup->fs.input[slot].src_index; - unsigned usage_mask = setup->fs.input[slot].usage_mask; unsigned i; if (perspective & usage_mask) { @@ -273,7 +279,8 @@ setup_point_coefficients( struct lp_setup_context *setup, case LP_INTERP_FACING: for (i = 0; i < NUM_CHANNELS; i++) if (usage_mask & (1 << i)) - constant_coef(setup, info, slot+1, 1.0, i); + constant_coef(setup, info, slot+1, + info->frontfacing ? 1.0f : -1.0f, i); break; default: @@ -289,70 +296,156 @@ setup_point_coefficients( struct lp_setup_context *setup, } -static INLINE int +static inline int subpixel_snap(float a) { return util_iround(FIXED_ONE * a); } +/** + * Print point vertex attribs (for debug). + */ +static void +print_point(struct lp_setup_context *setup, + const float (*v0)[4], + const float size) +{ + const struct lp_setup_variant_key *key = &setup->setup.variant->key; + uint i; + + debug_printf("llvmpipe point, width %f\n", size); + for (i = 0; i < 1 + key->num_inputs; i++) { + debug_printf(" v0[%d]: %f %f %f %f\n", i, + v0[i][0], v0[i][1], v0[i][2], v0[i][3]); + } +} + static boolean try_setup_point( struct lp_setup_context *setup, const float (*v0)[4] ) { + struct llvmpipe_context *lp_context = (struct llvmpipe_context *)setup->pipe; /* x/y positions in fixed point */ - const int sizeAttr = setup->psize; + const struct lp_setup_variant_key *key = &setup->setup.variant->key; + const int sizeAttr = setup->psize_slot; const float size = (setup->point_size_per_vertex && sizeAttr > 0) ? v0[sizeAttr][0] : setup->point_size; - - /* Point size as fixed point integer, remove rounding errors - * and gives minimum width for very small points + + /* 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 fixed_width = MAX2(FIXED_ONE, - (subpixel_snap(size) + FIXED_ONE/2 - 1) & ~(FIXED_ONE-1)); + int adj = (setup->bottom_edge_rule != 0) ? 1 : 0; - const int x0 = subpixel_snap(v0[0][0] - setup->pixel_offset) - fixed_width/2; - const int y0 = subpixel_snap(v0[0][1] - setup->pixel_offset) - fixed_width/2; - struct lp_scene *scene = setup->scene; struct lp_rast_triangle *point; unsigned bytes; struct u_rect bbox; unsigned nr_planes = 4; struct point_info info; + unsigned viewport_index = 0; + unsigned layer = 0; + int fixed_width; + + if (setup->viewport_index_slot > 0) { + unsigned *udata = (unsigned*)v0[setup->viewport_index_slot]; + viewport_index = lp_clamp_viewport_idx(*udata); + } + if (setup->layer_slot > 0) { + layer = *(unsigned*)v0[setup->layer_slot]; + layer = MIN2(layer, scene->fb_max_layer); + } + if (0) + print_point(setup, v0, size); /* 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. + if (!lp_context->rasterizer || + lp_context->rasterizer->point_quad_rasterization) { + /* + * Rasterize points as quads. + */ + int x0, y0; + /* Point size as fixed point integer, remove rounding errors + * and gives minimum width for very small points. */ - int adj = (setup->pixel_offset != 0) ? 1 : 0; + fixed_width = MAX2(FIXED_ONE, subpixel_snap(size)); + + x0 = subpixel_snap(v0[0][0] - setup->pixel_offset) - fixed_width/2; + y0 = subpixel_snap(v0[0][1] - setup->pixel_offset) - fixed_width/2; - bbox.x0 = (x0 + (FIXED_ONE-1) + adj) >> FIXED_ORDER; - bbox.x1 = (x0 + fixed_width + (FIXED_ONE-1) + adj) >> FIXED_ORDER; - bbox.y0 = (y0 + (FIXED_ONE-1)) >> FIXED_ORDER; - bbox.y1 = (y0 + fixed_width + (FIXED_ONE-1)) >> FIXED_ORDER; + bbox.x0 = (x0 + (FIXED_ONE-1)) >> FIXED_ORDER; + bbox.x1 = (x0 + fixed_width + (FIXED_ONE-1)) >> FIXED_ORDER; + bbox.y0 = (y0 + (FIXED_ONE-1) + adj) >> FIXED_ORDER; + bbox.y1 = (y0 + fixed_width + (FIXED_ONE-1) + adj) >> FIXED_ORDER; /* Inclusive coordinates: */ bbox.x1--; bbox.y1--; + } else { + /* + * OpenGL legacy rasterization rules for non-sprite points. + * + * Per OpenGL 2.1 spec, section 3.3.1, "Basic Point Rasterization". + * + * This type of point rasterization is only available in pre 3.0 contexts + * (or compatibilility contexts which we don't support) anyway. + */ + + const int x0 = subpixel_snap(v0[0][0]); + const int y0 = subpixel_snap(v0[0][1]) - adj; + + int int_width; + /* Point size as fixed point integer. For GL legacy points + * the point size is always a whole integer. + */ + fixed_width = MAX2(FIXED_ONE, + (subpixel_snap(size) + FIXED_ONE/2 - 1) & ~(FIXED_ONE-1)); + int_width = fixed_width >> FIXED_ORDER; + + assert(setup->pixel_offset != 0); + + if (int_width == 1) { + bbox.x0 = x0 >> FIXED_ORDER; + bbox.y0 = y0 >> FIXED_ORDER; + bbox.x1 = bbox.x0; + bbox.y1 = bbox.y0; + } else { + if (int_width & 1) { + /* Odd width */ + bbox.x0 = (x0 >> FIXED_ORDER) - (int_width - 1)/2; + bbox.y0 = (y0 >> FIXED_ORDER) - (int_width - 1)/2; + } else { + /* Even width */ + bbox.x0 = ((x0 + FIXED_ONE/2) >> FIXED_ORDER) - int_width/2; + bbox.y0 = ((y0 + FIXED_ONE/2) >> FIXED_ORDER) - int_width/2; + } + + bbox.x1 = bbox.x0 + int_width - 1; + bbox.y1 = bbox.y0 + int_width - 1; + } } - - if (!u_rect_test_intersection(&setup->draw_region, &bbox)) { + + if (0) { + debug_printf(" bbox: (%i, %i) - (%i, %i)\n", + bbox.x0, bbox.y0, + bbox.x1, bbox.y1); + } + + if (!u_rect_test_intersection(&setup->draw_regions[viewport_index], &bbox)) { if (0) debug_printf("offscreen\n"); LP_COUNT(nr_culled_tris); return TRUE; } - u_rect_find_intersection(&setup->draw_region, &bbox); + u_rect_find_intersection(&setup->draw_regions[viewport_index], &bbox); point = lp_setup_alloc_triangle(scene, - setup->fs.nr_inputs, + key->num_inputs, nr_planes, &bytes); if (!point) @@ -363,6 +456,19 @@ try_setup_point( struct lp_setup_context *setup, point->v[0][1] = v0[0][1]; #endif + LP_COUNT(nr_tris); + + if (lp_context->active_statistics_queries) { + lp_context->pipeline_statistics.c_primitives++; + } + + if (draw_will_inject_frontface(lp_context->draw) && + setup->face_slot > 0) { + point->inputs.frontfacing = v0[setup->face_slot][0]; + } else { + point->inputs.frontfacing = TRUE; + } + info.v0 = v0; info.dx01 = 0; info.dx12 = fixed_width; @@ -371,62 +477,73 @@ try_setup_point( struct lp_setup_context *setup, info.a0 = GET_A0(&point->inputs); info.dadx = GET_DADX(&point->inputs); info.dady = GET_DADY(&point->inputs); + info.frontfacing = point->inputs.frontfacing; /* Setup parameter interpolants: */ setup_point_coefficients(setup, &info); - point->inputs.frontfacing = TRUE; point->inputs.disable = FALSE; point->inputs.opaque = FALSE; + point->inputs.layer = layer; + point->inputs.viewport_index = viewport_index; { struct lp_rast_plane *plane = GET_PLANES(point); - plane[0].dcdx = -1; + plane[0].dcdx = -1 << 8; plane[0].dcdy = 0; - plane[0].c = 1-bbox.x0; - plane[0].eo = 1; + plane[0].c = (1-bbox.x0) << 8; + plane[0].eo = 1 << 8; - plane[1].dcdx = 1; + plane[1].dcdx = 1 << 8; plane[1].dcdy = 0; - plane[1].c = bbox.x1+1; + plane[1].c = (bbox.x1+1) << 8; plane[1].eo = 0; plane[2].dcdx = 0; - plane[2].dcdy = 1; - plane[2].c = 1-bbox.y0; - plane[2].eo = 1; + plane[2].dcdy = 1 << 8; + plane[2].c = (1-bbox.y0) << 8; + plane[2].eo = 1 << 8; plane[3].dcdx = 0; - plane[3].dcdy = -1; - plane[3].c = bbox.y1+1; + plane[3].dcdy = -1 << 8; + plane[3].c = (bbox.y1+1) << 8; plane[3].eo = 0; } - return lp_setup_bin_triangle(setup, point, &bbox, nr_planes); + return lp_setup_bin_triangle(setup, point, &bbox, &bbox, nr_planes, viewport_index); } static void +lp_setup_point_discard(struct lp_setup_context *setup, + const float (*v0)[4]) +{ +} + +static void lp_setup_point(struct lp_setup_context *setup, const float (*v0)[4]) { - if (!try_setup_point( setup, v0 )) - { + if (!try_setup_point(setup, v0)) { if (!lp_setup_flush_and_restart(setup)) return; - if (!try_setup_point( setup, v0 )) + if (!try_setup_point(setup, v0)) return; } } void -lp_setup_choose_point( struct lp_setup_context *setup ) +lp_setup_choose_point(struct lp_setup_context *setup) { - setup->point = lp_setup_point; + if (setup->rasterizer_discard) { + setup->point = lp_setup_point_discard; + } else { + setup->point = lp_setup_point; + } }