Legend.LegendUtil

//=============================================================================
// Util.uc
// $Author: Mfox $
// $Date: 8/05/02 12:29p $
// $Revision: 2 $
//=============================================================================

class LegendUtil extends LegendObjectComponent
	abstract;


//------------------------------------------------------------------------------

static function DrawQuickLine
(
	Actor				Helper,		// pass in self.
	optional vector		Start,
	optional vector		End,
	optional Actor		StartActor,
	optional Actor		EndActor,
	optional float		SpriteInterval,
	optional float		SpriteSize,
	optional Texture	SpriteTexture,
	optional float		Duration
)
{
	local Line Line;

	local vector A, B;
	local float Length;

	if( Helper == None ) return;
	
	// Stupidity check.
	if( (StartActor == None || EndActor == None) && Start == End )
	{
		Helper.warn( "Invalid parameters." );
	}

	Line = Helper.Spawn( class'Line' );

	Line.SetEndpoints( Start, End );
	Line.SetFollowActors( StartActor, EndActor );
	
	if( StartActor != None )
		A = StartActor.Location;
	else
		A = Start;
	
	if( EndActor != None )
		B = EndActor.Location;
	else
		B = End;

	Length = VSize(A - B);
	
	if( SpriteInterval > 0.0 )
		Line.SegmentLength = SpriteInterval;
	else
		Line.SegmentLength = FClamp( Length / 50.0, 0.5, 16.0 );

	if( SpriteSize > 0.0 )
		Line.SetDrawScale( SpriteSize );
	else
		Line.SetDrawScale( FClamp( Length / 400.0, 0.01, 2.0 ) );
	
	if( SpriteTexture != None )
		Line.Texture = SpriteTexture;
	else
		Line.Texture = Texture(DynamicLoadObject( "ParticleSystems.Sparks01", class'Texture' ));	//!!hardcoded texture

	Line.LifeSpan = Duration;
}


//-----------------------------------------------------------------------------
// Draws a line made of sprites (or dots) that can optionally fade out.
// Used primarily for debugging. Quite a bit slower to generate and render than
// DrawLine (virtually unusable if many lines and may even crash renderer).
//-----------------------------------------------------------------------------

static function DrawLine3D
(
	Actor Helper, vector Start, vector End, 
	optional float FadeDuration,			// Amount of time to fade the line out over.
	optional float DotInterval,				// Space between consecutive dots in a line.
	optional Texture DotTexture,			// Texture to use to draw the dots in the line.
	optional float DelayTime				// How long to wait before actually drawing the line.
)
{
	local Line3D Line;

	Line = Helper.Spawn( class'Line3D' );
	Line.LineDuration = FadeDuration;
	if( DotTexture != None )
	{
		Line.LineTexture = DotTexture;
	}
	if( DotInterval > 0.0 )
	{
		Line.DotInterval = DotInterval;
	}
	Line.SetEndpoints( Start, End );
	Line.ReDraw( DelayTime );
}

//-----------------------------------------------------------------------------
// Draws a permanent, easily visible line from Start to End. Mainly useful for
// debugging calls to Trace etc. Quite a bit faster to generate and render than
// DrawLine3D but can still slow things to crawl if there are many of these.
//-----------------------------------------------------------------------------

static function DrawLine
(
	Actor			Owner,
	vector 			Start,
	vector          End,
	optional		Texture SkinToUse
)
{
	local LineStreak LS;
	local LineStreakVert LSV;

	LS	= Owner.Spawn( class'LineStreak' );
	LSV	= Owner.Spawn( class'LineStreakVert' );

	LS.SetEndPoints( Start, End ); 
	LSV.SetEndPoints( Start, End ); 

	if( SkinToUse != None )
	{
		LS.SetSkin( SkinToUse );
		LSV.SetSkin( SkinToUse );
	}
}


//-----------------------------------------------------------------------------
// Use this to fade objects out instead of just Destroy()ing them. Note that
// in multiplayer games fading is not performed for now, instead, after the
// DelayTime, the object is destroyed after FadeTime additional seconds.
//-----------------------------------------------------------------------------
// Other:				The Actor to fade away.
// FadeTime:			How long it takes to fade the object away.					(Defaults to Fader's default FadeTime value.)
// bNoDeleteActor:		When we finish fading the object out, should we delete it?	(Deletes it by default.)
// InitialScaleGlow:	The ScaleGlow the Actor starts with.						(Defaults to the Actor's current ScaleGlow value.)
// FinalScaleGlow:		The ScaleGlow the Actor ends with.							(Defaults to Fader's default FinalScaleGlow value (0).) - Must be less than InitialScaleGlow.
// DelayTime:			Time to wait before starting to fade.						(Defaults to 0.0 seconds)
// NumFlickers:			Number of times to "flicker" before fading                  (Defaults to 0)
//-----------------------------------------------------------------------------

static simulated function Fade( Actor Other, optional float FadeTime, optional bool bNoDeleteActor, optional float InitialScaleGlow, optional float FinalScaleGlow, optional float DelayTime, optional int NumFlickers )
{
	local Fader F;

	if( Other != None )
	{
		F = Other.Spawn( class'Fader' );
		
		if( FadeTime > 0.0 )
		{
			F.FadeTime = FadeTime;
		}

		F.bDeleteActor = !bNoDeleteActor;

		if( InitialScaleGlow > 0.0 )
		{
			F.InitialScaleGlow = InitialScaleGlow;
		}

		if( FinalScaleGlow > 0.0 )
		{
			F.FinalScaleGlow = FinalScaleGlow;
		}

		F.DelayTime = DelayTime;
		
		F.NumFlickers = NumFlickers;

		F.Fade( Other );
	}
}

//-----------------------------------------------------------------------------
// Same as trace, but draws a line from the start location to the end location.
//-----------------------------------------------------------------------------

static function Actor VisibleTrace
(
	Actor			TraceFromActor,
	out vector      HitLocation,
	out vector      HitNormal,
	vector          TraceEnd,
	optional vector TraceStart,
	optional bool   bTraceActors,
	optional vector Extent
)
{
	DrawLine( TraceFromActor, TraceStart, TraceEnd );

	return TraceFromActor.Trace( HitLocation, HitNormal, TraceEnd, TraceStart, bTraceActors, Extent );
}

//-----------------------------------------------------------------------------
// Draw a line from the given player's eyes along his line of sight.
//-----------------------------------------------------------------------------

static function DrawViewLine( Pawn P )
{
	local vector StartTrace, EndTrace;

	StartTrace		= P.Location; 
	StartTrace.Z   += P.BaseEyeHeight;
	
	EndTrace = StartTrace + 32767 * vector(P.GetViewRotation() );

	DrawLine( P, StartTrace, EndTrace );
}

defaultproperties
{
}