UTGame.UTGib

/**
 * base class for gibs
 *
 * Copyright 1998-2008 Epic Games, Inc. All Rights Reserved.
 */
class UTGib extends Actor
	config(Game)
	notplaceable
	abstract;


/** Our LightEnvironment **/
var DynamicLightEnvironmentComponent GibLightEnvironment;

/** sound played when we hit a wall */
var SoundCue HitSound;

/** the component that will be set to the chosen mesh */
var MeshComponent GibMeshComp;

/** This is the MIC to use for the gib **/
var MaterialInstanceConstant MIC_Gib;

/** This is the MI to use for the decal that this gib may spawn **/
var MaterialInstance MI_Decal;

/** This is the template/parent to use for the decal which will be spawned **/
var protected MaterialInstanceTimeVarying MITV_DecalTemplate;

/** This is the MITV dissolve param for the decal **/
var name DecalDissolveParamName;

/** How long before the Decal should start dissolving **/
var float DecalWaitTimeBeforeDissolve;

/** This is the template/parent to use for the GibMesh which will be spawned **/
var protected MaterialInstanceTimeVarying MITV_GibMeshTemplate;

/** 
 * This is the template/parent to use for the GibMesh which will be spawned.
 * Some of our gibs types have two different materials/packages used so we need to mark which ones need to use the secondary MITV template 
 **/
var protected MaterialInstanceTimeVarying MITV_GibMeshTemplateSecondary;

/** This is the MITV dissolve param for the GibMesh **/
var protected name GibMeshDissolveParamName;

/** How long before the GibMesh should start dissolving **/
var protected float GibMeshWaitTimeBeforeDissolve;


/** PSC for the GibEffect (e.g. for the link gun we play a little lightning) **/
var ParticleSystemComponent PSC_GibEffect;
/** The ParticleSystem or the Custom Gib Effect (if any) **/
var ParticleSystem PS_CustomEffect;

struct StaticMeshDatum
{
	var StaticMesh TheStaticMesh;

	var SkeletalMesh TheSkelMesh;
	var PhysicsAsset ThePhysAsset;

	/** Different gibs can all have different scales based on where the asset came from**/
	var float DrawScale;

	/** Some of our gibs types have two different materials/packages used so we need to mark which ones need to use the secondary MITV template **/
	var bool bUseSecondaryGibMeshMITV;

	structdefaultproperties
	{
		DrawScale=1.0
	}
};

/** list of generic gib meshes from which one will be chosen at random */
var array<StaticMeshDatum> GibMeshesData;

/** Used when is acting as viewtarget */
var vector OldCamLoc;
var rotator OldCamRot;
var bool bStopMovingCamera;


simulated event PreBeginPlay()
{
	Super.PreBeginPlay();

	ChooseGib();
}


/**
 * This will force the gib material to stay streamed in and not be affected by distance based streaming
 * which often seems to be causing pops.
 *
 * @paran TimeToBeResisent num seconds to be resident
 **/
simulated function SetTexturesToBeResident( float TimeToBeResisent )
{
	local int MatIdx;
	local array<texture> Textures;
	local int TexIdx;

	for( MatIdx = 0; MatIdx < GibMeshComp.Materials.Length; ++MatIdx )
	{
		Textures = GibMeshComp.Materials[MatIdx].GetMaterial().GetTextures();

		for( TexIdx = 0; TexIdx < Textures.Length; ++TexIdx )
		{
			//`log( "Texture setting bForceMiplevelsToBeResident: " $ TimeToBeResisent @ GibMeshComp.Materials[MatIdx] @ Textures[TexIdx] );
			Texture2D(Textures[TexIdx]).TimeToForceMipLevelsToBeResident = TimeToBeResisent;
		}
	}
}


/**
 * @param	HUD		- HUD with canvas to draw on
 * @input	out_YL		- Height of the current font
 * @input	out_YPos	- Y position on Canvas. out_YPos += out_YL, gives position to draw text for next debug line.
 */
