fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-23 19:50:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

gallivm/tessellator: use private functions for min/max to avoid namespace issues

Browse source 
Different builds are failing because of namespace collisions here.

Just fix the MS code to avoid it.

Fixes: bd0188f9ea ("gallium/auxiliary: add the microsoft tessellator and a pipe wrapper.")

Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
Closes: https://gitlab.freedesktop.org/mesa/mesa/issues/2586
Tested-by: Marge Bot <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4016>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4016>
This commit is contained in:
Dave Airlie 2020-03-02 16:55:18 +10:00
parent c376865f5e
commit bb2287ccdf
1 changed files with 45 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -43,7 +43,7 @@ union fiu {
int i; int i;
}; };
bool isNaN( float a ) static bool tess_isNaN( float a )
{ {
static const int exponentMask = 0x7f800000; static const int exponentMask = 0x7f800000;
static const int mantissaMask = 0x007fffff; static const int mantissaMask = 0x007fffff;
@ -55,7 +55,7 @@ bool isNaN( float a )
//--------------------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------------------
// flush (denorm) // flush (denorm)
//--------------------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------------------
float flush( float a ) static float tess_flush( float a )
{ {
static const int minNormalizedFloat = 0x00800000; static const int minNormalizedFloat = 0x00800000;
static const int signBit = 0x80000000; static const int signBit = 0x80000000;
@ -75,11 +75,11 @@ float flush( float a )
//--------------------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------------------
// IEEE754R min // IEEE754R min
//--------------------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------------------
float fmin( float a, float b ) static float tess_fmin( float a, float b )
{ {
float _a = flush( a ); float _a = tess_flush( a );
float _b = flush( b ); float _b = tess_flush( b );
if( isNaN( _b ) ) if( tess_isNaN( _b ) )
{ {
return a; return a;
} }
@ -95,12 +95,12 @@ float fmin( float a, float b )
//--------------------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------------------
// IEEE754R max // IEEE754R max
//--------------------------------------------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------------------------------------------
float fmax( float a, float b ) static float tess_fmax( float a, float b )
{ {
float _a = flush( a ); float _a = tess_flush( a );
float _b = flush( b ); float _b = tess_flush( b );
if( isNaN( _b ) ) if( tess_isNaN( _b ) )
{ {
return a; return a;
} }
@ -582,10 +582,10 @@ void CHWTessellator::QuadProcessTessFactors( float tessFactor_Ueq0, float tessFa
break; break;
} }
tessFactor_Ueq0 = fmin( upperBound, fmax( lowerBound, tessFactor_Ueq0 ) ); tessFactor_Ueq0 = tess_fmin( upperBound, tess_fmax( lowerBound, tessFactor_Ueq0 ) );
tessFactor_Veq0 = fmin( upperBound, fmax( lowerBound, tessFactor_Veq0 ) ); tessFactor_Veq0 = tess_fmin( upperBound, tess_fmax( lowerBound, tessFactor_Veq0 ) );
tessFactor_Ueq1 = fmin( upperBound, fmax( lowerBound, tessFactor_Ueq1 ) ); tessFactor_Ueq1 = tess_fmin( upperBound, tess_fmax( lowerBound, tessFactor_Ueq1 ) );
tessFactor_Veq1 = fmin( upperBound, fmax( lowerBound, tessFactor_Veq1 ) ); tessFactor_Veq1 = tess_fmin( upperBound, tess_fmax( lowerBound, tessFactor_Veq1 ) );
if( HWIntegerPartitioning()) // pow2 or integer, round to next int (hw doesn't care about pow2 distinction) if( HWIntegerPartitioning()) // pow2 or integer, round to next int (hw doesn't care about pow2 distinction)
{ {
@ -614,8 +614,8 @@ void CHWTessellator::QuadProcessTessFactors( float tessFactor_Ueq0, float tessFa
} }
} }
insideTessFactor_U = fmin( upperBound, fmax( lowerBound, insideTessFactor_U ) ); insideTessFactor_U = tess_fmin( upperBound, tess_fmax( lowerBound, insideTessFactor_U ) );
insideTessFactor_V = fmin( upperBound, fmax( lowerBound, insideTessFactor_V ) ); insideTessFactor_V = tess_fmin( upperBound, tess_fmax( lowerBound, insideTessFactor_V ) );
// Note the above clamps map NaN to lowerBound // Note the above clamps map NaN to lowerBound
@ -1100,9 +1100,9 @@ void CHWTessellator::TriProcessTessFactors( float tessFactor_Ueq0, float tessFac
break; break;
} }
tessFactor_Ueq0 = fmin( upperBound, fmax( lowerBound, tessFactor_Ueq0 ) ); tessFactor_Ueq0 = tess_fmin( upperBound, tess_fmax( lowerBound, tessFactor_Ueq0 ) );
tessFactor_Veq0 = fmin( upperBound, fmax( lowerBound, tessFactor_Veq0 ) ); tessFactor_Veq0 = tess_fmin( upperBound, tess_fmax( lowerBound, tessFactor_Veq0 ) );
tessFactor_Weq0 = fmin( upperBound, fmax( lowerBound, tessFactor_Weq0 ) ); tessFactor_Weq0 = tess_fmin( upperBound, tess_fmax( lowerBound, tessFactor_Weq0 ) );
if( HWIntegerPartitioning()) // pow2 or integer, round to next int (hw doesn't care about pow2 distinction) if( HWIntegerPartitioning()) // pow2 or integer, round to next int (hw doesn't care about pow2 distinction)
{ {
@ -1126,7 +1126,7 @@ void CHWTessellator::TriProcessTessFactors( float tessFactor_Ueq0, float tessFac
} }
} }
insideTessFactor = fmin( upperBound, fmax( lowerBound, insideTessFactor ) ); insideTessFactor = tess_fmin( upperBound, tess_fmax( lowerBound, insideTessFactor ) );
// Note the above clamps map NaN to lowerBound // Note the above clamps map NaN to lowerBound
if( HWIntegerPartitioning()) // pow2 or integer, round to next int (hw doesn't care about pow2 distinction) if( HWIntegerPartitioning()) // pow2 or integer, round to next int (hw doesn't care about pow2 distinction)
@ -1475,9 +1475,9 @@ void CHWTessellator::IsoLineProcessTessFactors( float TessFactor_V_LineDensity,
break; break;
} }
TessFactor_V_LineDensity = fmin( D3D11_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR, TessFactor_V_LineDensity = tess_fmin( D3D11_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR,
fmax( D3D11_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR, TessFactor_V_LineDensity ) ); tess_fmax( D3D11_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR, TessFactor_V_LineDensity ) );
TessFactor_U_LineDetail = fmin( upperBound, fmax( lowerBound, TessFactor_U_LineDetail ) ); 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. // Reset our vertex and index buffers. We have enough storage for the max tessFactor.
m_NumPoints = 0; m_NumPoints = 0;
@ -2281,10 +2281,10 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
switch( m_insideTessFactorReduction ) switch( m_insideTessFactorReduction )
{ {
case D3D11_TESSELLATOR_REDUCTION_MIN: case D3D11_TESSELLATOR_REDUCTION_MIN:
insideTessFactor[U] = fmin(fmin(tessFactor_Veq0,tessFactor_Veq1),fmin(tessFactor_Ueq0,tessFactor_Ueq1)); insideTessFactor[U] = tess_fmin(tess_fmin(tessFactor_Veq0,tessFactor_Veq1),tess_fmin(tessFactor_Ueq0,tessFactor_Ueq1));
break; break;
case D3D11_TESSELLATOR_REDUCTION_MAX: case D3D11_TESSELLATOR_REDUCTION_MAX:
insideTessFactor[U] = fmax(fmax(tessFactor_Veq0,tessFactor_Veq1),fmax(tessFactor_Ueq0,tessFactor_Ueq1)); insideTessFactor[U] = tess_fmax(tess_fmax(tessFactor_Veq0,tessFactor_Veq1),tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1));
break; break;
case D3D11_TESSELLATOR_REDUCTION_AVERAGE: case D3D11_TESSELLATOR_REDUCTION_AVERAGE:
insideTessFactor[U] = (tessFactor_Veq0 + tessFactor_Veq1 + tessFactor_Ueq0 + tessFactor_Ueq1) / 4; insideTessFactor[U] = (tessFactor_Veq0 + tessFactor_Veq1 + tessFactor_Ueq0 + tessFactor_Ueq1) / 4;
@ -2321,11 +2321,11 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
{ {
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction) if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{ {
insideTessFactor[U] = fmin(FLOAT_THREE,fmax(fmax(tessFactor_Veq0,tessFactor_Veq1),fmax(tessFactor_Ueq0,tessFactor_Ueq1))); insideTessFactor[U] = tess_fmin(FLOAT_THREE,tess_fmax(tess_fmax(tessFactor_Veq0,tessFactor_Veq1),tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1)));
} }
else else
{ {
insideTessFactor[U] = fmin(FLOAT_THREE,(tessFactor_Veq0 + tessFactor_Veq1 + tessFactor_Ueq0 + tessFactor_Ueq1) / 4); insideTessFactor[U] = tess_fmin(FLOAT_THREE,(tessFactor_Veq0 + tessFactor_Veq1 + tessFactor_Ueq0 + tessFactor_Ueq1) / 4);
} }
ClampTessFactor(insideTessFactor[U]); // clamp reduction result that is based on unbounded user input ClampTessFactor(insideTessFactor[U]); // clamp reduction result that is based on unbounded user input
m_LastUnRoundedComputedTessFactors[4] = m_LastUnRoundedComputedTessFactors[5] = insideTessFactor[U]; // Save off TessFactors so they can be returned to app m_LastUnRoundedComputedTessFactors[4] = m_LastUnRoundedComputedTessFactors[5] = insideTessFactor[U]; // Save off TessFactors so they can be returned to app
@ -2343,12 +2343,12 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
switch( m_insideTessFactorReduction ) switch( m_insideTessFactorReduction )
{ {
case D3D11_TESSELLATOR_REDUCTION_MIN: case D3D11_TESSELLATOR_REDUCTION_MIN:
insideTessFactor[U] = fmin(tessFactor_Veq0,tessFactor_Veq1); insideTessFactor[U] = tess_fmin(tessFactor_Veq0,tessFactor_Veq1);
insideTessFactor[V] = fmin(tessFactor_Ueq0,tessFactor_Ueq1); insideTessFactor[V] = tess_fmin(tessFactor_Ueq0,tessFactor_Ueq1);
break; break;
case D3D11_TESSELLATOR_REDUCTION_MAX: case D3D11_TESSELLATOR_REDUCTION_MAX:
insideTessFactor[U] = fmax(tessFactor_Veq0,tessFactor_Veq1); insideTessFactor[U] = tess_fmax(tessFactor_Veq0,tessFactor_Veq1);
insideTessFactor[V] = fmax(tessFactor_Ueq0,tessFactor_Ueq1); insideTessFactor[V] = tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1);
break; break;
case D3D11_TESSELLATOR_REDUCTION_AVERAGE: case D3D11_TESSELLATOR_REDUCTION_AVERAGE:
insideTessFactor[U] = (tessFactor_Veq0 + tessFactor_Veq1) / 2; insideTessFactor[U] = (tessFactor_Veq0 + tessFactor_Veq1) / 2;
@ -2392,11 +2392,11 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
{ {
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction) if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{ {
insideTessFactor[U] = fmin(FLOAT_THREE,fmax(tessFactor_Veq0,tessFactor_Veq1)); insideTessFactor[U] = tess_fmin(FLOAT_THREE,tess_fmax(tessFactor_Veq0,tessFactor_Veq1));
} }
else else
{ {
insideTessFactor[U] = fmin(FLOAT_THREE,(tessFactor_Veq0 + tessFactor_Veq1) / 2); insideTessFactor[U] = tess_fmin(FLOAT_THREE,(tessFactor_Veq0 + tessFactor_Veq1) / 2);
} }
ClampTessFactor(insideTessFactor[U]); // clamp reduction result that is based on unbounded user input ClampTessFactor(insideTessFactor[U]); // clamp reduction result that is based on unbounded user input
m_LastUnRoundedComputedTessFactors[4] = insideTessFactor[U]; // Save off TessFactors so they can be returned to app m_LastUnRoundedComputedTessFactors[4] = insideTessFactor[U]; // Save off TessFactors so they can be returned to app
@ -2412,11 +2412,11 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
{ {
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction) if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{ {
insideTessFactor[V] = fmin(FLOAT_THREE,fmax(tessFactor_Ueq0,tessFactor_Ueq1)); insideTessFactor[V] = tess_fmin(FLOAT_THREE,tess_fmax(tessFactor_Ueq0,tessFactor_Ueq1));
} }
else else
{ {
insideTessFactor[V] = fmin(FLOAT_THREE,(tessFactor_Ueq0 + tessFactor_Ueq1) / 2); insideTessFactor[V] = tess_fmin(FLOAT_THREE,(tessFactor_Ueq0 + tessFactor_Ueq1) / 2);
} }
ClampTessFactor(insideTessFactor[V]);// clamp reduction result that is based on unbounded user input ClampTessFactor(insideTessFactor[V]);// clamp reduction result that is based on unbounded user input
m_LastUnRoundedComputedTessFactors[5] = insideTessFactor[V]; // Save off TessFactors so they can be returned to app m_LastUnRoundedComputedTessFactors[5] = insideTessFactor[V]; // Save off TessFactors so they can be returned to app
@ -2435,7 +2435,7 @@ void CHLSLTessellator::QuadHLSLProcessTessFactors( float tessFactor_Ueq0, float
// as much as the side with the minimum TessFactor. Prevents snapping to edge. // as much as the side with the minimum TessFactor. Prevents snapping to edge.
if( (insideTessFactor[axis] < FLOAT_THREE) && (insideTessFactor[axis] < insideTessFactor[(axis+1)&0x1])) if( (insideTessFactor[axis] < FLOAT_THREE) && (insideTessFactor[axis] < insideTessFactor[(axis+1)&0x1]))
{ {
insideTessFactor[axis] = fmin(insideTessFactor[(axis+1)&0x1],FLOAT_THREE); insideTessFactor[axis] = tess_fmin(insideTessFactor[(axis+1)&0x1],FLOAT_THREE);
m_LastUnRoundedComputedTessFactors[4+axis] = insideTessFactor[axis]; // Save off TessFactors so they can be returned to app m_LastUnRoundedComputedTessFactors[4+axis] = insideTessFactor[axis]; // Save off TessFactors so they can be returned to app
} }
} }
@ -2517,10 +2517,10 @@ void CHLSLTessellator::TriHLSLProcessTessFactors( float tessFactor_Ueq0, float t
switch( m_insideTessFactorReduction ) switch( m_insideTessFactorReduction )
{ {
case D3D11_TESSELLATOR_REDUCTION_MIN: case D3D11_TESSELLATOR_REDUCTION_MIN:
insideTessFactor = fmin(fmin(tessFactor_Ueq0,tessFactor_Veq0),tessFactor_Weq0); insideTessFactor = tess_fmin(tess_fmin(tessFactor_Ueq0,tessFactor_Veq0),tessFactor_Weq0);
break; break;
case D3D11_TESSELLATOR_REDUCTION_MAX: case D3D11_TESSELLATOR_REDUCTION_MAX:
insideTessFactor = fmax(fmax(tessFactor_Ueq0,tessFactor_Veq0),tessFactor_Weq0); insideTessFactor = tess_fmax(tess_fmax(tessFactor_Ueq0,tessFactor_Veq0),tessFactor_Weq0);
break; break;
case D3D11_TESSELLATOR_REDUCTION_AVERAGE: case D3D11_TESSELLATOR_REDUCTION_AVERAGE:
insideTessFactor = (tessFactor_Ueq0 + tessFactor_Veq0 + tessFactor_Weq0) / 3; insideTessFactor = (tessFactor_Ueq0 + tessFactor_Veq0 + tessFactor_Weq0) / 3;
@ -2529,7 +2529,7 @@ void CHLSLTessellator::TriHLSLProcessTessFactors( float tessFactor_Ueq0, float t
// Scale inside TessFactor based on user scale factor. // Scale inside TessFactor based on user scale factor.
ClampFloatTessFactorScale(insideTessFactorScale); // clamp scale value to [0..1], NaN->0 ClampFloatTessFactorScale(insideTessFactorScale); // clamp scale value to [0..1], NaN->0
insideTessFactor = insideTessFactor*fmin(FLOAT_ONE,insideTessFactorScale); insideTessFactor = insideTessFactor*tess_fmin(FLOAT_ONE,insideTessFactorScale);
ClampTessFactor(insideTessFactor); // clamp reduction + scale result that is based on unbounded user input ClampTessFactor(insideTessFactor); // clamp reduction + scale result that is based on unbounded user input
m_LastUnRoundedComputedTessFactors[3] = insideTessFactor;// Save off TessFactors so they can be returned to app m_LastUnRoundedComputedTessFactors[3] = insideTessFactor;// Save off TessFactors so they can be returned to app
@ -2552,11 +2552,11 @@ void CHLSLTessellator::TriHLSLProcessTessFactors( float tessFactor_Ueq0, float t
// in using avg or max (and ignore inside TessFactor scaling) until it is at least 3. // in using avg or max (and ignore inside TessFactor scaling) until it is at least 3.
if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction) if(D3D11_TESSELLATOR_REDUCTION_MAX == m_insideTessFactorReduction)
{ {
insideTessFactor = fmin(FLOAT_THREE,fmax(tessFactor_Ueq0,fmax(tessFactor_Veq0,tessFactor_Weq0))); insideTessFactor = tess_fmin(FLOAT_THREE,tess_fmax(tessFactor_Ueq0,tess_fmax(tessFactor_Veq0,tessFactor_Weq0)));
} }
else else
{ {
insideTessFactor = fmin(FLOAT_THREE,(tessFactor_Ueq0 + tessFactor_Veq0 + tessFactor_Weq0) / 3); insideTessFactor = tess_fmin(FLOAT_THREE,(tessFactor_Ueq0 + tessFactor_Veq0 + tessFactor_Weq0) / 3);
} }
ClampTessFactor(insideTessFactor); // clamp reduction result that is based on unbounded user input ClampTessFactor(insideTessFactor); // clamp reduction result that is based on unbounded user input
m_LastUnRoundedComputedTessFactors[3] = insideTessFactor;// Save off TessFactors so they can be returned to app m_LastUnRoundedComputedTessFactors[3] = insideTessFactor;// Save off TessFactors so they can be returned to app
@ -2631,19 +2631,19 @@ void CHLSLTessellator::ClampTessFactor(float& TessFactor)
{ {
if( Pow2Partitioning() ) if( Pow2Partitioning() )
{ {
TessFactor = fmin( D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) ); TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
} }
else if( IntegerPartitioning() ) else if( IntegerPartitioning() )
{ {
TessFactor = fmin( D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR, fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) ); TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
} }
else if( Odd() ) else if( Odd() )
{ {
TessFactor = fmin( D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR, fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) ); TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR) );
} }
else // even else // even
{ {
TessFactor = fmin( D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, fmax( TessFactor, D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR) ); TessFactor = tess_fmin( D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR, tess_fmax( TessFactor, D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR) );
} }
} }