Engine.ShadowProjector

//
//	ShadowProjector
//

class ShadowProjector extends Projector;

var() Actor		ShadowActor;
var() vector	LightDirection;
var() float		LightDistance;
var() float		InterpolateRate;
var() float		BoundScale;
var() int		ShadowResolution;
var() bool		bBlobShadow;
var() bool		bForceFullPolyShadow;
var() bool		bForceBlobShadow;
var() bool		bShadowActive;
var() bool		bAlwaysAllocate;
var() bool		bBlurShadow;
var() bool		bStaticLights;		// light sourced via static lights.
var() bool		bDynamicLights;		// light sourced via dynamic lights.

var ShadowBitmapMaterial	ShadowTexture;
var float					LastRenderTime;
var float					LastLightDistance;

//
//	PostBeginPlay
//

event PostBeginPlay()
{
	Super(Actor).PostBeginPlay();
}

//
//	Destroyed
//

event Destroyed()
{
	if(ShadowTexture != None)
	{
		ShadowTexture.ShadowActor = None;

		if(!ShadowTexture.Invalid)
			Level.ObjectPool.FreeObject(ShadowTexture);

		ShadowTexture = None;
		ProjTexture = None;
	}

	Super.Destroyed();
}

//
//	InitShadow
//

function InitShadow()
{
	local Plane		BoundingSphere;

	if(ShadowActor != None)
	{
		// Attach the shadow projector with the blob texture until the first time it's rendered.

		BoundingSphere = ShadowActor.GetRenderBoundingSphere();

		FOV = Max(1, Atan2(BoundingSphere.W * 2 + BoundScale, LightDistance) * 180 / PI);

		if(bAlwaysAllocate)
		{
			Level.ObjectPool.FreeObject(Level.ObjectPool.AllocateObject(class'ShadowBitmapMaterial',Level));
			PreRender();
		}

		Enable('Tick');
		UpdateShadow();
	}
	else
		Log(Name$".InitShadow: No actor");
}

//
//	UpdateShadow
//

function UpdateShadow(optional float DeltaTime)
{
	local coords	C;
	local bool		bSuccess;

	DetachProjector(true);

	if(ShadowActor != None && !ShadowActor.bHidden)
	{
		bSuccess = CalcPos(DeltaTime);

		if(Level.TimeSeconds > LastRenderTime + 1.0f && ShadowTexture != None)
		{
			Level.ObjectPool.FreeObject(ShadowTexture);
			ShadowTexture = None;
			ProjTexture = class'ShadowBitmapMaterial'.default.BlobShadow;
		}

		if(ShadowTexture != None)
		{
			ShadowTexture.Dirty = true;
			ProjTexture = ShadowTexture;
		}
		else
			ProjTexture = class'ShadowBitmapMaterial'.default.BlobShadow;

		if(!bSuccess && ShadowTexture != None)	// Fix ARL: It would be better just to not reattach, but then it never gets updated again.
		{
			Level.ObjectPool.FreeObject(ShadowTexture);
			ShadowTexture = None;
			ProjTexture = None;
		}

		AttachProjector();
	}
}

//
// CalcPos: Precondition(ShadowActor != None)
//

function bool CalcPos(float DeltaTime)
{
	local float Pct;
	local float Dist;
	local vector Diff;
	local vector LightLoc;
	local rotator LightRot;
	local Actor LightSource;
	local bool bAttach;

	// Update projector location.
	if(ShadowTexture != None)
		SetLocation(ShadowTexture.GetShadowLocation());
	else
	{
		SetLocation(ShadowActor.Location + vect(0,0,5));
		SetRotation(Rotator(Normal(-LightDirection)));
		return true;
	}

	// Get proper light source.
	if(bStaticLights)
	{
		LightSource = ShadowActor.PrimaryStaticLight;
		if(!LightSource)
			return false;
	}
	if(bDynamicLights)
	{
		LightSource = ShadowActor.PrimaryDynamicLight;
		if(!LightSource)
			return false;
	}

	// Handle non-lightsourced rotation.
	if(!LightSource)
	{
		ShadowTexture.LightDirection = Normal(LightDirection);
		ShadowTexture.LightDistance = LightDistance;
		ShadowTexture.FrustumOrigin = Location + ShadowTexture.LightDirection * ShadowTexture.LightDistance;
		SetRotation(Rotator(Normal(-LightDirection)));
		return true;
	}

	// Calculate light position.
	if(LightSource.LightEffect == LE_Sunlight)
	{
		Dist = 1024;
		LightRot = LightSource.Rotation;
	}
	else
	{
		Diff = Location - LightSource.Location;
		Dist = FMin( VSize(Diff), 1024 );
		if(Dist>0)	LightRot = Rotator(Diff);
		else		LightRot = LightSource.Rotation;
	}
	LightLoc = Location - Vector(LightRot) * Dist;

	// Interpolate from last light position (in case we've switched to a new light).
	Pct = FMin(1.0, (DeltaTime * InterpolateRate));
	ShadowTexture.FrustumOrigin += (LightLoc - ShadowTexture.FrustumOrigin) * Pct;
	Diff = Location - ShadowTexture.FrustumOrigin;
	LightRot = Rotator(Diff);	// recalc so we're always facing our caster.
	SetRotation(LightRot);
	SetLightDistance(VSize(Diff),LightSource.LightEffect == LE_Sunlight);
	LightDirection = -Vector(LightRot) * LightDistance;
	ShadowTexture.LightDirection = Normal(LightDirection);
	ShadowTexture.LightDistance = LightDistance;

	return true;
}