simulated function DisplayDebug(HUD HUD, out float out_YL, out float out_YPos)
{
	if ( SkeletalMeshComponent(GibMeshComp) != None )
		HUD.Canvas.DrawText("Mesh "$SkeletalMeshComponent(GibMeshComp).SkeletalMesh, false);
	else
		HUD.Canvas.DrawText("Mesh "$StaticMeshComponent(GibMeshComp).StaticMesh, false);
	out_YPos += out_YL;
	HUD.Canvas.SetPos(4,out_YPos);
	super.DisplayDebug(HUD, out_YL, out_YPos);
}

/**
 * This will set the StaticMeshComponent's StaticMesh.  Useful for spawning a UTGib and then setting the value (e.g. the vehicle gibs)
 **/
simulated function SetGibStaticMesh( StaticMesh NewStaticMesh )
{
	local StaticMeshComponent SMC;

	GibMeshComp = new(self) class'UTGibStaticMeshComponent';
	CollisionComponent = GibMeshComp;

	SMC = StaticMeshComponent(GibMeshComp);
	AttachComponent(GibMeshComp);
	// Need to attach before calling SetStaticMesh, so component is in right place before creating physics
	SMC.SetStaticMesh( NewStaticMesh );

	SMC.SetLightEnvironment( GibLightEnvironment );
}


/** This will choose between the two types of gib meshes that we can have. **/
simulated function ChooseGib()
{
	local StaticMeshDatum SMD;
	local StaticMeshComponent SMC;
	local SkeletalMeshComponent SKMC;
	local int StartIndex, Index;
	local MaterialInstanceTimeVarying GibMaterialInstance;

	if (GibMeshesData.length > 0)
	{
		Index = Rand(GibMeshesData.length);
		// don't allow skeletal gibs if low detail
		if ( WorldInfo.bDropDetail || WorldInfo.GetDetailMode() == DM_Low || class'Engine'.static.IsSplitScreen() )
		{
			StartIndex = Index;
			while (GibMeshesData[Index].ThePhysAsset != None)
			{
				Index++;
				if (Index >= GibMeshesData.length)
				{
					Index = 0;
				}
				if (Index == StartIndex)
				{
					Destroy();
					return;
				}
			}
		}
		SMD = GibMeshesData[Index];

		// do the static mesh version of the gib
		if( SMD.ThePhysAsset == NONE )
		{
			GibMeshComp = new(self) class'UTGibStaticMeshComponent';
			CollisionComponent = GibMeshComp;

			SMC = StaticMeshComponent(GibMeshComp);
			SMC.SetScale(SMD.DrawScale);
			AttachComponent(GibMeshComp);
			// Need to attach before calling SetStaticMesh, so component is in right place before creating physics
			SMC.SetStaticMesh( SMD.TheStaticMesh );
		}
		// do the skeletal mesh version of the gib
		else
		{
			GibMeshComp = new(self) class'UTGibSkeletalMeshComponent';
			CollisionComponent = GibMeshComp;

			SKMC = SkeletalMeshComponent(GibMeshComp);
			SKMC.SetSkeletalMesh( SMD.TheSkelMesh );
			SKMC.SetPhysicsAsset( SMD.ThePhysAsset );
			SKMC.SetScale(SMD.DrawScale);
			AttachComponent(GibMeshComp);
			SKMC.SetHasPhysicsAssetInstance( TRUE ); // this need to comes after the AttachComponent so component is in right place.
		}

		GibMeshComp.SetLightEnvironment( GibLightEnvironment );

		DoCustomGibEffects();

		// this is going to set up the MITV so we can have the gibs burn out nicely
		GibMaterialInstance = new(self) class'MaterialInstanceTimeVarying';
		if( SMD.bUseSecondaryGibMeshMITV == FALSE )
		{
			GibMaterialInstance.SetParent( MITV_GibMeshTemplate );
		}
		else
		{
			GibMaterialInstance.SetParent( MITV_GibMeshTemplateSecondary );
		}

		GibMeshComp.SetMaterial( 0, GibMaterialInstance );

		GibMaterialInstance.SetScalarStartTime( GibMeshDissolveParamName, (GibMeshWaitTimeBeforeDissolve-(FRand()*1.0f)));
		
	}
	else
	{
		//`warn( "Unable to find mesh for: " $ self );
		//ScriptTrace();
		Destroy();
	}
}


