NeroReflex/mesa
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

gallium/tessellator: Rename D3D11 defines

Browse source 
We're Gallium, c'mon!

Signed-off-by: Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com>
Acked-by: Jesse Natalie <jenatali@microsoft.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/9118>
This commit is contained in:
Alyssa Rosenzweig 2021-02-17 19:56:49 -05:00 • committed by Marge Bot
parent 248a5a330d
commit 5b6ed24cb8
3 changed files with 142 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

18
src/gallium/auxiliary/tessellator/p_tessellator.cpp
View file

@ -49,21 +49,21 @@ namespace pipe_tessellator_wrap
enum pipe_tess_spacing ts_spacing,
bool tes_vertex_order_cw, bool tes_point_mode)
{
static D3D11_TESSELLATOR_PARTITIONING CVT_TS_D3D_PARTITIONING[] = {
D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD, // PIPE_TESS_SPACING_ODD
D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN, // PIPE_TESS_SPACING_EVEN
D3D11_TESSELLATOR_PARTITIONING_INTEGER, // PIPE_TESS_SPACING_EQUAL
static PIPE_TESSELLATOR_PARTITIONING CVT_TS_D3D_PARTITIONING[] = {
PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD, // PIPE_TESS_SPACING_ODD
PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN, // PIPE_TESS_SPACING_EVEN
PIPE_TESSELLATOR_PARTITIONING_INTEGER, // PIPE_TESS_SPACING_EQUAL
};
D3D11_TESSELLATOR_OUTPUT_PRIMITIVE out_prim;
PIPE_TESSELLATOR_OUTPUT_PRIMITIVE out_prim;
if (tes_point_mode)
out_prim = D3D11_TESSELLATOR_OUTPUT_POINT;
out_prim = PIPE_TESSELLATOR_OUTPUT_POINT;
else if (tes_prim_mode == PIPE_PRIM_LINES)
out_prim = D3D11_TESSELLATOR_OUTPUT_LINE;
out_prim = PIPE_TESSELLATOR_OUTPUT_LINE;
else if (tes_vertex_order_cw)
out_prim = D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW;
out_prim = PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CW;
else
out_prim = D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW;
out_prim = PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CCW;
SUPER::Init(CVT_TS_D3D_PARTITIONING[ts_spacing],
out_prim);

170
src/gallium/auxiliary/tessellator/tessellator.cpp
View file

@ -354,7 +354,7 @@ INT32 floatToIDotF( const float& input )
// or equal to this allows avg. reduction on a quad patch
// including rounding.
static const FXP s_fixedReciprocal[D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR+1] =
static const FXP s_fixedReciprocal[PIPE_TESSELLATOR_MAX_TESSELLATION_FACTOR+1] =
{
0xffffffff, // 1/0 is the first entry (unused)
0x10000, 0x8000, 0x5555, 0x4000,
@ -453,8 +453,8 @@ CHWTessellator::~CHWTessellator()
// User calls this.
//---------------------------------------------------------------------------------------------------------------------------------
void CHWTessellator::Init(
D3D11_TESSELLATOR_PARTITIONING partitioning,
D3D11_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive)
PIPE_TESSELLATOR_PARTITIONING partitioning,
PIPE_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive)
{
if( 0 == m_Point )
{
@ -468,13 +468,13 @@ void CHWTessellator::Init(
m_originalPartitioning = partitioning;
switch( partitioning )
{
case D3D11_TESSELLATOR_PARTITIONING_INTEGER:
case PIPE_TESSELLATOR_PARTITIONING_INTEGER:
default:
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
m_parity = TESSELLATOR_PARITY_ODD;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
m_parity = TESSELLATOR_PARITY_EVEN;
break;
}
@ -509,17 +509,17 @@ void CHWTessellator::TessellateQuadDomain( float tessFactor_Ueq0, float tessFact
switch(m_outputPrimitive)
{
case D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW:
case D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW:
case PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CW:
case PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CCW:
// function orients them CCW if needed
DefineClockwiseTriangle(0,1,3,/*indexStorageOffset*/0);
DefineClockwiseTriangle(1,2,3,/*indexStorageOffset*/3);
m_NumIndices = 6;
break;
case D3D11_TESSELLATOR_OUTPUT_POINT:
case PIPE_TESSELLATOR_OUTPUT_POINT:
DumpAllPoints();
break;
case D3D11_TESSELLATOR_OUTPUT_LINE:
case PIPE_TESSELLATOR_OUTPUT_LINE:
DumpAllPointsAsInOrderLineList();
break;
}
@ -528,12 +528,12 @@ void CHWTessellator::TessellateQuadDomain( float tessFactor_Ueq0, float tessFact
QuadGeneratePoints(processedTessFactors);
if( m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_POINT )
if( m_outputPrimitive == PIPE_TESSELLATOR_OUTPUT_POINT )
{
DumpAllPoints();
return;
}
if( m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_LINE )
if( m_outputPrimitive == PIPE_TESSELLATOR_OUTPUT_LINE )
{
DumpAllPointsAsInOrderLineList();
return;
@ -566,20 +566,20 @@ void CHWTessellator::QuadProcessTessFactors( float tessFactor_Ueq0, float tessFa
float lowerBound = 0.0, upperBound = 0.0;
switch(m_originalPartitioning)
{
case D3D11_TESSELLATOR_PARTITIONING_INTEGER:
case D3D11_TESSELLATOR_PARTITIONING_POW2: // don<6F>t care about pow2 distinction for validation, just treat as integer
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_INTEGER:
case PIPE_TESSELLATOR_PARTITIONING_POW2: // don<6F>t care about pow2 distinction for validation, just treat as integer
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
lowerBound = D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
lowerBound = PIPE_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR;
break;
}
@ -597,10 +597,10 @@ void CHWTessellator::QuadProcessTessFactors( float tessFactor_Ueq0, float tessFa
}
// Clamp inside TessFactors
if(D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD == m_originalPartitioning)
if(PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD == m_originalPartitioning)
{
#define EPSILON 0.0000152587890625f // 2^(-16), min positive fixed point fraction
#define MIN_ODD_TESSFACTOR_PLUS_HALF_EPSILON (D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR + EPSILON/2)
#define MIN_ODD_TESSFACTOR_PLUS_HALF_EPSILON (PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR + EPSILON/2)
// If any TessFactor will end up > 1 after floatToFixed conversion later,
// then force the inside TessFactors to be > 1 so there is a picture frame.
if( (tessFactor_Ueq0 > MIN_ODD_TESSFACTOR_PLUS_HALF_EPSILON) ||
@ -611,7 +611,7 @@ void CHWTessellator::QuadProcessTessFactors( float tessFactor_Ueq0, float tessFa
(insideTessFactor_V > MIN_ODD_TESSFACTOR_PLUS_HALF_EPSILON) )
{
// Force picture frame
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR + EPSILON;
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR + EPSILON;
}
}
@ -1029,16 +1029,16 @@ void CHWTessellator::TessellateTriDomain( float tessFactor_Ueq0, float tessFacto
switch(m_outputPrimitive)
{
case D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW:
case D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW:
case PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CW:
case PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CCW:
// function orients them CCW if needed
DefineClockwiseTriangle(0,1,2,/*indexStorageBaseOffset*/m_NumIndices);
m_NumIndices = 3;
break;
case D3D11_TESSELLATOR_OUTPUT_POINT:
case PIPE_TESSELLATOR_OUTPUT_POINT:
DumpAllPoints();
break;
case D3D11_TESSELLATOR_OUTPUT_LINE:
case PIPE_TESSELLATOR_OUTPUT_LINE:
DumpAllPointsAsInOrderLineList();
break;
}
@ -1047,12 +1047,12 @@ void CHWTessellator::TessellateTriDomain( float tessFactor_Ueq0, float tessFacto
TriGeneratePoints(processedTessFactors);
if( m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_POINT )
if( m_outputPrimitive == PIPE_TESSELLATOR_OUTPUT_POINT )
{
DumpAllPoints();
return;
}
if( m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_LINE )
if( m_outputPrimitive == PIPE_TESSELLATOR_OUTPUT_LINE )
{
DumpAllPointsAsInOrderLineList();
return;
@ -1084,20 +1084,20 @@ void CHWTessellator::TriProcessTessFactors( float tessFactor_Ueq0, float tessFac
float lowerBound = 0.0, upperBound = 0.0;
switch(m_originalPartitioning)
{
case D3D11_TESSELLATOR_PARTITIONING_INTEGER:
case D3D11_TESSELLATOR_PARTITIONING_POW2: // don<6F>t care about pow2 distinction for validation, just treat as integer
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_INTEGER:
case PIPE_TESSELLATOR_PARTITIONING_POW2: // don<6F>t care about pow2 distinction for validation, just treat as integer
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
lowerBound = D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
lowerBound = PIPE_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR;
break;
}
@ -1113,7 +1113,7 @@ void CHWTessellator::TriProcessTessFactors( float tessFactor_Ueq0, float tessFac
}
// Clamp inside TessFactors
if(D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD == m_originalPartitioning)
if(PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD == m_originalPartitioning)
{
if( (tessFactor_Ueq0 > MIN_ODD_TESSFACTOR_PLUS_HALF_EPSILON) ||
(tessFactor_Veq0 > MIN_ODD_TESSFACTOR_PLUS_HALF_EPSILON) ||
@ -1123,7 +1123,7 @@ void CHWTessellator::TriProcessTessFactors( float tessFactor_Ueq0, float tessFac
// patches which have 2 insideTessFactors.
{
// Force picture frame
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR + EPSILON;
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR + EPSILON;
}
}
@ -1459,25 +1459,25 @@ void CHWTessellator::IsoLineProcessTessFactors( float TessFactor_V_LineDensity,
float lowerBound = 0.0, upperBound = 0.0;
switch(m_originalPartitioning)
{
case D3D11_TESSELLATOR_PARTITIONING_INTEGER:
case D3D11_TESSELLATOR_PARTITIONING_POW2: // don<6F>t care about pow2 distinction for validation, just treat as integer
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_INTEGER:
case PIPE_TESSELLATOR_PARTITIONING_POW2: // don<6F>t care about pow2 distinction for validation, just treat as integer
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
lowerBound = D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
lowerBound = PIPE_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
lowerBound = D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR;
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
lowerBound = PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR;
upperBound = PIPE_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR;
break;
}
TessFactor_V_LineDensity = tess_fmin( D3D11_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR,
tess_fmax( D3D11_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR, TessFactor_V_LineDensity ) );
TessFactor_V_LineDensity = tess_fmin( PIPE_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR,
tess_fmax( PIPE_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR, TessFactor_V_LineDensity ) );
TessFactor_U_LineDetail = tess_fmin( upperBound, tess_fmax( lowerBound, TessFactor_U_LineDetail ) );
// Reset our vertex and index buffers. We have enough storage for the max tessFactor.
@ -1502,7 +1502,7 @@ void CHWTessellator::IsoLineProcessTessFactors( float TessFactor_V_LineDensity,
ComputeTessFactorContext(fxpTessFactor_U_LineDetail, processedTessFactors.lineDetailTessFactorCtx);
processedTessFactors.numPointsPerLine = NumPointsForTessFactor(fxpTessFactor_U_LineDetail);
OverridePartitioning(D3D11_TESSELLATOR_PARTITIONING_INTEGER);
OverridePartitioning(PIPE_TESSELLATOR_PARTITIONING_INTEGER);
TessFactor_V_LineDensity = ceil(TessFactor_V_LineDensity);
processedTessFactors.lineDensityParity = isEven(TessFactor_V_LineDensity) ? TESSELLATOR_PARITY_EVEN : TESSELLATOR_PARITY_ODD;
@ -1518,7 +1518,7 @@ void CHWTessellator::IsoLineProcessTessFactors( float TessFactor_V_LineDensity,
// outside edge offsets
m_NumPoints = processedTessFactors.numPointsPerLine * processedTessFactors.numLines;
if( m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_POINT )
if( m_outputPrimitive == PIPE_TESSELLATOR_OUTPUT_POINT )
{
m_NumIndices = m_NumPoints;
}
@ -1556,7 +1556,7 @@ void CHWTessellator::IsoLineGeneratePoints( const PROCESSED_TESS_FACTORS_ISOLINE
void CHWTessellator::IsoLineGenerateConnectivity( const PROCESSED_TESS_FACTORS_ISOLINE& processedTessFactors )
{
int line, pointOffset, indexOffset;
if( m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_POINT )
if( m_outputPrimitive == PIPE_TESSELLATOR_OUTPUT_POINT )
{
for(line = 0, pointOffset = 0, indexOffset = 0; line < processedTessFactors.numLines; line++)
{
@ -1650,7 +1650,7 @@ void CHWTessellator::DefineClockwiseTriangle(int index0, int index1, int index2,
{
// inputs a clockwise triangle, stores a CW or CCW triangle depending on the state
DefineIndex(index0,indexStorageBaseOffset);
bool bWantClockwise = (m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW) ? true : false;
bool bWantClockwise = (m_outputPrimitive == PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CW) ? true : false;
if( bWantClockwise )
{
DefineIndex(index1,indexStorageBaseOffset+1);
@ -2115,10 +2115,10 @@ CHLSLTessellator::CHLSLTessellator()
// User calls this.
//---------------------------------------------------------------------------------------------------------------------------------
void CHLSLTessellator::Init(
D3D11_TESSELLATOR_PARTITIONING partitioning,
D3D11_TESSELLATOR_REDUCTION insideTessFactorReduction,
D3D11_TESSELLATOR_QUAD_REDUCTION_AXIS quadInsideTessFactorReductionAxis,
D3D11_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive)
PIPE_TESSELLATOR_PARTITIONING partitioning,
PIPE_TESSELLATOR_REDUCTION insideTessFactorReduction,
PIPE_TESSELLATOR_QUAD_REDUCTION_AXIS quadInsideTessFactorReductionAxis,
PIPE_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive)
{
CHWTessellator::Init(partitioning,outputPrimitive);
m_LastComputedTessFactors[0] = m_LastComputedTessFactors[1] = m_LastComputedTessFactors[2] =
@ -2127,13 +2127,13 @@ void CHLSLTessellator::Init(
m_originalPartitioning = partitioning;
switch( partitioning )
{
case D3D11_TESSELLATOR_PARTITIONING_INTEGER:
case PIPE_TESSELLATOR_PARTITIONING_INTEGER:
default:
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
m_parity = TESSELLATOR_PARITY_ODD;
break;
case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
case PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
m_parity = TESSELLATOR_PARITY_EVEN;
break;
}
@ -2215,17 +2215,17 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
// Compute inside TessFactors
float insideTessFactor[QUAD_AXES];
if( m_quadInsideTessFactorReductionAxis == D3D11_TESSELLATOR_QUAD_REDUCTION_1_AXIS )
if( m_quadInsideTessFactorReductionAxis == PIPE_TESSELLATOR_QUAD_REDUCTION_1_AXIS )
{
switch( m_insideTessFactorReduction )
{
case D3D11_TESSELLATOR_REDUCTION_MIN:
case PIPE_TESSELLATOR_REDUCTION_MIN:
insideTessFactor[U] = tess_fmin(tess_fmin(tessFactor_Veq0,tessFactor_Veq1),tess_fmin(tessFactor_Ueq0,tessFactor_Ueq1));
break;
case D3D11_TESSELLATOR_REDUCTION_MAX:
case PIPE_TESSELLATOR_REDUCTION_MAX:
insideTessFactor[U] = tess_fmax(tess_fmax(tessFactor_Veq0,tessFactor_Veq1),tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1));
break;
case D3D11_TESSELLATOR_REDUCTION_AVERAGE:
case PIPE_TESSELLATOR_REDUCTION_AVERAGE:
insideTessFactor[U] = (tessFactor_Veq0 + tessFactor_Veq1 + tessFactor_Ueq0 + tessFactor_Ueq1) / 4;
break;
}
@ -2258,7 +2258,7 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
if( (TESSELLATOR_PARITY_ODD == insideTessFactorParity[U]) &&
(insideTessFactor[U] < FLOAT_THREE) )
{
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
if(PIPE_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{
insideTessFactor[U] = tess_fmin(FLOAT_THREE,tess_fmax(tess_fmax(tessFactor_Veq0,tessFactor_Veq1),tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1)));
}
@ -2281,15 +2281,15 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
{
switch( m_insideTessFactorReduction )
{
case D3D11_TESSELLATOR_REDUCTION_MIN:
case PIPE_TESSELLATOR_REDUCTION_MIN:
insideTessFactor[U] = tess_fmin(tessFactor_Veq0,tessFactor_Veq1);
insideTessFactor[V] = tess_fmin(tessFactor_Ueq0,tessFactor_Ueq1);
break;
case D3D11_TESSELLATOR_REDUCTION_MAX:
case PIPE_TESSELLATOR_REDUCTION_MAX:
insideTessFactor[U] = tess_fmax(tessFactor_Veq0,tessFactor_Veq1);
insideTessFactor[V] = tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1);
break;
case D3D11_TESSELLATOR_REDUCTION_AVERAGE:
case PIPE_TESSELLATOR_REDUCTION_AVERAGE:
insideTessFactor[U] = (tessFactor_Veq0 + tessFactor_Veq1) / 2;
insideTessFactor[V] = (tessFactor_Ueq0 + tessFactor_Ueq1) / 2;
break;
@ -2329,7 +2329,7 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
if( (TESSELLATOR_PARITY_ODD == insideTessFactorParity[U]) &&
(insideTessFactor[U] < FLOAT_THREE) )
{
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
if(PIPE_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{
insideTessFactor[U] = tess_fmin(FLOAT_THREE,tess_fmax(tessFactor_Veq0,tessFactor_Veq1));
}
@ -2349,7 +2349,7 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
if( (TESSELLATOR_PARITY_ODD == insideTessFactorParity[V]) &&
(insideTessFactor[V] < FLOAT_THREE) )
{
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
if(PIPE_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{
insideTessFactor[V] = tess_fmin(FLOAT_THREE,tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1));
}
@ -2455,13 +2455,13 @@ void CHLSLTessellator::TriHLSLProcessTessFactors( float tessFactor_Ueq0, float t
float insideTessFactor;
switch( m_insideTessFactorReduction )
{
case D3D11_TESSELLATOR_REDUCTION_MIN:
case PIPE_TESSELLATOR_REDUCTION_MIN:
insideTessFactor = tess_fmin(tess_fmin(tessFactor_Ueq0,tessFactor_Veq0),tessFactor_Weq0);
break;
case D3D11_TESSELLATOR_REDUCTION_MAX:
case PIPE_TESSELLATOR_REDUCTION_MAX:
insideTessFactor = tess_fmax(tess_fmax(tessFactor_Ueq0,tessFactor_Veq0),tessFactor_Weq0);
break;
case D3D11_TESSELLATOR_REDUCTION_AVERAGE:
case PIPE_TESSELLATOR_REDUCTION_AVERAGE:
insideTessFactor = (tessFactor_Ueq0 + tessFactor_Veq0 + tessFactor_Weq0) / 3;
break;
}
@ -2489,7 +2489,7 @@ void CHLSLTessellator::TriHLSLProcessTessFactors( float tessFactor_Ueq0, float t
{
// To prevent snapping on edges, the "picture frame" comes
// in using avg or max (and ignore inside TessFactor scaling) until it is at least 3.
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
if(PIPE_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{
insideTessFactor = tess_fmin(FLOAT_THREE,tess_fmax(tessFactor_Ueq0,tess_fmax(tessFactor_Veq0,tessFactor_Weq0)));
}
@ -2549,7 +2549,7 @@ void CHLSLTessellator::IsoLineHLSLProcessTessFactors( float TessFactor_V_LineDen
RoundUpTessFactor(TessFactor_U_LineDetail);
}
OverridePartitioning(D3D11_TESSELLATOR_PARTITIONING_INTEGER);
OverridePartitioning(PIPE_TESSELLATOR_PARTITIONING_INTEGER);
ClampTessFactor(TessFactor_V_LineDensity); // Clamp unbounded user input to integer
m_LastUnRoundedComputedTessFactors[0] = TessFactor_V_LineDensity; // Save off TessFactors so they can be returned to app
@ -2570,19 +2570,19 @@ void CHLSLTessellator::ClampTessFactor(float& TessFactor)
{
if( Pow2Partitioning() )
{
TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
TessFactor = tess_fmin( PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, tess_fmax( TessFactor, PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
}
else if( IntegerPartitioning() )
{
TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
TessFactor = tess_fmin( PIPE_TESSELLATOR_MAX_TESSELLATION_FACTOR, tess_fmax( TessFactor, PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
}
else if( Odd() )
{
TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
TessFactor = tess_fmin( PIPE_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR, tess_fmax( TessFactor, PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
}
else // even
{
TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR) );
TessFactor = tess_fmin( PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, tess_fmax( TessFactor, PIPE_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR) );
}
}

96
src/gallium/auxiliary/tessellator/tessellator.hpp
View file

@ -58,49 +58,49 @@
//
//=================================================================================================================================
#define D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR 1
#define D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR 63
#define D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR 2
#define D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR 64
#define PIPE_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR 1
#define PIPE_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR 63
#define PIPE_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR 2
#define PIPE_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR 64
#define D3D11_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR 1
#define D3D11_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR 64
#define PIPE_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR 1
#define PIPE_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR 64
#define D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR 64 // max of even and odd tessFactors
#define PIPE_TESSELLATOR_MAX_TESSELLATION_FACTOR 64 // max of even and odd tessFactors
#define MAX_POINT_COUNT ((D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR+1)*(D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR+1))
#define MAX_INDEX_COUNT (D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR*D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR*2*3)
#define MAX_POINT_COUNT ((PIPE_TESSELLATOR_MAX_TESSELLATION_FACTOR+1)*(PIPE_TESSELLATOR_MAX_TESSELLATION_FACTOR+1))
#define MAX_INDEX_COUNT (PIPE_TESSELLATOR_MAX_TESSELLATION_FACTOR*PIPE_TESSELLATOR_MAX_TESSELLATION_FACTOR*2*3)
//=================================================================================================================================
// Data types for the caller
//=================================================================================================================================
enum D3D11_TESSELLATOR_PARTITIONING
enum PIPE_TESSELLATOR_PARTITIONING
{
D3D11_TESSELLATOR_PARTITIONING_INTEGER,
D3D11_TESSELLATOR_PARTITIONING_POW2,
D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD,
D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN
PIPE_TESSELLATOR_PARTITIONING_INTEGER,
PIPE_TESSELLATOR_PARTITIONING_POW2,
PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD,
PIPE_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN
};
enum D3D11_TESSELLATOR_REDUCTION
enum PIPE_TESSELLATOR_REDUCTION
{
D3D11_TESSELLATOR_REDUCTION_MIN,
D3D11_TESSELLATOR_REDUCTION_MAX,
D3D11_TESSELLATOR_REDUCTION_AVERAGE
PIPE_TESSELLATOR_REDUCTION_MIN,
PIPE_TESSELLATOR_REDUCTION_MAX,
PIPE_TESSELLATOR_REDUCTION_AVERAGE
};
enum D3D11_TESSELLATOR_QUAD_REDUCTION_AXIS
enum PIPE_TESSELLATOR_QUAD_REDUCTION_AXIS
{
D3D11_TESSELLATOR_QUAD_REDUCTION_1_AXIS,
D3D11_TESSELLATOR_QUAD_REDUCTION_2_AXIS
PIPE_TESSELLATOR_QUAD_REDUCTION_1_AXIS,
PIPE_TESSELLATOR_QUAD_REDUCTION_2_AXIS
};
enum D3D11_TESSELLATOR_OUTPUT_PRIMITIVE
enum PIPE_TESSELLATOR_OUTPUT_PRIMITIVE
{
D3D11_TESSELLATOR_OUTPUT_POINT,
D3D11_TESSELLATOR_OUTPUT_LINE,
D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW,
D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW,
PIPE_TESSELLATOR_OUTPUT_POINT,
PIPE_TESSELLATOR_OUTPUT_LINE,
PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CW,
PIPE_TESSELLATOR_OUTPUT_TRIANGLE_CCW,
};
typedef struct DOMAIN_POINT
@ -119,8 +119,8 @@ class CHWTessellator
//---------------------------------------------------------------------------------------------------------------------------------
public:
void Init( D3D11_TESSELLATOR_PARTITIONING partitioning,
D3D11_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive);
void Init( PIPE_TESSELLATOR_PARTITIONING partitioning,
PIPE_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive);
void TessellateIsoLineDomain( float TessFactor_V_LineDensity,
float TessFactor_U_LineDetail );
@ -166,7 +166,7 @@ public:
static const int TRI_EDGES = 3;
//=============================================================================================================================
enum TESSELLATOR_PARITY // derived from D3D11_TESSELLATOR_PARTITIONING
enum TESSELLATOR_PARITY // derived from PIPE_TESSELLATOR_PARTITIONING
{ // (note: for integer tessellation, both parities are used)
TESSELLATOR_PARITY_EVEN,
TESSELLATOR_PARITY_ODD
@ -175,9 +175,9 @@ private:
TESSELLATOR_PARITY m_originalParity; // user chosen parity
TESSELLATOR_PARITY m_parity; // current parity: if allowing mix of even/odd during discrete
// tessellation, this can vary from the user defined parity
D3D11_TESSELLATOR_PARTITIONING m_originalPartitioning; // user chosen partitioning
D3D11_TESSELLATOR_PARTITIONING m_partitioning; // current partitioning. IsoLines overrides for line density
D3D11_TESSELLATOR_OUTPUT_PRIMITIVE m_outputPrimitive;
PIPE_TESSELLATOR_PARTITIONING m_originalPartitioning; // user chosen partitioning
PIPE_TESSELLATOR_PARTITIONING m_partitioning; // current partitioning. IsoLines overrides for line density
PIPE_TESSELLATOR_OUTPUT_PRIMITIVE m_outputPrimitive;
DOMAIN_POINT* m_Point; // array where we will store u/v's for the points we generate
int* m_Index; // array where we will store index topology
int m_NumPoints;
@ -207,12 +207,12 @@ private:
// HWIntegerPartitioning() - hardware doesn't care about what pow2 partitioning is - the query below is true for
// both integer and pow2.
bool HWIntegerPartitioning() {return ((m_partitioning == D3D11_TESSELLATOR_PARTITIONING_INTEGER)||
(m_partitioning == D3D11_TESSELLATOR_PARTITIONING_POW2)) ? true : false;}
bool HWIntegerPartitioning() {return ((m_partitioning == PIPE_TESSELLATOR_PARTITIONING_INTEGER)||
(m_partitioning == PIPE_TESSELLATOR_PARTITIONING_POW2)) ? true : false;}
// Tesselation Partitioning control
void RestorePartitioning() {m_partitioning = m_originalPartitioning;};
void OverridePartitioning(D3D11_TESSELLATOR_PARTITIONING partitioning) {m_partitioning = partitioning;} //isoline uses this for density
void OverridePartitioning(PIPE_TESSELLATOR_PARTITIONING partitioning) {m_partitioning = partitioning;} //isoline uses this for density
// Call these to generate new points and indices. Max TessFactor storage is already allocated.
int DefinePoint(FXP u, FXP v, int pointStorageOffset);
@ -355,7 +355,7 @@ private:
};
//=================================================================================================================================
// CHLSLTessellator: D3D11 Tessellation HLSL Tessellator Interface
// CHLSLTessellator: PIPE Tessellation HLSL Tessellator Interface
// Demonstrates TessFactor preconditioning code auto-generated by HLSL. Subject to change, but this
// just represents the effect of shader code the HLSL compiler will generate in the Hull Shader,
// so it does not affect hardware design at all.
@ -363,10 +363,10 @@ private:
class CHLSLTessellator : public CHWTessellator
{
public:
void Init( D3D11_TESSELLATOR_PARTITIONING partitioning,
D3D11_TESSELLATOR_REDUCTION insideTessFactorReduction,
D3D11_TESSELLATOR_QUAD_REDUCTION_AXIS quadInsideTessFactorReductionAxis,
D3D11_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive);
void Init( PIPE_TESSELLATOR_PARTITIONING partitioning,
PIPE_TESSELLATOR_REDUCTION insideTessFactorReduction,
PIPE_TESSELLATOR_QUAD_REDUCTION_AXIS quadInsideTessFactorReductionAxis,
PIPE_TESSELLATOR_OUTPUT_PRIMITIVE outputPrimitive);
void TessellateIsoLineDomain( float TessFactor_V_LineDensity,
float TessFactor_U_LineDetail );
@ -426,15 +426,15 @@ private:
TESSELLATOR_PARITY m_originalParity; // user chosen parity
TESSELLATOR_PARITY m_parity; // current parity: if allowing mix of even/odd during discrete
// tessellation, this can vary from the user defined parity
D3D11_TESSELLATOR_PARTITIONING m_originalPartitioning; // user chosen partitioning
D3D11_TESSELLATOR_PARTITIONING m_partitioning; // current partitioning. IsoLines overrides for line density
D3D11_TESSELLATOR_OUTPUT_PRIMITIVE m_outputPrimitive;
D3D11_TESSELLATOR_REDUCTION m_insideTessFactorReduction;
D3D11_TESSELLATOR_QUAD_REDUCTION_AXIS m_quadInsideTessFactorReductionAxis;
PIPE_TESSELLATOR_PARTITIONING m_originalPartitioning; // user chosen partitioning
PIPE_TESSELLATOR_PARTITIONING m_partitioning; // current partitioning. IsoLines overrides for line density
PIPE_TESSELLATOR_OUTPUT_PRIMITIVE m_outputPrimitive;
PIPE_TESSELLATOR_REDUCTION m_insideTessFactorReduction;
PIPE_TESSELLATOR_QUAD_REDUCTION_AXIS m_quadInsideTessFactorReductionAxis;
float m_LastComputedTessFactors[6]; // TessFactors used for last tessellation
float m_LastUnRoundedComputedTessFactors[6]; // TessFactors used for last tessellation (before they were rounded)
bool IntegerPartitioning() {return (m_partitioning == D3D11_TESSELLATOR_PARTITIONING_INTEGER) ? true : false;}
bool Pow2Partitioning() {return (m_partitioning == D3D11_TESSELLATOR_PARTITIONING_POW2)? true : false;}
bool IntegerPartitioning() {return (m_partitioning == PIPE_TESSELLATOR_PARTITIONING_INTEGER) ? true : false;}
bool Pow2Partitioning() {return (m_partitioning == PIPE_TESSELLATOR_PARTITIONING_POW2)? true : false;}
void ClampTessFactor(float& TessFactor);
void RoundUpTessFactor(float& TessFactor);
void CleanupFloatTessFactor(float& input); // clamp float to [1.0f... +INF] (incl NaN->1.0f)
@ -446,7 +446,7 @@ private:
// Tesselation Partitioning control
void RestorePartitioning() {m_partitioning = m_originalPartitioning;};
void OverridePartitioning(D3D11_TESSELLATOR_PARTITIONING partitioning) {m_partitioning = partitioning;} //isoline uses this for density
void OverridePartitioning(PIPE_TESSELLATOR_PARTITIONING partitioning) {m_partitioning = partitioning;} //isoline uses this for density
void IsoLineHLSLProcessTessFactors( float TessFactor_V_LineDensity, float TessFactor_U_LineDetail );
void TriHLSLProcessTessFactors( float tessFactor_Ueq0, float TessFactor_Veq0, float TessFactor_Weq0, float insideTessFactor );