[UnrealEd.EditorEngine] EditPackagesOutPath=..\..\UDKGame\Script FRScriptOutputPath=..\..\UDKGame\ScriptFinalRelease +EditPackages=UDKBase +EditPackages=UTEditor AutoSaveDir=..\..\UDKGame\Autosaves InEditorGameURLOptions=?quickstart=1?numplay=1
case 'ThirdPerson' : //Enters here as long as CameraStyle is still set to ThirdPerson
case 'IsometricCam' : //Isometric camera
case 'ShoulderCam' : //Side Scrolling Camera for Mega Man 2
case 'FreeCam' :
if (CameraStyle == 'IsometricCam') // A basic if statement
{
/*Rot.pitch = -10000;*/
/*Rot.yaw = -5500; With these two statements, we're telling the camera to stay fixed at these rotation values, provided by rahatropa */
Rot = PCOwner.Owner.Rotation;
TargetZ = 300;
TargetFOV = 90.f;
TargetOffset = 100;
FreeCamDistance = 64;
Bindings=(Name="LeftShift",Command="ShoulderCam | OnRelease ReturnCam") Bindings=(Name="Z",Command="IsometricCam | OnRelease ReturnCam")
class YourGameCamera extends Camera;
// initializing static variables
var float Dist;
var float TargetFOV;
var float TargetZ;
var float Z;
var float TargetOffset;
var float Offset;
var float pival;
DefaultProperties
{
FreeCamDistance = 256.f
pival = 3.14159;
}
function UpdateViewTarget(out TViewTarget OutVT, float DeltaTime)
{
//Declaring local variables
local vector Loc, Pos, HitLocation, HitNormal;
local rotator Rot;
local Actor HitActor;
local CameraActor CamActor;
local bool bDoNotApplyModifiers;
local TPOV OrigPOV;
// store previous POV, in case we need it later
OrigPOV = OutVT.POV;
// Default FOV on viewtarget
OutVT.POV.FOV = DefaultFOV;
// Viewing through a camera actor.
CamActor = CameraActor(OutVT.Target);
if( CamActor != None )
{
CamActor.GetCameraView(DeltaTime, OutVT.POV);
// Grab aspect ratio from the CameraActor.
bConstrainAspectRatio = bConstrainAspectRatio || CamActor.bConstrainAspectRatio;
OutVT.AspectRatio = CamActor.AspectRatio;
// See if the CameraActor wants to override the PostProcess settings used.
CamOverridePostProcessAlpha = CamActor.CamOverridePostProcessAlpha;
CamPostProcessSettings = CamActor.CamOverridePostProcess;
}
else
{
// Give Pawn Viewtarget a chance to dictate the camera position.
// If Pawn doesn't override the camera view, then we proceed with our own defaults
if( Pawn(OutVT.Target) == None ||
!Pawn(OutVT.Target).CalcCamera(DeltaTime, OutVT.POV.Location, OutVT.POV.Rotation, OutVT.POV.FOV) )
{
// don't apply modifiers when using these debug camera modes.
bDoNotApplyModifiers = TRUE;
switch(CameraStyle)
{
case 'Fixed' : // No update, keeps previous view
OutVT.POV = OrigPOV;
break;
case 'ThirdPerson' : //Enters here as long as CameraStyle is still set to ThirdPerson
case 'IsometricCam' : //Isometric camera
case 'ShoulderCam' : //Side Scrolling Camera for Mega Man 2
case 'FreeCam' :
Loc = OutVT.Target.Location; // Setting the camera location and rotation to the viewtarget's
Rot = OutVT.Target.Rotation;
if (CameraStyle == 'ThirdPerson')
{
Rot = PCOwner.Rotation; //setting the rotation of the camera to the rotation of the pawn
TargetZ = 0;
TargetFOV = 90;
TargetOffset = 0;
}
if (CameraStyle == 'IsometricCam') // A basic if statement
{
/*Rot.pitch = -10000;*/
/*Rot.yaw = -5500; With these two statements, we're telling the camera to stay fixed at these rotation values, provided by rahatropa */
Rot = PCOwner.Owner.Rotation;
TargetZ = 300;
TargetFOV = 90.f;
TargetOffset = 100;
FreeCamDistance = 64;
}
if (CameraStyle == 'ShoulderCam')
{
Rot = PCOwner.Rotation;
FreeCamDistance = 64;
TargetFOV = 60.f;
TargetZ = 32;
TargetOffset = 32;
}
//OutVT.Target.GetActorEyesViewPoint(Loc, Rot);
if(CameraStyle == 'FreeCam')
{
Rot = PCOwner.Rotation;
}
Loc += FreeCamOffset >> Rot;
Loc.Z += Z; // Setting the Z coordinate offset for shoulder view
//Linear interpolation algorithm. This is the "smoothing," so the camera doesn't jump between zoom levels
if (Dist != FreeCamDistance)
{
Dist = Lerp(Dist,FreeCamDistance,0.15); //Increment Dist towards FreeCamDistance, which is where you want your camera to be. Increments a percentage of the distance between them according to the third term, in this case, 0.15 or 15%
}
if (Z != TargetZ)
{
Z = Lerp(Z,TargetZ,0.1);
}
if (DefaultFOV != TargetFOV)
{
DefaultFOV = Lerp(DefaultFOV,TargetFOV,0.1);
}
if (Offset != TargetOffset)
{
Offset = Lerp(Offset,TargetOffset,0.1);
}
Pos = Loc - Vector(Rot) * Dist; /*Instead of using FreeCamDistance here, which would cause the camera to jump by the entire increment, we use Dist, which increments in small steps to the desired value of FreeCamDistance using the Lerp function above*/
// Setting the XY camera offset for shoulder view
Pos.X += Offset*sin(-Rot.Yaw*pival*2/65536);
Pos.Y += Offset*cos(Rot.Yaw*pival*2/65536);
// @fixme, respect BlockingVolume.bBlockCamera=false
//This determines if the camera will pass through a mesh by tracing a path to the view target.
HitActor = Trace(HitLocation, HitNormal, Pos, Loc, FALSE, vect(12,12,12));
//This is where the location and rotation of the camera are actually set
OutVT.POV.Location = (HitActor == None) ? Pos : HitLocation;
OutVT.POV.Rotation = Rot;
break; //This is where our code leaves the switch-case statement, preventing it from executing the commands intended for the FirstPerson case.
case 'FirstPerson' : // Simple first person, view through viewtarget's 'eyes'
default : OutVT.Target.GetActorEyesViewPoint(OutVT.POV.Location, OutVT.POV.Rotation);
break;
}
}
}
if( !bDoNotApplyModifiers )
{
// Apply camera modifiers at the end (view shakes for example)
ApplyCameraModifiers(DeltaTime, OutVT.POV);
}
//`log( WorldInfo.TimeSeconds @ GetFuncName() @ OutVT.Target @ OutVT.POV.Location @ OutVT.POV.Rotation @ OutVT.POV.FOV );
}
class YourGamePlayerController extends GamePlayerController;
var float PreDist; //tore our previous camera distance so that when we switch back to the normal camera, we'll be at our original setting.
simulated event PostBeginPlay() //This event is triggered when play begins
{
super.PostBeginPlay();
`Log("I am alive!"); //This sends the message "I am alive!" to thelog (to see the log, you need to run UDK with the -log switch)
}
//Functions for zooming in and out
exec function NextWeapon() /*The "exec" command tells UDK that this function can be called by the console or keybind.
We'll go over how to change the function of keys later (if, for instance, you didn't want you use the scroll wheel, but page up and down for zooming instead.)*/
{
if (PlayerCamera.FreeCamDistance < 512) //Checks that the the value FreeCamDistance, which tells the camera how far to offset from the view target, isn't further than we want the camera to go. Change this to your liking.
{
`Log("MouseScrollDown"); //Another log message to tell us what's happening in the code
PlayerCamera.FreeCamDistance += 64*(PlayerCamera.FreeCamDistance/256); /*This portion increases the camera distance.
By taking a base zoom increment (64) and multiplying it by the current distance (d) over 256, we decrease the zoom increment for when the camera is close,
(d < 256), and increase it for when it's far away (d > 256).
Just a little feature to make the zoom feel better. You can tweak the values or take out the scaling altogether and just use the base zoom increment if you like */
}
}
exec function PrevWeapon()
{
if (PlayerCamera.FreeCamDistance > 64) //Checking if the distance is at our minimum distance
{
`Log("MouseScrollUp");
PlayerCamera.FreeCamDistance -= 64*(PlayerCamera.FreeCamDistance/256); //Once again scaling the zoom for distance
}
}
DefaultProperties
{
CameraClass=class 'YourGameCamera' //Telling the player controller to use your custom camera script
DefaultFOV=90.f //Telling the player controller what the default field of view (FOV) should be
}
exec function ShoulderCam() // Declaring our ShoulderCam function that we bound to
{
`Log("Shoulder Camera"); // Yet another log...
PreDist = PlayerCamera.FreeCamDistance; //Storing our previous camera distance...
YourGameCamera(PlayerCamera).CameraStyle = 'ShoulderCam'; //Type casting our camera script to access the variable CameraStyle
}
exec function ReturnCam() //This is called on release of left shift
{
`Log("Main Camera");
PlayerCamera.FreeCamDistance = PreDist; // Restoring the previous camera distance
YourGameCamera(PlayerCamera).CameraStyle = 'ThirdPerson'; // Restoring the previous camera style
}
class YourGameInfo extends GameInfo; //This line tells UDK that you want to inherit all of the functionality of GameInfo.uc, and< add your own. The name after "class" must match the file name.
DefaultProperties //Self explanatory
{
bDelayedStart = false
PlayerControllerClass = class 'YourGame.YourGamePlayerController' //Setting the Player Controller to your custom script
DefaultPawnClass = class 'YourGame.YourGamePawn' //Setting the Pawn to your custom script
}
class YourGamePawn extends GamePawn; //Again, naming conventions apply here. Your script is extending the UDK script
//This lets the pawn tell the PlayerController what Camera Style to set the camera in initially (more on this later).
simulated function name GetDefaultCameraMode(PlayerController RequestedBy)
{
return 'ThirdPerson';
}
DefaultProperties
{
//Setting up the light environment
Begin Object Class=DynamicLightEnvironmentComponent Name=MyLightEnvironment
ModShadowFadeoutTime=0.25
MinTimeBetweenFullUpdates=0.2
AmbientGlow=(R=.01,G=.01,B=.01,A=1)
AmbientShadowColor=(R=0.15,G=0.15,B=0.15)
LightShadowMode=LightShadow_ModulateBetter
ShadowFilterQuality=SFQ_High
bSynthesizeSHLight=TRUE
End Object
Components.Add(MyLightEnvironment)
//Setting up the mesh and animset components
Begin Object Class=SkeletalMeshComponent Name=InitialSkeletalMesh
CastShadow=true
bCastDynamicShadow=true
bOwnerNoSee=false
LightEnvironment=MyLightEnvironment;
BlockRigidBody=true;
CollideActors=true;
BlockZeroExtent=true;
//What to change if you'd like to use your own meshes and animations
PhysicsAsset=PhysicsAsset'CH_AnimCorrupt.Mesh.SK_CH_Corrupt_Male_Physics'
AnimSets(0)=AnimSet'CH_AnimHuman.Anims.K_AnimHuman_AimOffset'
AnimSets(1)=AnimSet'CH_AnimHuman.Anims.K_AnimHuman_BaseMale'
AnimTreeTemplate=AnimTree'CH_AnimHuman_Tree.AT_CH_Human'
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
End Object
//Setting up a proper collision cylinder
Mesh=InitialSkeletalMesh;
Components.Add(InitialSkeletalMesh);
CollisionType=COLLIDE_BlockAll
Begin Object Name=CollisionCylinder
CollisionRadius=+0023.000000
CollisionHeight=+0050.000000
End Object
CylinderComponent=CollisionCylinder
Rot = PCOwner.Owner.Rotation;
Comment