/** This will do any custom gib effects for this gib.  (e.g. robots have a sparkie that plays!) **/
simulated function DoCustomGibEffects();


function Timer()
{
	local PlayerController PC;

	ForEach LocalPlayerControllers(class'PlayerController', PC)
	{
		if( PC.ViewTarget == self )
		{
			SetTimer( 4.0, FALSE );
			return;
		}
	}

	Destroy();
}

event BecomeViewTarget( PlayerController PC )
{
	SetHidden( TRUE );
	LifeSpan = 0;
	SetTimer( 4.0, FALSE );
}


/**
 *	Calculate camera view point, when viewing this actor.
 *
 * @param	fDeltaTime	delta time seconds since last update
 * @param	out_CamLoc	Camera Location
 * @param	out_CamRot	Camera Rotation
 * @param	out_FOV		Field of View
 *
 * @return	true if Actor should provide the camera point of view.
 */
simulated function bool CalcCamera( float fDeltaTime, out vector out_CamLoc, out rotator out_CamRot, out float out_FOV )
{
	local actor HitActor;
	local vector HitNormal, HitLocation;
	local int InYaw;

	if( Physics != PHYS_None )
	{
		if ( bStopMovingCamera )
		{
			OldCamRot.Roll = OldCamRot.Roll & 65535;
			if ( (OldCamRot.Roll < 8192) || (OldCamRot.Roll > 57343) )
			{
				out_CamRot = Rotation;
				out_CamRot.Pitch = 0;
				OldCamRot = out_CamRot;
			}
			else
			{
				InYaw = out_CamRot.Yaw;
				out_CamRot = OldCamRot;
				out_CamRot.Yaw = InYaw;
			}
		}
		else
		{
			out_CamRot = Rotation;
			out_CamRot.Pitch = 0;
			OldCamRot = out_CamRot;
		}
	}

	out_CamLoc = Location;

	if ( OldCamLoc != vect(0,0,0) )
	{
		HitActor = trace(HitLocation, HitNormal, Location, OldCamLoc, false, vect(14,14,14));
		if ( HitActor != None )
		{
			out_CamLoc = HitLocation;
			bStopMovingCamera = (HitNormal.Z > 0.7);
		}
	}
	OldCamLoc = out_CamLoc;
	return false;
}

simulated event RigidBodyCollision( PrimitiveComponent HitComponent, PrimitiveComponent OtherComponent,
					const out CollisionImpactData RigidCollisionData, int ContactIndex )
{
	// don't spawn a decal unless we have more than likely hit something other than the orig pawn or other Gibs
	if( (WorldInfo.TimeSeconds - CreationTime ) > 0.4 )
	{
		//`log( "RBC: " $ self $ " against " $ HitComponent );

		// once we hit one thing don't fire off anymore hits
		if( GibMeshComp != none )
		{
			GibMeshComp.SetNotifyRigidBodyCollision( FALSE );
		}

		if ( EffectIsRelevant(Location, false, 4000.0) )
		{
			PlaySound( HitSound, TRUE );
			LeaveADecal( Location, Normal(Velocity) );
		}
	}
}


