sF32 sBSpline::Evaluate(sF32 time) const
{
sInt deg = Degree;
sF32 *weights = (sF32 *) _alloca(sizeof(sF32) * (deg + 1));
sInt first;
CalcBasis(time,first,weights);
sF32 value = 0.0f;
for(sInt i=0; i<=deg; i++)
value += weights[i] * Values[first+i];
return value;
}
void CGlowOverlay::Draw( bool bCacheFullSceneState )
{
extern ConVar r_drawsprites;
if( !r_drawsprites.GetBool() )
return;
// Get the vector to the sun.
Vector vToGlow;
if( m_bDirectional )
vToGlow = m_vDirection;
else
vToGlow = m_vPos - CurrentViewOrigin();
VectorNormalize( vToGlow );
float flDot = vToGlow.Dot( CurrentViewForward() );
UpdateGlowObstruction( vToGlow, bCacheFullSceneState );
if( m_flGlowObstructionScale == 0 )
return;
bool bWireframe = ShouldDrawInWireFrameMode() || (r_drawsprites.GetInt() == 2);
CMatRenderContextPtr pRenderContext( materials );
for( int iSprite=0; iSprite < m_nSprites; iSprite++ )
{
CGlowSprite *pSprite = &m_Sprites[iSprite];
// Figure out the color and size to draw it.
float flHorzSize, flVertSize;
Vector vColor;
CalcSpriteColorAndSize( flDot, pSprite, &flHorzSize, &flVertSize, &vColor );
// If we're alpha'd out, then don't bother
if ( vColor.LengthSqr() < 0.00001f )
continue;
// Setup the basis to draw the sprite.
Vector vBasePt, vUp, vRight;
CalcBasis( vToGlow, flHorzSize, flVertSize, vBasePt, vUp, vRight );
//Get our diagonal radius
float radius = (vRight+vUp).Length();
if ( R_CullSphere( view->GetFrustum(), 5, &vBasePt, radius ) )
continue;
// Get our material (deferred default load)
if ( m_Sprites[iSprite].m_pMaterial == NULL )
{
m_Sprites[iSprite].m_pMaterial = materials->FindMaterial( "sprites/light_glow02_add_noz", TEXTURE_GROUP_CLIENT_EFFECTS );
}
Assert( m_Sprites[iSprite].m_pMaterial );
static unsigned int nHDRColorScaleCache = 0;
IMaterialVar *pHDRColorScaleVar = m_Sprites[iSprite].m_pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
if( pHDRColorScaleVar )
{
pHDRColorScaleVar->SetFloatValue( m_flHDRColorScale );
}
// Draw the sprite.
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, 0, 0, m_Sprites[iSprite].m_pMaterial );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_QUADS, 1 );
Vector vPt;
vPt = vBasePt - vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 0, 1 );
builder.AdvanceVertex();
vPt = vBasePt + vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 1, 1 );
builder.AdvanceVertex();
vPt = vBasePt + vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 1, 0 );
builder.AdvanceVertex();
vPt = vBasePt - vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 0, 0 );
builder.AdvanceVertex();
builder.End( false, true );
if( bWireframe )
{
IMaterial *pWireframeMaterial = materials->FindMaterial( "debug/debugwireframevertexcolor", TEXTURE_GROUP_OTHER );
pRenderContext->Bind( pWireframeMaterial );
// Draw the sprite.
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, 0, 0, pWireframeMaterial );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_QUADS, 1 );
Vector vPt;
vPt = vBasePt - vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
vPt = vBasePt + vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
vPt = vBasePt + vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
vPt = vBasePt - vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
builder.End( false, true );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Special draw for the warped overlay
//-----------------------------------------------------------------------------
void CWarpOverlay::Draw( bool bCacheFullSceneState )
{
// Get the vector to the sun.
Vector vToGlow;
if( m_bDirectional )
vToGlow = m_vDirection;
else
vToGlow = m_vPos - CurrentViewOrigin();
VectorNormalize( vToGlow );
float flDot = vToGlow.Dot( CurrentViewForward() );
if( flDot <= g_flOverlayRange )
return;
UpdateGlowObstruction( vToGlow, bCacheFullSceneState );
if( m_flGlowObstructionScale == 0 )
return;
CMatRenderContextPtr pRenderContext( materials );
//FIXME: Allow multiple?
for( int iSprite=0; iSprite < m_nSprites; iSprite++ )
{
CGlowSprite *pSprite = &m_Sprites[iSprite];
// Figure out the color and size to draw it.
float flHorzSize, flVertSize;
Vector vColor;
CalcSpriteColorAndSize( flDot, pSprite, &flHorzSize, &flVertSize, &vColor );
// Setup the basis to draw the sprite.
Vector vBasePt, vUp, vRight;
CalcBasis( vToGlow, flHorzSize, flVertSize, vBasePt, vUp, vRight );
// Draw the sprite.
IMaterial *pMaterial = materials->FindMaterial( "sun/overlay", TEXTURE_GROUP_CLIENT_EFFECTS );
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, 0, 0, pMaterial );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_QUADS, 1 );
Vector vPt;
vPt = vBasePt - vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 0, 1 );
builder.AdvanceVertex();
vPt = vBasePt + vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 1, 1 );
builder.AdvanceVertex();
vPt = vBasePt + vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 1, 0 );
builder.AdvanceVertex();
vPt = vBasePt - vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 0, 0 );
builder.AdvanceVertex();
builder.End( false, true );
}
}
void sBSpline::LeastSquaresFit(const Sample *samples,sInt nSamples)
{
// The input dataset is assumed to be on [0,1)
// Now do a least-squares fit via normal equations, that is solve
// (A^T A) x = A^T b
// for x.
//
// To do this, first compute the weights of the B-Spline at
// sample points to determine A
sInt deg = Degree,order = Degree + 1;
sInt nKnots = Knots.Count;
sF32 *A = new sF32[nSamples * order];
sInt *start = new sInt[nSamples];
for(sInt i=0; i<nSamples; i++)
if(samples[i].Type == 0) // normal function value
CalcBasis(samples[i].Time,start[i],A + i*order);
else // derivative
CalcBasisDeriv(samples[i].Time,start[i],A + i*order);
// Next, calculate the matrix A^T A. This is always symmetrical and
// positive semidefinite, and in this case also a banded matrix, so we
// only need order * nKnots floats to store it
sF32 *ATA = new sF32[nKnots * order];
for(sInt i=0; i<nKnots; i++)
{
// samples for knot i
sInt start1 = lowerBound(start,i-deg,nSamples);
sInt end1 = lowerBound(start,i+1,nSamples);
for(sInt j=0; j<order; j++)
{
// samples for knot i+j-deg
sInt start2 = lowerBound(start,i+j-2*deg,nSamples);
sInt end2 = lowerBound(start,i+j-deg+1,nSamples);
// calculate overlap
sInt commonStart = sMax(start1,start2);
sInt commonEnd = sMin(end1,end2);
// perform summation
sF64 sum = 0.0f;
for(sInt k=commonStart; k<commonEnd; k++)
{
sF32 *pos = &A[k*order + i-start[k]];
sum += pos[0] * pos[j-deg];
}
ATA[i*order+j] = sum;
}
}
// Compute a LDL^T decomposition of A^T A (in-place)
sF32 *scale = new sF32[nKnots];
for(sInt i=0; i<nKnots; i++)
{
// Solve for diagonal element
sF64 d = ATA[i*order+deg];
for(sInt j=sMax(i-deg,0); j<i; j++)
d -= sSquare(ATA[i*order+(j-i)+deg])*ATA[j*order+deg];
// Calculate inverse d, store back
d = (sFAbs(d) > 1e-10f) ? d : 0.0f;
sF64 id = d ? 1.0f / d : 0.0f;
ATA[i*order+deg] = d;
scale[i] = id;
// Solve for rest
for(sInt j=1; j<order; j++)
{
sInt row = i+j;
if(row < nKnots)
{
sF64 sum = ATA[row*order+deg-j];
for(sInt k=sMax(row-deg,0); k<i; k++)
sum -= ATA[row*order+(k-row)+deg] * ATA[i*order+(k-i)+deg] * ATA[k*order+deg];
ATA[row*order+deg-j] = id * sum;
}
}
}
// Now, actually solve the system. Anything before this only needs to be
// done once per knot vector.
// Compute A^T b
for(sInt i=0; i<nKnots; i++)
{
sInt startw = lowerBound(start,i-deg,nSamples);
sInt endw = lowerBound(start,i+1,nSamples);
sF64 c = 0.0f;
for(sInt j=startw; j<endw; j++)
c += A[j*order + i-start[j]] * samples[j].Value;
Values[i] = c;
}
// Solve Lx
for(sInt i=0; i<nKnots; i++)
{
sF64 sum = Values[i];
for(sInt j=sMax(i-deg,0); j<i; j++)
sum -= ATA[i*order+(j-i)+deg] * Values[j];
Values[i] = sum;
}
// Solve Dx
for(sInt i=0; i<nKnots; i++)
Values[i] *= scale[i];
// Solve L^Tx (backwards substitution)
for(sInt i=nKnots-2; i>=0; i--)
{
sF64 sum = Values[i];
for(sInt j=i+1; j<sMin(i+order,nKnots); j++)
sum -= ATA[j*order+(i-j)+deg] * Values[j];
Values[i] = sum;
}
// Cleanup
delete[] A;
delete[] start;
delete[] ATA;
delete[] scale;
}
