|
|
///////////////////////////////////////////////////////////////////////////////
// Copyright (C) Microsoft Corporation, 1998.
//
// cvgmask.cpp
//
// Direct3D Reference Rasterizer - Antialiasing Coverage Mask Generation
//
///////////////////////////////////////////////////////////////////////////////
#include "pch.cpp"
#pragma hdrstop
#if 0
// from edgefunc.hpp
// Normalization factor for antialising is stored in floating point. This is
// computed during the setup and applied per-pixel after the (non-normalized)
// edge distance is evaluated.
//
DOUBLE m_dNorm; INT16 m_iEdgeYGradBits; // 1.8 fixed point
// from edgefunc.cpp ::Set
if ( bFragProcEnable ) { // compute normalization factor for antialiasing - normalizes for 'square'
// distance (a.k.a 'manhatten' distance) such that an equidistant point
// sweep of a distance of 0.5 is a square 1.0 pixel area.
m_dNorm = 1.0 / ( fabs( fY0-fY1 ) + fabs( fX1-fX0 ) );
// compute rounded fixed point Y gradient bits for generation of
// antialiasing coverage mask
m_iEdgeYGradBits = AS_INT16( ((fY0-fY1)*m_dNorm) + DOUBLE_8_SNAP ); }
// from ::AATest
// The edge evaluation is done exactly the same as the point sample case, then
// it is converted to double precision floating point for the normalization and
// rounding. Using doubles makes it very easy to carry adequate precision in
// the normalization factor and to convert to 32 bit signed integer (holding
// the n.5 fixed point distance) with round to nearest even.
//
// evaluate edge distance function (n.8 fixed point)
INT64 iEdgeDist = ( (INT64)m_iA * (INT64)(iX<<4) ) + // n.4 * n.4 = n.8
( (INT64)m_iB * (INT64)(iY<<4) ) + // n.4 * n.4 = n.8
(INT64)m_iC; // n.8
// convert to double (adjust for n.8 fixed point) for normalization
// and rounding
DOUBLE dEdgeDist = (DOUBLE)iEdgeDist * (1./(DOUBLE)(1<<8));
// normalize edge distance
dEdgeDist *= m_dNorm;
// convert distance to fixed point with nearest-even round;
// keep 5 fractional bits for antialiasing
INT32 iEdgeDistRnd = AS_INT32( dEdgeDist + DOUBLE_5_SNAP );
// pixel is fully outside of edge if out by +.5 or more
if ( iEdgeDistRnd >= +(1<<4) ) return 0x0000;
// pixel is fully inside of edge if in by -.5 or more
if ( iEdgeDistRnd <= -(1<<4) ) return 0xFFFF;
// here when pixel is within 1/2 (square distance) of edge
// compute coverage mask for this edge
return ComputeCoverageMask( m_iEdgeYGradBits, m_bAPos, m_bBPos, iEdgeDistRnd );
#endif
//-----------------------------------------------------------------------------
//
// Tables used in computation of coverage mask
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// These are the ranges of the x gradient (the 'A' of F=Ax+By+c) for one
// octant into which the edge slopes are binned.
//-----------------------------------------------------------------------------
#define A_RANGES 4
static UINT16 uARanges[A_RANGES] = { // 0.0.8 values
0x00, // 0.00
0x40, // 0.25
0x55, // 0.33
0x66, // 0.40
};
//-----------------------------------------------------------------------------
// These are the 16 bit coverage masks for each of the A ranges. The
// 15 values within each range define the order in which the coverage
// mask bits are enabled, thus the least-significant index is the number
// of coverage mask bits that need to be enabled.
//-----------------------------------------------------------------------------
static UINT16 CvgMasks[A_RANGES][15] = { { // 0.000 .. 0.250
0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, }, { // 0.250 .. 0.333
0x1, 0x3, 0x7, 0x17, 0x1F, 0x3F, 0x7F, 0x17F, 0x1FF, 0x3FF, 0x7FF, 0x17FF, 0x1FFF, 0x3FFF, 0x7FFF, }, { // 0.333 .. 0.400
0x1, 0x3, 0x13, 0x17, 0x37, 0x3F, 0x13F, 0x17F, 0x37F, 0x3FF, 0x13FF, 0x17FF, 0x37FF, 0x3FFF, 0x7FFF, }, { // 0.400 .. 0.500
0x1, 0x3, 0x13, 0x17, 0x37, 0x137, 0x13F, 0x17F, 0x37F, 0x137F, 0x13FF, 0x17FF, 0x37FF, 0x3FFF, 0x7FFF, },};
//-----------------------------------------------------------------------------
// This table is used for a rough area approximation. The [16] index
// is the top 4 bits of the edge distance (i.e. the distance from the
// edge to the center of the pixel). The [4] index is the top two bits
// of the A gradient term. The return is the number of bits that should
// be set in the coverage mask, which is a function of the area covered.
//-----------------------------------------------------------------------------
static INT16 nBitsA = 2;static INT16 nBitsE = 4;static INT16 nBitsToEnable[4][16] = { { // A: 0.000; B: 1.000
8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, }, { // A: 0.125; B: 0.875
8, 9, 9, 10, 10, 11, 11, 12, 13, 13, 14, 14, 15, 15, 16, 16, }, { // A: 0.250; B: 0.750
8, 9, 9, 10, 11, 11, 12, 13, 13, 14, 15, 15, 15, 16, 16, 16, }, { // A: 0.375; B: 0.625
8, 9, 10, 10, 11, 12, 13, 13, 14, 14, 15, 15, 15, 16, 16, 16, },};
//-----------------------------------------------------------------------------
//
// Mask manipulation functions - these are needed because coverage mask
// table (indexed by angle) is for one octant only and need to be
// munged in various ways for other octants
//
//-----------------------------------------------------------------------------
static voiddoCvgMaskTBFlip(UINT16 &CvgMask){ UINT16 CvgMaskT = CvgMask; CvgMask = 0; CvgMask |= (((CvgMaskT >> 0) & 0x1) << 12); CvgMask |= (((CvgMaskT >> 1) & 0x1) << 13); CvgMask |= (((CvgMaskT >> 2) & 0x1) << 14); CvgMask |= (((CvgMaskT >> 3) & 0x1) << 15); CvgMask |= (((CvgMaskT >> 4) & 0x1) << 8); CvgMask |= (((CvgMaskT >> 5) & 0x1) << 9); CvgMask |= (((CvgMaskT >> 6) & 0x1) << 10); CvgMask |= (((CvgMaskT >> 7) & 0x1) << 11); CvgMask |= (((CvgMaskT >> 8) & 0x1) << 4); CvgMask |= (((CvgMaskT >> 9) & 0x1) << 5); CvgMask |= (((CvgMaskT >> 10) & 0x1) << 6); CvgMask |= (((CvgMaskT >> 11) & 0x1) << 7); CvgMask |= (((CvgMaskT >> 12) & 0x1) << 0); CvgMask |= (((CvgMaskT >> 13) & 0x1) << 1); CvgMask |= (((CvgMaskT >> 14) & 0x1) << 2); CvgMask |= (((CvgMaskT >> 15) & 0x1) << 3);}//-----------------------------------------------------------------------------
static voiddoCvgMaskSFlip(UINT16 &CvgMask){ UINT16 CvgMaskT = CvgMask; CvgMask = 0; CvgMask |= (((CvgMaskT >> 0) & 0x1) << 0); CvgMask |= (((CvgMaskT >> 1) & 0x1) << 4); CvgMask |= (((CvgMaskT >> 2) & 0x1) << 8); CvgMask |= (((CvgMaskT >> 3) & 0x1) << 12); CvgMask |= (((CvgMaskT >> 4) & 0x1) << 1); CvgMask |= (((CvgMaskT >> 5) & 0x1) << 5); CvgMask |= (((CvgMaskT >> 6) & 0x1) << 9); CvgMask |= (((CvgMaskT >> 7) & 0x1) << 13); CvgMask |= (((CvgMaskT >> 8) & 0x1) << 2); CvgMask |= (((CvgMaskT >> 9) & 0x1) << 6); CvgMask |= (((CvgMaskT >> 10) & 0x1) << 10); CvgMask |= (((CvgMaskT >> 11) & 0x1) << 14); CvgMask |= (((CvgMaskT >> 12) & 0x1) << 3); CvgMask |= (((CvgMaskT >> 13) & 0x1) << 7); CvgMask |= (((CvgMaskT >> 14) & 0x1) << 11); CvgMask |= (((CvgMaskT >> 15) & 0x1) << 15);}
//-----------------------------------------------------------------------------
//
// ComputeCoverageMask - Computes the 16 bit coverage mask. Called once per
// pixel per crossing edge (i.e. up to 3 times per pixel).
//
// This is doing the algorithm described in Schilling's Siggraph paper, with
// modifications to perform the operation for a single virtual octant and
// then munging the result for the actual octant.
//
// Note that the A and B signs for the edges must be computed very carefully
// to guarantee that shared edges will always result in full complimentary
// coverage of pixels on the shared edge.
//
//-----------------------------------------------------------------------------
RRCvgMaskComputeCoverageMask( INT16 iABits, // 1.8 value
BOOL bAPos, BOOL bBPos, INT16 iEBits) // 1.5.5 value, but ranges from -.5 to +.5 here
{ RRCvgMask CvgMask; // return value
// grab already rounded 8 bit value and take absolute value
UINT16 uMagA = (iABits < 0) ? ((UINT16)-iABits) : ((UINT16)iABits); UINT16 uABits = uMagA & 0x1ff;
// compute booleans for manipulating masks
BOOL bMaskInvert = TRUE; BOOL bMaskRFlip = !(bAPos ^ bBPos); if (!bAPos) { iEBits = -iEBits; bMaskInvert = FALSE; }
//
// compute A offset from x or y axis
//
// mirror around 45 degree axis - keep track of this because
// the 45 degree mirroring requires a side-to-side mask flip
BOOL bMaskSFlip = (uABits > 0x80); // > 0.5F ?
if (bMaskSFlip) { uABits = 0x100 - uABits; }
// uABits is now a 0.0.8 value in the range 0x00 to 0x80
//
// determine number of bits to enable in mask based on the area covered
//
// extract bits from A for area lookup
UINT16 uAAreaBits = (uABits == 0x80) ? ((1<<nBitsA)-1) : (uABits >> (7-nBitsA));
// grab distance bits for area lookup - take absolute value and clamp
UINT16 uEBits = (iEBits < 0) ? ((UINT16)-iEBits) : ((UINT16)iEBits); uEBits = MIN(uEBits,(UINT16)(((1<<nBitsE)-1))); // clamp
// look up area in table - returns number of bits to enable
INT16 iNumCvgBits = nBitsToEnable[uAAreaBits][uEBits];
// flip for negative distance
if (iEBits < 0) { iNumCvgBits = 16 - iNumCvgBits; }
//
// compute slope range index and look up coverage mask
//
INT16 iARange = 3; for (INT16 i=0; i<(A_RANGES-1); i++) { if ((uARanges[i] <= uABits) && (uABits < uARanges[i+1])) { iARange = i; break; } }
// check for zero/full coverage else look up coverage mask
if (0 == iNumCvgBits) { CvgMask = 0x0000; } else if (16 == iNumCvgBits) { CvgMask = 0xffff; } else { CvgMask = CvgMasks[iARange][iNumCvgBits-1]; }
//
// adjust mask for different quadrants and directions
//
// first to side-to-side mask flip for 45 degree mirroring
if (bMaskSFlip) { doCvgMaskSFlip(CvgMask); } // invert for 'backwards' line directions
if (bMaskInvert) { CvgMask ^= 0xffff; } // flip for same sign quadrants
if (bMaskRFlip) { doCvgMaskTBFlip(CvgMask); }
return CvgMask;}
///////////////////////////////////////////////////////////////////////////////
// end
|