/** Data provided by the derived classes to do their specific form of decal leaving (e.g. blood for bodies, green goop for aliens, etc.) **/
simulated function LeaveADecal( vector HitLoc, vector HitNorm )
{
	local Actor TraceActor;
	local vector out_HitLocation;
	local vector out_HitNormal;
	local vector TraceDest;
	local vector TraceStart;
	local vector TraceExtent;
	local TraceHitInfo HitInfo;

	// this code is mostly duplicated in:  UTGib, UTProjectile, UTVehicle, UTWeaponAttachment be aware when updating
	// see if our child class provided a template to spawn
	if( MITV_DecalTemplate != none )
	{
		// these should be randomized
		TraceStart = HitLoc + ( -HitNorm * 15 );
		TraceDest = HitLoc + ( HitNorm * 15 );
		//DrawDebugLine( TraceStart, TraceDest, 255,255,255, TRUE );

		TraceActor = Trace( out_HitLocation, out_HitNormal, TraceDest, TraceStart, false, TraceExtent, HitInfo, TRACEFLAG_PhysicsVolumes );

		if( TraceActor != None )
		{
			MI_Decal = new(self) class'MaterialInstanceTimeVarying';
			MI_Decal.SetParent( MITV_DecalTemplate );

			WorldInfo.MyDecalManager.SpawnDecal(MI_Decal, out_HitLocation, rotator(-out_HitNormal), 200, 200, 10, false,, HitInfo.HitComponent, true, false, HitInfo.BoneName, HitInfo.Item, HitInfo.LevelIndex);

			MaterialInstanceTimeVarying(MI_Decal).SetScalarStartTime( DecalDissolveParamName, DecalWaitTimeBeforeDissolve );
		}
	}
}


simulated function TurnOnCollision()
{
	//`log( "COLLIDING ON: " $ self );
	//GibMeshComp.SetActorCollision( TRUE, FALSE );

	GibMeshComp.SetBlockRigidBody( TRUE );

	GibMeshComp.SetRBCollidesWithChannel( RBCC_Default, TRUE );
	GibMeshComp.SetRBCollidesWithChannel( RBCC_Pawn, TRUE );
	GibMeshComp.SetRBCollidesWithChannel( RBCC_Vehicle, TRUE );
	GibMeshComp.SetRBCollidesWithChannel( RBCC_GameplayPhysics, TRUE );
	GibMeshComp.SetRBCollidesWithChannel( RBCC_EffectPhysics, TRUE );

	DetachComponent(GibMeshComp);
	AttachComponent(GibMeshComp);

	GibMeshComp.WakeRigidBody();
}

defaultproperties
{
   Begin Object Class=DynamicLightEnvironmentComponent Name=GibLightEnvironmentComp ObjName=GibLightEnvironmentComp Archetype=DynamicLightEnvironmentComponent'Engine.Default__DynamicLightEnvironmentComponent'
      AmbientShadowColor=(R=0.300000,G=0.300000,B=0.300000,A=1.000000)
      AmbientGlow=(R=0.500000,G=0.500000,B=0.500000,A=1.000000)
      bCastShadows=False
      Name="GibLightEnvironmentComp"
      ObjectArchetype=DynamicLightEnvironmentComponent'Engine.Default__DynamicLightEnvironmentComponent'
   End Object
   GibLightEnvironment=GibLightEnvironmentComp
   DecalDissolveParamName="DissolveAmount"
   DecalWaitTimeBeforeDissolve=20.000000
   GibMeshDissolveParamName="BurnTime"
   GibMeshWaitTimeBeforeDissolve=8.000000
   Components(0)=GibLightEnvironmentComp
   Physics=PHYS_RigidBody
   TickGroup=TG_PostAsyncWork
   bDestroyedByInterpActor=True
   bGameRelevant=True
   bCollideActors=True
   bProjTarget=True
   bNoEncroachCheck=True
   LifeSpan=10.000000
   CollisionType=COLLIDE_CustomDefault
   Name="Default__UTGib"
   ObjectArchetype=Actor'Engine.Default__Actor'
}