diff options
Diffstat (limited to 'public/panorama/layout/fillbrush.h')
| -rw-r--r-- | public/panorama/layout/fillbrush.h | 993 |
1 files changed, 993 insertions, 0 deletions
diff --git a/public/panorama/layout/fillbrush.h b/public/panorama/layout/fillbrush.h new file mode 100644 index 0000000..97d528b --- /dev/null +++ b/public/panorama/layout/fillbrush.h @@ -0,0 +1,993 @@ +//=========== Copyright Valve Corporation, All rights reserved. ===============// +// +// Purpose: Classes/types to represent fill brushes of varius types +// +//=============================================================================// + +#ifndef FILLBRUSH_H +#define FILLBRUSH_H + +#ifdef _WIN32 +#pragma once +#endif + +#include <float.h> +#include "color.h" +#include "utlvector.h" +#include "uilength.h" + +namespace panorama +{ + +//----------------------------------------------------------------------------- +// Purpose: Represents a gradient color stop value +//----------------------------------------------------------------------------- +class CGradientColorStop +{ +public: + + CGradientColorStop() + { + m_flPercent = 0.0f; + m_color = Color( 0, 0, 0, 0 ); + } + + CGradientColorStop( float flPercent, Color color ) + { + m_flPercent = clamp( flPercent, 0.0f, 1.0f ); + m_color = color; + } + + void SetPosition( float flPercent ) + { + m_flPercent = clamp( flPercent, 0.0f, 1.0f ); + } + + void SetColor( Color color ) + { + m_color = color; + } + + void SetColor( int r, int g, int b, int a ) + { + m_color.SetColor( r, g, b, a ); + } + + float GetPosition() const { return m_flPercent; } + Color GetColor() const { return m_color; } + + bool operator==( const CGradientColorStop &rhs ) const + { + return ( m_flPercent == rhs.m_flPercent && m_color == rhs.m_color ); + } + + bool operator!=( const CGradientColorStop &rhs ) const + { + return !(*this == rhs); + } + +private: + + // 0.0->1.0f + float m_flPercent; + + // rgba color + Color m_color; +}; + + + +//----------------------------------------------------------------------------- +// Purpose: Represents a particle system +//----------------------------------------------------------------------------- +class CParticleSystem +{ +public: + + // Default constructor, sets empty system + CParticleSystem() + { + SetParticleSystem( Vector( 0.0f, 0.0f, 0.0f ), Vector( 0.0f, 0.0f, 0.0f ), 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, Vector( 0.0f, 0.0f, 0.0f ), Vector( 0.0f, 0.0f, 0.0f ), + Vector( -9999999.0f, -9999999.0f, -9999999.0f ), Vector( 9999999.0f, 9999999.0f, 9999999.0f ), + Vector( 0.0f, 0.0f, 0.0f ), Vector( 0.0f, 0.0f, 0.0f ), + Color( 0, 0, 0, 0 ), Color( 0, 0, 0, 0 ), Color( 0, 0, 0, 0 ), Color (0, 0, 0, 0 ), 1.0, 0.0f, 0.0f, 0.0f ); + } + + CParticleSystem( Vector vecBasePositon, Vector vecBasePositionVariance, float flSize, float flSizeVariance, float flParticlesPerSecond, float flParticlesPerSecondVariance, + float flLifeSpanSeconds, float flLifeSpanSecondsVariance, Vector vecInitialVelocity, Vector vecInitialVelocityVariance, Vector vecVelocityMin, Vector vecVelocityMax, + Vector vecGravityAcceleration, Vector vecGravityAccelerationParticleVariance, + Color colorStart, Color colorStartVariance, Color colorEnd, Color colorEndVariance, float flSharpness, float flSharpnessVariance, float flFlicker, float flFlickerVariance ) + { + SetParticleSystem( vecBasePositon, vecBasePositionVariance, flSize, flSizeVariance, flParticlesPerSecond, flParticlesPerSecondVariance, + flLifeSpanSeconds, flLifeSpanSecondsVariance, vecInitialVelocity, vecInitialVelocityVariance, vecVelocityMin, vecVelocityMax, + vecGravityAcceleration, vecGravityAccelerationParticleVariance, + colorStart, colorStartVariance, colorEnd, colorEndVariance, flSharpness, flSharpnessVariance, flFlicker, flFlickerVariance ); + } + + + void SetParticleSystem( Vector vecBasePositon, Vector vecBasePositionVariance, float flSize, float flSizeVariance, float flParticlesPerSecond, float flParticlesPerSecondVariance, + float flLifeSpanSeconds, float flLifeSpanSecondsVariance, Vector vecInitialVelocity, Vector vecInitialVelocityVariance, Vector vecVelocityMin, Vector vecVelocityMax, + Vector vecGravityAcceleration, Vector vecGravityAccelerationParticleVariance, Color colorStart, Color colorStartVariance, Color colorEnd, Color colorEndVariance, + float flSharpness, float flSharpnessVariance, float flFlicker, float flFlickerVariance ) + { + m_vecBasePosition = vecBasePositon; + m_vecBasePositionVariance = vecBasePositionVariance; + + m_flParticleSize = flSize; + m_flParticleSizeVariance = flSizeVariance; + + m_flParticlesPerSecond = flParticlesPerSecond; + m_flParticlesPerSecondVariance = flParticlesPerSecondVariance; + + m_flParticleLifeSpanSeconds = flLifeSpanSeconds; + m_flParticleLifeSpanSecondsVariance = flLifeSpanSecondsVariance; + + m_vecParticleInitialVelocity = vecInitialVelocity; + m_vecParticleInitialVelocityVariance = vecInitialVelocityVariance; + + m_vecVelocityMin = vecVelocityMin; + m_vecVelocityMax = vecVelocityMax; + + m_vecGravityAcceleration = vecGravityAcceleration; + m_vecGravityAccelerationParticleVariance = vecGravityAccelerationParticleVariance; + + m_colorStartRGBA = colorStart; + m_colorStartRGBAVariance = colorStartVariance; + + m_colorEndRGBA = colorEnd; + m_colorEndRGBAVariance = colorEndVariance; + + m_flSharpness = flSharpness; + m_flSharpnessVariance = flSharpnessVariance; + + m_flFlicker = flFlicker; + m_flFlickerVariance = flFlickerVariance; + } + + + bool operator==( const CParticleSystem &rhs ) const + { + if ( m_vecBasePosition != rhs.m_vecBasePosition ) + return false; + + if ( m_vecBasePositionVariance != rhs.m_vecBasePositionVariance ) + return false; + + if ( m_flParticleSize != rhs.m_flParticleSize ) + return false; + + if ( m_flParticleSizeVariance != rhs.m_flParticleSizeVariance ) + return false; + + if ( m_flParticlesPerSecond != rhs.m_flParticlesPerSecond ) + return false; + + if ( m_flParticlesPerSecondVariance != rhs.m_flParticlesPerSecondVariance ) + return false; + + if ( m_flParticleLifeSpanSeconds != rhs.m_flParticleLifeSpanSeconds ) + return false; + + if ( m_flParticleLifeSpanSecondsVariance != rhs.m_flParticleLifeSpanSecondsVariance ) + return false; + + if ( m_vecParticleInitialVelocity != rhs.m_vecParticleInitialVelocity ) + return false; + + if ( m_vecParticleInitialVelocityVariance != rhs.m_vecParticleInitialVelocityVariance ) + return false; + + if ( m_vecGravityAcceleration != rhs.m_vecGravityAcceleration ) + return false; + + if ( m_vecGravityAccelerationParticleVariance != rhs.m_vecGravityAccelerationParticleVariance ) + return false; + + if ( m_colorStartRGBA != rhs.m_colorStartRGBA ) + return false; + + if ( m_colorStartRGBAVariance != rhs.m_colorStartRGBAVariance ) + return false; + + if ( m_colorEndRGBA != rhs.m_colorEndRGBA ) + return false; + + if ( m_colorEndRGBAVariance != rhs.m_colorEndRGBAVariance ) + return false; + + if ( m_flSharpness != rhs.m_flSharpness ) + return false; + + if ( m_flSharpnessVariance != rhs.m_flSharpnessVariance ) + return false; + + if ( m_flFlicker != rhs.m_flFlicker ) + return false; + + if ( m_flFlickerVariance != rhs.m_flFlickerVariance ) + return false; + + if ( m_vecVelocityMin != rhs.m_vecVelocityMin ) + return false; + + if ( m_vecVelocityMax != rhs.m_vecVelocityMax ) + return false; + + return true; + } + + void Interpolate( float flProgress, CParticleSystem &target ) + { + m_vecBasePosition.x = Lerp( flProgress, m_vecBasePosition.x, target.m_vecBasePosition.x ); + m_vecBasePosition.y = Lerp( flProgress, m_vecBasePosition.y, target.m_vecBasePosition.y ); + m_vecBasePosition.z = Lerp( flProgress, m_vecBasePosition.z, target.m_vecBasePosition.z ); + + m_vecBasePositionVariance.x = Lerp( flProgress, m_vecBasePositionVariance.x, target.m_vecBasePositionVariance.x ); + m_vecBasePositionVariance.y = Lerp( flProgress, m_vecBasePositionVariance.y, target.m_vecBasePositionVariance.y ); + m_vecBasePositionVariance.z = Lerp( flProgress, m_vecBasePositionVariance.z, target.m_vecBasePositionVariance.z ); + + m_flParticleSize = Lerp( flProgress, m_flParticleSize, target.m_flParticleSize ); + m_flParticleSizeVariance = Lerp( flProgress, m_flParticleSizeVariance, target.m_flParticleSizeVariance ); + + m_flParticlesPerSecond = Lerp( flProgress, m_flParticlesPerSecond, target.m_flParticlesPerSecond ); + m_flParticlesPerSecondVariance = Lerp( flProgress, m_flParticlesPerSecondVariance, target.m_flParticlesPerSecondVariance ); + + m_vecParticleInitialVelocity.x = Lerp( flProgress, m_vecParticleInitialVelocity.x, target.m_vecParticleInitialVelocity.x ); + m_vecParticleInitialVelocity.y = Lerp( flProgress, m_vecParticleInitialVelocity.y, target.m_vecParticleInitialVelocity.y ); + m_vecParticleInitialVelocity.z = Lerp( flProgress, m_vecParticleInitialVelocity.z, target.m_vecParticleInitialVelocity.z ); + + m_vecParticleInitialVelocityVariance.x = Lerp( flProgress, m_vecParticleInitialVelocityVariance.x, target.m_vecParticleInitialVelocityVariance.x ); + m_vecParticleInitialVelocityVariance.y = Lerp( flProgress, m_vecParticleInitialVelocityVariance.y, target.m_vecParticleInitialVelocityVariance.y ); + m_vecParticleInitialVelocityVariance.z = Lerp( flProgress, m_vecParticleInitialVelocityVariance.z, target.m_vecParticleInitialVelocityVariance.z ); + + m_vecVelocityMin.x = Lerp( flProgress, m_vecVelocityMin.x, target.m_vecVelocityMin.x ); + m_vecVelocityMin.y = Lerp( flProgress, m_vecVelocityMin.y, target.m_vecVelocityMin.y ); + + m_vecVelocityMax.x = Lerp( flProgress, m_vecVelocityMax.x, target.m_vecVelocityMax.x ); + m_vecVelocityMax.y = Lerp( flProgress, m_vecVelocityMax.y, target.m_vecVelocityMax.y ); + + m_vecGravityAcceleration.x = Lerp( flProgress, m_vecGravityAcceleration.x, target.m_vecGravityAcceleration.x ); + m_vecGravityAcceleration.y = Lerp( flProgress, m_vecGravityAcceleration.y, target.m_vecGravityAcceleration.y ); + m_vecGravityAcceleration.z = Lerp( flProgress, m_vecGravityAcceleration.z, target.m_vecGravityAcceleration.z ); + + m_vecGravityAccelerationParticleVariance.x = Lerp( flProgress, m_vecGravityAccelerationParticleVariance.x, target.m_vecGravityAccelerationParticleVariance.x ); + m_vecGravityAccelerationParticleVariance.y = Lerp( flProgress, m_vecGravityAccelerationParticleVariance.y, target.m_vecGravityAccelerationParticleVariance.y ); + m_vecGravityAccelerationParticleVariance.z = Lerp( flProgress, m_vecGravityAccelerationParticleVariance.z, target.m_vecGravityAccelerationParticleVariance.z ); + + m_colorStartRGBA.SetColor( + Lerp( flProgress, m_colorStartRGBA.r(), target.m_colorStartRGBA.r() ), + Lerp( flProgress, m_colorStartRGBA.g(), target.m_colorStartRGBA.g() ), + Lerp( flProgress, m_colorStartRGBA.b(), target.m_colorStartRGBA.b() ), + Lerp( flProgress, m_colorStartRGBA.a(), target.m_colorStartRGBA.a() ) + ); + + m_colorStartRGBAVariance.SetColor( + Lerp( flProgress, m_colorStartRGBAVariance.r(), target.m_colorStartRGBAVariance.r() ), + Lerp( flProgress, m_colorStartRGBAVariance.g(), target.m_colorStartRGBAVariance.g() ), + Lerp( flProgress, m_colorStartRGBAVariance.b(), target.m_colorStartRGBAVariance.b() ), + Lerp( flProgress, m_colorStartRGBAVariance.a(), target.m_colorStartRGBAVariance.a() ) + ); + + m_colorEndRGBA.SetColor( + Lerp( flProgress, m_colorEndRGBA.r(), target.m_colorEndRGBA.r() ), + Lerp( flProgress, m_colorEndRGBA.g(), target.m_colorEndRGBA.g() ), + Lerp( flProgress, m_colorEndRGBA.b(), target.m_colorEndRGBA.b() ), + Lerp( flProgress, m_colorEndRGBA.a(), target.m_colorEndRGBA.a() ) + ); + + m_colorEndRGBAVariance.SetColor( + Lerp( flProgress, m_colorEndRGBAVariance.r(), target.m_colorEndRGBAVariance.r() ), + Lerp( flProgress, m_colorEndRGBAVariance.g(), target.m_colorEndRGBAVariance.g() ), + Lerp( flProgress, m_colorEndRGBAVariance.b(), target.m_colorEndRGBAVariance.b() ), + Lerp( flProgress, m_colorEndRGBAVariance.a(), target.m_colorEndRGBAVariance.a() ) + ); + + m_flSharpness = Lerp( flProgress, m_flSharpness, target.m_flSharpness ); + m_flSharpnessVariance = Lerp( flProgress, m_flSharpnessVariance, target.m_flSharpnessVariance ); + + m_flFlicker = Lerp( flProgress, m_flFlicker, target.m_flFlicker ); + m_flFlickerVariance = Lerp( flProgress, m_flFlickerVariance, target.m_flFlickerVariance ); + + } + + void ScaleLengthValues( float flScaleFactor ) + { + // Scale all X/Y size/position values + m_vecBasePosition.x *= flScaleFactor; + m_vecBasePosition.y *= flScaleFactor; + + m_vecBasePositionVariance.x *= flScaleFactor; + m_vecBasePositionVariance.y *= flScaleFactor; + + m_flParticleSize *= flScaleFactor; + m_flParticleSizeVariance *= flScaleFactor; + + m_vecParticleInitialVelocity.x *= flScaleFactor; + m_vecParticleInitialVelocity.y *= flScaleFactor; + + m_vecParticleInitialVelocityVariance.x *= flScaleFactor; + m_vecParticleInitialVelocityVariance.y *= flScaleFactor; + + m_vecGravityAcceleration.x *= flScaleFactor; + m_vecGravityAcceleration.y *= flScaleFactor; + + m_vecGravityAccelerationParticleVariance.x *= flScaleFactor; + m_vecGravityAccelerationParticleVariance.y *= flScaleFactor; + + m_vecVelocityMin.x *= flScaleFactor; + m_vecVelocityMin.y *= flScaleFactor; + + m_vecVelocityMax.x *= flScaleFactor; + m_vecVelocityMax.y *= flScaleFactor; + } + + Vector GetBasePosition() const + { + return m_vecBasePosition; + } + + Vector GetBasePositionVariance() const + { + return m_vecBasePositionVariance; + } + + float GetParticleSize() const + { + return m_flParticleSize; + } + + float GetParticleSizeVariance() const + { + return m_flParticleSizeVariance; + } + + float GetParticlesPerSecond() const + { + return m_flParticlesPerSecond; + } + + float GetParticlesPerSecondVariance() const + { + return m_flParticlesPerSecondVariance; + } + + float GetParticleLifeSpanSeconds() const + { + return m_flParticleLifeSpanSeconds; + } + + float GetParticleLifeSpanSecondsVariance() const + { + return m_flParticleLifeSpanSecondsVariance; + } + + Vector GetParticleInitialVelocity() const + { + return m_vecParticleInitialVelocity; + } + + Vector GetParticleInitialVelocityVariance() const + { + return m_vecParticleInitialVelocityVariance; + } + + Vector GetParticleVelocityMin() const + { + return m_vecVelocityMin; + } + + Vector GetParticleVelocityMax() const + { + return m_vecVelocityMax; + } + + Vector GetGravityAcceleration() const + { + return m_vecGravityAcceleration; + } + + Vector GetGravityAccelerationParticleVariance() const + { + return m_vecGravityAccelerationParticleVariance; + } + + Color GetStartColor() const + { + return m_colorStartRGBA; + } + + Color GetStartColorVariance() const + { + return m_colorStartRGBAVariance; + } + + Color GetEndColor() const + { + return m_colorEndRGBA; + } + + Color GetEndColorVariance() const + { + return m_colorEndRGBAVariance; + } + + float GetSharpness() const + { + return m_flSharpness; + } + + float GetSharpnessVariance() const + { + return m_flSharpnessVariance; + } + + float GetFlicker() const + { + return m_flFlicker; + } + + float GetFlickerVariance() const + { + return m_flFlickerVariance; + } + +#ifdef DBGFLAG_VALIDATE + virtual void Validate( CValidator &validator, const tchar *pchName ) + { + VALIDATE_SCOPE(); + } +#endif + +private: + + Vector m_vecBasePosition; + Vector m_vecBasePositionVariance; + + float m_flParticleSize; + float m_flParticleSizeVariance; + + float m_flParticlesPerSecond; + float m_flParticlesPerSecondVariance; + + float m_flParticleLifeSpanSeconds; + float m_flParticleLifeSpanSecondsVariance; + + Vector m_vecParticleInitialVelocity; + Vector m_vecParticleInitialVelocityVariance; + + Vector m_vecVelocityMin; + Vector m_vecVelocityMax; + + Vector m_vecGravityAcceleration; + Vector m_vecGravityAccelerationParticleVariance; + + Color m_colorStartRGBA; + Color m_colorStartRGBAVariance; + + Color m_colorEndRGBA; + Color m_colorEndRGBAVariance; + + float m_flSharpness; + float m_flSharpnessVariance; + + float m_flFlicker; + float m_flFlickerVariance; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Represents a linear gradient +//----------------------------------------------------------------------------- +class CLinearGradient +{ +public: + CLinearGradient() + { + m_StartPoint[0].SetLength( 0.0 ); + m_StartPoint[1].SetLength( 0.0 ); + m_EndPoint[0].SetLength( 0.0 ); + m_EndPoint[1].SetLength( 0.0 ); + } + + CLinearGradient( CUILength StartX, CUILength StartY, CUILength EndX, CUILength EndY, const CUtlVector<CGradientColorStop> &vecStopColors ) + { + SetGradient( StartX, StartY, EndX, EndY, vecStopColors ); + } + + void SetGradient( CUILength StartX, CUILength StartY, CUILength EndX, CUILength EndY, const CUtlVector<CGradientColorStop> &vecStopColors ) + { + m_StartPoint[0] = StartX; + m_StartPoint[1] = StartY; + m_EndPoint[0] = EndX; + m_EndPoint[1] = EndY; + + m_vecStops.AddMultipleToTail( vecStopColors.Count(), vecStopColors.Base() ); + } + + void SetControlPoints( CUILength StartX, CUILength StartY, CUILength EndX, CUILength EndY ) + { + m_StartPoint[0] = StartX; + m_StartPoint[1] = StartY; + m_EndPoint[0] = EndX; + m_EndPoint[1] = EndY; + } + + void GetStartPoint( CUILength &startX, CUILength &startY ) const + { + startX = m_StartPoint[0]; + startY = m_StartPoint[1]; + } + + void GetEndPoint( CUILength &endX, CUILength &endY ) const + { + endX = m_EndPoint[0]; + endY = m_EndPoint[1]; + } + + const CUtlVector<CGradientColorStop> &AccessStopColors() const + { + return m_vecStops; + } + + CUtlVector<CGradientColorStop> &AccessMutableStopColors() + { + return m_vecStops; + } + + bool operator==( const CLinearGradient &rhs ) const + { + if ( m_StartPoint[0] != rhs.m_StartPoint[0] || m_StartPoint[1] != rhs.m_StartPoint[1] || m_EndPoint[0] != rhs.m_EndPoint[0] || m_EndPoint[1] != rhs.m_EndPoint[1] ) + return false; + + if ( m_vecStops.Count() != rhs.m_vecStops.Count() ) + return false; + + FOR_EACH_VEC( m_vecStops, i ) + { + if ( m_vecStops[i] != rhs.m_vecStops[i] ) + return false; + } + + return true; + } + + void ScaleLengthValues( float flScaleFactor ) + { + m_StartPoint[0].ScaleLengthValue( flScaleFactor ); + m_StartPoint[1].ScaleLengthValue( flScaleFactor ); + m_EndPoint[0].ScaleLengthValue( flScaleFactor ); + m_EndPoint[1].ScaleLengthValue( flScaleFactor ); + } + +#ifdef DBGFLAG_VALIDATE + virtual void Validate( CValidator &validator, const tchar *pchName ) + { + VALIDATE_SCOPE(); + ValidateObj( m_vecStops ); + } +#endif + +private: + + // Start/end point determine angle vector + CUILength m_StartPoint[2]; + CUILength m_EndPoint[2]; + CCopyableUtlVector<CGradientColorStop> m_vecStops; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Represents a radial gradient +//----------------------------------------------------------------------------- +class CRadialGradient +{ +public: + CRadialGradient() + { + m_Center[0].SetLength( 0.0 ); + m_Center[1].SetLength( 0.0 ); + m_Offset[0].SetLength( 0.0 ); + m_Offset[1].SetLength( 0.0 ); + m_Radius[0].SetLength( 0.0 ); + m_Radius[1].SetLength( 0.0 ); + } + + CRadialGradient( CUILength centerX, CUILength centerY, CUILength offsetX, CUILength offsetY, CUILength radiusX, CUILength radiusY, const CUtlVector<CGradientColorStop> &vecStopColors ) + { + SetGradient( centerX, centerY, offsetX, offsetY, radiusX, radiusY, vecStopColors ); + } + + void SetGradient( CUILength centerX, CUILength centerY, CUILength offsetX, CUILength offsetY, CUILength radiusX, CUILength radiusY, const CUtlVector<CGradientColorStop> &vecStopColors ) + { + m_Center[0] = centerX; + m_Center[1] = centerY; + m_Offset[0] = offsetX; + m_Offset[1] = offsetY; + m_Radius[0] = radiusX; + m_Radius[1] = radiusY; + + m_vecStops.AddMultipleToTail( vecStopColors.Count(), vecStopColors.Base() ); + } + + void GetCenterPoint( CUILength ¢erX, CUILength ¢erY ) const + { + centerX = m_Center[0]; + centerY = m_Center[1]; + } + + void GetOffsetDistance( CUILength &offsetX, CUILength &offsetY ) const + { + offsetX = m_Offset[0]; + offsetY = m_Offset[1]; + } + + void GetRadii( CUILength &radiusX, CUILength &radiusY ) const + { + radiusX = m_Radius[0]; + radiusY = m_Radius[1]; + } + + void SetCenterPoint( const CUILength &x, const CUILength &y ) + { + m_Center[0] = x; + m_Center[1] = y; + } + + void SetOffsetDistance( const CUILength &x, const CUILength &y ) + { + m_Offset[0] = x; + m_Offset[1] = y; + } + + void SetRadii( const CUILength &x, const CUILength &y ) + { + m_Radius[0] = x; + m_Radius[1] = y; + } + + const CUtlVector<CGradientColorStop> &AccessStopColors() const + { + return m_vecStops; + } + + CUtlVector<CGradientColorStop> &AccessMutableStopColors() + { + return m_vecStops; + } + + bool operator==( const CRadialGradient &rhs ) const + { + if ( m_Center[0] != rhs.m_Center[0] || m_Center[1] != rhs.m_Center[1] || + m_Offset[0] != rhs.m_Offset[0] || m_Offset[1] != rhs.m_Offset[1] || + m_Radius[0] != rhs.m_Radius[0] || m_Radius[1] != rhs.m_Radius[1] ) + { + return false; + } + + if ( m_vecStops.Count() != rhs.m_vecStops.Count() ) + return false; + + FOR_EACH_VEC( m_vecStops, i ) + { + if ( m_vecStops[i] != rhs.m_vecStops[i] ) + return false; + } + + return true; + } + + void ScaleLengthValues( float flScaleFactor ) + { + m_Center[0].ScaleLengthValue( flScaleFactor ); + m_Center[1].ScaleLengthValue( flScaleFactor ); + m_Offset[0].ScaleLengthValue( flScaleFactor ); + m_Offset[1].ScaleLengthValue( flScaleFactor ); + m_Radius[0].ScaleLengthValue( flScaleFactor ); + m_Radius[1].ScaleLengthValue( flScaleFactor ); + } + +#ifdef DBGFLAG_VALIDATE + virtual void Validate( CValidator &validator, const tchar *pchName ) + { + VALIDATE_SCOPE(); + ValidateObj( m_vecStops ); + } +#endif + +private: + + // Start/end point determine angle vector + CUILength m_Center[2]; + CUILength m_Offset[2]; + CUILength m_Radius[2]; + CCopyableUtlVector<CGradientColorStop> m_vecStops; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Represents a fill color/stroke, may be a gradient +//----------------------------------------------------------------------------- +class CFillBrush +{ +public: + + // Types of strokes we support + enum EStrokeType + { + k_EStrokeTypeFillColor, + k_EStrokeTypeLinearGradient, + k_EStrokeTypeRadialGradient, + k_EStrokeTypeParticleSystem, + }; + + // Default constructor, sets transparent fill color + CFillBrush() + { + m_eType = k_EStrokeTypeFillColor; + m_FillColor.SetColor( 0, 0, 0, 0 ); + } + + // Constructor for standard color fill + CFillBrush( int r, int g, int b, int a ) + { + m_eType = k_EStrokeTypeFillColor; + m_FillColor.SetColor( r, g, b, a ); + } + + // Constructor for linear gradient fill + CFillBrush( CUILength StartX, CUILength StartY, CUILength EndX, CUILength EndY, const CUtlVector<CGradientColorStop> &vecStopColors ) + { + m_eType = k_EStrokeTypeLinearGradient; + m_LinearGradient.SetGradient( StartX, StartY, EndX, EndY, vecStopColors ); + } + + // Constructor for radial gradient + CFillBrush( CUILength centerX, CUILength centerY, CUILength offsetX, CUILength offsetY, CUILength radiusX, CUILength radiusY, const CUtlVector<CGradientColorStop> &vecStopColors ) + { + m_eType = k_EStrokeTypeRadialGradient; + m_RadialGradient.SetGradient( centerX, centerY, offsetX, offsetY, radiusX, radiusY, vecStopColors ); + } + + // Constructor for particle system + CFillBrush( Vector vecBasePositon, Vector vecBasePositionVariance, float flSize, float flSizeVariance, float flParticlesPerSecond, float flParticlesPerSecondVariance, + float flLifeSpanSeconds, float flLifeSpanSecondsVariance, Vector vecInitialVelocity, Vector vecInitialVelocityVariance, Vector vecVelocityMin, Vector vecVelocityMax, + Vector vecGravityAcceleration, Vector vecGravityAccelerationParticleVariance, + Color colorStart, Color colorStartVariance, Color colorEnd, Color colorEndVariance, float flSharpness, float flSharpnessVariance, float flFlicker, float flFlickerVariance ) + { + m_eType = k_EStrokeTypeParticleSystem; + m_ParticleSystem.SetParticleSystem( vecBasePositon, vecBasePositionVariance, flSize, flSizeVariance, flParticlesPerSecond, flParticlesPerSecondVariance, + flLifeSpanSeconds, flLifeSpanSecondsVariance, vecInitialVelocity, vecInitialVelocityVariance, vecVelocityMin, vecVelocityMax, + vecGravityAcceleration, vecGravityAccelerationParticleVariance, + colorStart, colorStartVariance, colorEnd, colorEndVariance, flSharpness, flSharpnessVariance, flFlicker, flFlickerVariance ); + } + + // Get type + EStrokeType GetType() const { return m_eType; } + + // Set to a fill color value + void SetToFillColor( Color color ) + { + m_eType = k_EStrokeTypeFillColor; + m_FillColor = color; + } + + // Get fill color for fill stroke types + Color GetFillColor() const + { + Assert( m_eType == k_EStrokeTypeFillColor ); + return m_FillColor; + } + + // Set brush to a linear gradient value + void SetToLinearGradient( const CUILength &startX, const CUILength &startY, const CUILength &endX, const CUILength &endY, const CUtlVector<CGradientColorStop> &vecColorStops ) + { + m_eType = k_EStrokeTypeLinearGradient; + m_LinearGradient.SetGradient( startX, startY, endX, endY, vecColorStops ); + } + + // Set to a radial gradient value + void SetToRadialGradient( CUILength centerX, CUILength centerY, CUILength offsetX, CUILength offsetY, CUILength radiusX, CUILength radiusY, const CUtlVector<CGradientColorStop> &vecStopColors ) + { + m_eType = k_EStrokeTypeRadialGradient; + m_RadialGradient.SetGradient( centerX, centerY, offsetX, offsetY, radiusX, radiusY, vecStopColors ); + } + + // Set to particle system value + void SetToParticleSystem( Vector vecBasePositon, Vector vecBasePositionVariance, float flSize, float flSizeVariance, float flParticlesPerSecond, float flParticlesPerSecondVariance, + float flLifeSpanSeconds, float flLifeSpanSecondsVariance, Vector vecInitialVelocity, Vector vecInitialVelocityVariance, Vector vecVelocityMin, Vector vecVelocityMax, + Vector vecGravityAcceleration, Vector vecGravityAccelerationParticleVariance, + Color colorStart, Color colorStartVariance, Color colorEnd, Color colorEndVariance, float flSharpness, float flSharpnessVariance, float flFlicker, float flFlickerVariance ) + { + m_eType = k_EStrokeTypeParticleSystem; + m_ParticleSystem.SetParticleSystem( vecBasePositon, vecBasePositionVariance, flSize, flSizeVariance, flParticlesPerSecond, flParticlesPerSecondVariance, + flLifeSpanSeconds, flLifeSpanSecondsVariance, vecInitialVelocity, vecInitialVelocityVariance, vecVelocityMin, vecVelocityMax, vecGravityAcceleration, vecGravityAccelerationParticleVariance, + colorStart, colorStartVariance, colorEnd, colorEndVariance, flSharpness, flSharpnessVariance, flFlicker, flFlickerVariance ); + } + + // Get start/end pos for linear gradient types + void GetStartAndEndPoints( CUILength &StartX, CUILength &StartY, CUILength &EndX, CUILength &EndY ) const + { + Assert( m_eType == k_EStrokeTypeLinearGradient ); + m_LinearGradient.GetStartPoint( StartX, StartY ); + m_LinearGradient.GetEndPoint( EndX, EndY ); + } + + // Access start/end pos for linear or radial gradient types + const CUtlVector<CGradientColorStop> &AccessStopColors() const + { + Assert( m_eType == k_EStrokeTypeLinearGradient || m_eType == k_EStrokeTypeRadialGradient ); + if ( m_eType == k_EStrokeTypeLinearGradient ) + return m_LinearGradient.AccessStopColors(); + + if ( m_eType == k_EStrokeTypeRadialGradient ) + return m_RadialGradient.AccessStopColors(); + + // Otherwise this is bad, let's just return the hopefully empty linear vector + return m_LinearGradient.AccessStopColors(); + } + + // Get start/end pos for linear gradient types + void GetRadialGradientValues( CUILength ¢erX, CUILength ¢erY, CUILength &offsetX, CUILength &offsetY, CUILength &radiusX, CUILength &radiusY ) const + { + Assert( m_eType == k_EStrokeTypeRadialGradient ); + m_RadialGradient.GetCenterPoint( centerX, centerY ); + m_RadialGradient.GetOffsetDistance( offsetX, offsetY ); + m_RadialGradient.GetRadii( radiusX, radiusY ); + } + + CParticleSystem * AccessParticleSystem() + { + Assert( m_eType == k_EStrokeTypeParticleSystem ); + return &m_ParticleSystem; + } + + bool Interpolate( float flActualWidth, float flActualHeight, CFillBrush &target, float flProgress ); + + bool operator==( const CFillBrush &rhs ) const + { + if ( m_eType != rhs.m_eType ) + return false; + + switch( m_eType ) + { + case k_EStrokeTypeFillColor: + return m_FillColor == rhs.m_FillColor; + case k_EStrokeTypeLinearGradient: + return m_LinearGradient == rhs.m_LinearGradient; + case k_EStrokeTypeRadialGradient: + return m_RadialGradient == rhs.m_RadialGradient; + case k_EStrokeTypeParticleSystem: + return m_ParticleSystem == rhs.m_ParticleSystem; + default: + AssertMsg( false, "Invalid type on fillbrush" ); + return false; + } + } + + bool operator!=( const CFillBrush &rhs ) const + { + return !( *this == rhs ); + } + + void ScaleLengthValues( float flScaleFactor ) + { + if ( m_eType == k_EStrokeTypeLinearGradient ) + m_LinearGradient.ScaleLengthValues( flScaleFactor ); + else if ( m_eType == k_EStrokeTypeRadialGradient ) + m_RadialGradient.ScaleLengthValues( flScaleFactor ); + else if ( m_eType == k_EStrokeTypeParticleSystem ) + m_ParticleSystem.ScaleLengthValues( flScaleFactor ); + + } + +#ifdef DBGFLAG_VALIDATE + virtual void Validate( CValidator &validator, const tchar *pchName ) + { + VALIDATE_SCOPE(); + ValidateObj( m_LinearGradient ); + ValidateObj( m_RadialGradient ); + ValidateObj( m_ParticleSystem ); + } +#endif +private: + + void ConvertToRadialGradient(); + void ConvertToLinearGradient(); + void NormalizeStopCount( CUtlVector<CGradientColorStop> &vec, int nStopsNeeded, Color defaultColor ); + + EStrokeType m_eType; + + Color m_FillColor; + CLinearGradient m_LinearGradient; + CRadialGradient m_RadialGradient; + CParticleSystem m_ParticleSystem; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Represents a collection of fill brushes, when filling geometry with +// such a collection they should be applied in order and blended appropriately. +//----------------------------------------------------------------------------- +#define MAX_FILL_BRUSHES_PER_COLLECTION 8 +class CFillBrushCollection +{ +public: + + + struct FillBrush_t + { + CFillBrush m_Brush; + float m_Opacity; + + bool operator==( const FillBrush_t &rhs ) const { return (m_Brush == rhs.m_Brush && m_Opacity == rhs.m_Opacity); } + bool operator!=( const FillBrush_t &rhs ) const { return !(*this == rhs ); } + }; + + CFillBrushCollection() { } + + // Get brush count + uint32 GetBrushCount() const { return m_vecFillBrushes.Count(); } + + // Access brush vector directly + CUtlVectorFixed< FillBrush_t, MAX_FILL_BRUSHES_PER_COLLECTION > &AccessBrushes() { return m_vecFillBrushes; } + const CUtlVectorFixed< FillBrush_t, MAX_FILL_BRUSHES_PER_COLLECTION> &AccessBrushes() const { return m_vecFillBrushes; } + + // Add brush to collection + void AddFillBrush( const CFillBrush &brush, float opacity = 1.0 ) + { + + int i = m_vecFillBrushes.AddToTail(); + m_vecFillBrushes[i].m_Brush = brush; + m_vecFillBrushes[i].m_Opacity = opacity; + } + + void ScaleLengthValues( float flScaleFactor ) + { + FOR_EACH_VEC( m_vecFillBrushes, i ) + { + m_vecFillBrushes[i].m_Brush.ScaleLengthValues( flScaleFactor ); + } + } + + int GetNumParticleSystems() + { + int nParticleSystems = 0; + FOR_EACH_VEC( m_vecFillBrushes, i ) + { + if ( m_vecFillBrushes[i].m_Brush.GetType() == CFillBrush::k_EStrokeTypeParticleSystem ) + ++nParticleSystems; + } + + return nParticleSystems; + } + + void Clear() + { + m_vecFillBrushes.RemoveAll(); + } + + // Interpolate between two fill brushes + void Interpolate( float flActualWidth, float flActualHeight, const CFillBrushCollection &target, float flProgress ); + bool operator==( const CFillBrushCollection &rhs ) const; + +#ifdef DBGFLAG_VALIDATE + void Validate( CValidator &validator, const tchar *pchName ) + { + VALIDATE_SCOPE(); + ValidateObj( m_vecFillBrushes ); + FOR_EACH_VEC( m_vecFillBrushes, i ) + { + ValidateObj( m_vecFillBrushes[i].m_Brush ); + } + } +#endif + +private: + + CCopyableUtlVectorFixed< FillBrush_t, MAX_FILL_BRUSHES_PER_COLLECTION > m_vecFillBrushes; +}; + +} // namespace panorama + +#endif // FILLBRUSH_H
\ No newline at end of file |