//
// SetLightDistance: Precondition(ShadowTexture != None && ShadowActor != None)
//

function SetLightDistance(float Dist,optional bool bSunlight)
{
	local Plane BoundingSphere;
	LightDistance = Dist;
	if(LightDistance != LastLightDistance)
	{
		LastLightDistance = LightDistance;
		BoundingSphere = ShadowActor.GetRenderBoundingSphere();
		FOV = Max(1, Atan2(BoundingSphere.W * 2 + BoundScale, LightDistance) * 180 / PI);
		ShadowTexture.LightDistance = LightDistance;
		ShadowTexture.LightFOV = FOV;
		if(bSunlight)	SetDrawScale((BoundingSphere.W * 2.0) / ShadowTexture.USize);
		else			SetDrawScale(LightDistance * tan(0.5 * FOV * PI / 180) / (0.5 * ShadowTexture.USize));
	}
}

//
//	PreRender
//

event PreRender()
{
	if(ShadowTexture == None)
	{
		// The first time the shadow projector is rendered, allocate the actual shadow texture.

//NOTE[aleiby]: RenderTargets allocated mid-game are useless since they aren't precached often kill performance.
//		if(bAlwaysAllocate)
//			ShadowTexture = ShadowBitmapMaterial(Level.ObjectPool.AllocateObject(class'ShadowBitmapMaterial',Level));
//		else
			ShadowTexture = ShadowBitmapMaterial(Level.ObjectPool.GetObject(class'ShadowBitmapMaterial'));

		if(!ShadowTexture)
			ShadowTexture = ShadowBitmapMaterial(Level.ObjectPool.AllocateObject(class'ShadowBitmapMaterialFallback',Level));

		ProjTexture = ShadowTexture;

		if(ShadowTexture != None)
		{
			if(bForceBlobShadow)
				bBlobShadow = true;
			if(bForceFullPolyShadow)
				bBlobShadow = false;

			ShadowTexture.bBlobShadow = bBlobShadow;
			ShadowTexture.bBlurShadow = bBlurShadow;
			ShadowTexture.ShadowActor = ShadowActor;
			ShadowTexture.LightDirection = Normal(LightDirection);
			ShadowTexture.LightDistance = LightDistance;
			ShadowTexture.LightFOV = FOV;
			ShadowTexture.SetRes(ShadowResolution);
			ShadowTexture.CullDistance = VisibilityRadius;
			ShadowTexture.Dirty = true;

			SetDrawScale(LightDistance * tan(0.5 * FOV * PI / 180) / (0.5 * ShadowTexture.USize));

			AttachProjector(); // Update the current projected texture.
		}
		else
		{
			Log(Name$".PreRender: Failed to allocate texture");
			Destroy();
		}
	}

	LastRenderTime = Level.TimeSeconds;
}

//
//	Tick
//

event Tick(float DeltaTime)
{
	super.Tick(DeltaTime);
	UpdateShadow(DeltaTime);
}

//
//	Default properties
//

defaultproperties
{
	InterpolateRate=2.500000
	BoundScale=35.000000
	ShadowResolution=256
	bShadowActive=true
	bBlurShadow=true
	MaxTraceDistance=220
	bProjectActor=false
	bClipBSP=true
	bGradient=true
	bProjectOnAlpha=true
	bProjectOnParallelBSP=true
	bDynamicAttach=true
	bStatic=false
	bOwnerNoSee=true
	RemoteRole=ROLE_None
	VisibilityRadius=1000.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}