/**************************************************************************
*
* Copyright 2010, VMware Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/*
* Binning code for points
*/
#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
struct point_info {
/* x,y deltas */
int dy01, dy12;
int dx01, dx12;
const float (*v0)[4];
float (*a0)[4];
float (*dadx)[4];
float (*dady)[4];
boolean frontfacing;
};
/**
* Compute a0 for a constant-valued coefficient (GL_FLAT shading).
*/
static void
constant_coef(struct lp_setup_context *setup,
struct point_info *info,
unsigned slot,
const float value,
unsigned i)
{
info->a0[slot][i] = value;
info->dadx[slot][i] = 0.0f;
info->dady[slot][i] = 0.0f;
}
static void
point_persp_coeff(struct lp_setup_context *setup,
const struct point_info *info,
unsigned slot,
unsigned i)
{
/*
* Fragment shader expects pre-multiplied w for LP_INTERP_PERSPECTIVE. A
* better stratergy would be to take the primitive in consideration when
* generating the fragment shader key, and therefore avoid the per-fragment
* perspective divide.
*/
float w0 = info->v0[0][3];
info->a0[slot][i] = info->v0[slot][i]*w0;
info->dadx[slot][i] = 0.0f;
info->dady[slot][i] = 0.0f;
}
/**
* Setup automatic texcoord coefficients (for sprite rendering).
* \param slot the vertex attribute slot to setup
* \param i the attribute channel in [0,3]
* \param sprite_coord_origin one of PIPE_SPRITE_COORD_x
* \param perspective does the shader expects pre-multiplied w, i.e.,
* LP_INTERP_PERSPECTIVE is specified in the shader key
*/
static void
texcoord_coef(struct lp_setup_context *setup,
const struct point_info *info,
unsigned slot,
unsigned i,
unsigned sprite_coord_origin,
boolean perspective)
{
float w0 = info->v0[0][3];
if (i == 0) {
float dadx = FIXED_ONE / (float)info->dx12;
float dady = 0.0f;
float x0 = info->v0[0][0] - setup->pixel_offset;
float y0 = info->v0[0][1] - setup->pixel_offset;
info->dadx[slot][0] = dadx;
info->dady[slot][0] = dady;
info->a0[slot][0] = 0.5 - (dadx * x0 + dady * y0);
if (perspective) {
info->dadx[slot][0] *= w0;
info->dady[slot][0] *= w0;
info->a0[slot][0] *= w0;
}
}
else if (i == 1) {
float dadx = 0.0f;
float dady = FIXED_ONE / (float)info->dx12;
float x0 = info->v0[0][0] - setup->pixel_offset;
float y0 = info->v0[0][1] - setup->pixel_offset;
if (sprite_coord_origin == PIPE_SPRITE_COORD_LOWER_LEFT) {
dady = -dady;
}
info->dadx[slot][1] = dadx;
info->dady[slot][1] = dady;
info->a0[slot][1] = 0.5 - (dadx * x0 + dady * y0);
if (perspective) {
info->dadx[slot][1] *= w0;
info->dady[slot][1] *= w0;
info->a0[slot][1] *= w0;
}
}
else if (i == 2) {
info->a0[slot][2] = 0.0f;
info->dadx[slot][2] = 0.0f;
info->dady[slot][2] = 0.0f;
}
else {
info->a0[slot][3] = perspective ? w0 : 1.0f;
info->dadx[slot][3] = 0.0f;
info->dady[slot][3] = 0.0f;
}
}
/**
* Special coefficient setup for gl_FragCoord.
* X and Y are trivial
* Z and W are copied from position_coef which should have already been computed.
* We could do a bit less work if we'd examine gl_FragCoord's swizzle mask.
*/
static void
setup_point_fragcoord_coef(struct lp_setup_context *setup,
struct point_info *info,
unsigned slot,
unsigned usage_mask)
{
/*X*/
if (usage_mask & TGSI_WRITEMASK_X) {
info->a0[slot][0] = 0.0;
info->dadx[slot][0] = 1.0;
info->dady[slot][0] = 0.0;
}
/*Y*/
if (usage_mask & TGSI_WRITEMASK_Y) {
info->a0[slot][1] = 0.0;
info->dadx[slot][1] = 0.0;
info->dady[slot][1] = 1.0;
}
/*Z*/
if (usage_mask & TGSI_WRITEMASK_Z) {
constant_coef(setup, info, slot, info->v0[0][2], 2);
}
/*W*/
if (usage_mask & TGSI_WRITEMASK_W) {
constant_coef(setup, info, slot, info->v0[0][3], 3);
}
}
/**
* Compute the point->coef[] array dadx, dady, a0 values.
*/
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 < 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 i;
if (perspective & usage_mask) {
fragcoord_usage_mask |= TGSI_WRITEMASK_W;
}
switch (interp) {
case LP_INTERP_POSITION:
/*
* The generated pixel interpolators will pick up the coeffs from
* slot 0, so all need to ensure that the usage mask is covers all
* usages.
*/
fragcoord_usage_mask |= usage_mask;
break;
case LP_INTERP_LINEAR:
/* Sprite tex coords may use linear interpolation someday */
/* fall-through */
case LP_INTERP_PERSPECTIVE:
/* check if the sprite coord flag is set for this attribute.
* If so, set it up so it up so x and y vary from 0 to 1.
*/
if (shader->info.base.input_semantic_name[slot] == TGSI_SEMANTIC_GENERIC) {
unsigned semantic_index = shader->info.base.input_semantic_index[slot];
/* Note that sprite_coord enable is a bitfield of
* PIPE_MAX_SHADER_OUTPUTS bits.
*/
if (semantic_index < PIPE_MAX_SHADER_OUTPUTS &&
(setup->sprite_coord_enable & (1 << semantic_index))) {
for (i = 0; i < NUM_CHANNELS; i++) {
if (usage_mask & (1 << i)) {
texcoord_coef(setup, info, slot + 1, i,
setup->sprite_coord_origin,
perspective);
}
}
break;
}
}
/* fall-through */
case LP_INTERP_CONSTANT:
for (i = 0; i < NUM_CHANNELS; i++) {
if (usage_mask & (1 << i)) {
if (perspective) {
point_persp_coeff(setup, info, slot+1, i);
}
else {
constant_coef(setup, info, slot+1, info->v0[vert_attr][i], i);
}
}
}
break;
case LP_INTERP_FACING:
for (i = 0; i < NUM_CHANNELS; i++)
if (usage_mask & (1 << i))
constant_coef(setup, info, slot+1,
info->frontfacing ? 1.0f : -1.0f, i);
break;
default:
break;
}
}
/* The internal position input is in slot zero:
*/
setup_point_fragcoord_coef(setup, info, 0,
fragcoord_usage_mask);
}
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 struct lp_setup_variant_key *key = &setup->setup.variant->key;
const int sizeAttr = setup->psize;
const float size
= (setup->point_size_per_vertex && sizeAttr > 0) ? v0[sizeAttr][0]
: setup->point_size;
/* 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;
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) */
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.
*/
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)) >> 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 (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_regions[viewport_index], &bbox);
point = lp_setup_alloc_triangle(scene,
key->num_inputs,
nr_planes,
&bytes);
if (!point)
return FALSE;
#ifdef DEBUG
point->v[0][0] = v0[0][0];
point->v[0][1] = v0[0][1];
#endif
LP_COUNT(nr_tris);
if (lp_context->active_statistics_queries &&
!llvmpipe_rasterization_disabled(lp_context)) {
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;
info.dy01 = fixed_width;
info.dy12 = 0;
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.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].dcdy = 0;
plane[0].c = 1-bbox.x0;
plane[0].eo = 1;
plane[1].dcdx = 1;
plane[1].dcdy = 0;
plane[1].c = bbox.x1+1;
plane[1].eo = 0;
plane[2].dcdx = 0;
plane[2].dcdy = 1;
plane[2].c = 1-bbox.y0;
plane[2].eo = 1;
plane[3].dcdx = 0;
plane[3].dcdy = -1;
plane[3].c = bbox.y1+1;
plane[3].eo = 0;
}
return lp_setup_bin_triangle(setup, point, &bbox, nr_planes, viewport_index);
}
static void
lp_setup_point(struct lp_setup_context *setup,
const float (*v0)[4])
{
if (!try_setup_point( setup, v0 ))
{
if (!lp_setup_flush_and_restart(setup))
return;
if (!try_setup_point( setup, v0 ))
return;
}
}
void
lp_setup_choose_point( struct lp_setup_context *setup )
{
setup->point = lp_setup_point;
}