X9

Creating a new perspective

Now that we have our player controller ready we should be able to tack something bigger. Lets add a custom camera to our game. This tutorial is aimed at doing an isometric game, since UDK doesn’t support this camera type it will be a good training exercise for you.

Create a new script file named IsometricCamera. Change the “extends Object” to “extends Camera”. I will then ask you to copy the following function inside your script file. Put it right under the class declaration, you should end up with the following :

class IsometricCamera extends Camera;
/*****************************************************************
*
*  TUTORIAL FUNCTION
*
*  This function was extended from camera. Your pawn will request
*  a camera type when its created with function GetDefaultCameraMode,
*  Force it to 'Isometric'. This change is small and doesnt hinder the
*  in-game use of other buil-in camera types.
*
*  This is a skeletal function provided to be simple and to the point
*  to get an iso camera, add more or extend from another parent class
*  if you miss anything from GameCamera.
*
*
*****************************************************************/
function UpdateViewTarget(out TViewTarget OutVT, float DeltaTime)
{
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'		:	// do not update, keep previous camera position by restoring
// saved POV, in case CalcCamera changes it but still returns false
OutVT.POV = OrigPOV;
break;

case 'ThirdPerson'	: // Simple third person view implementation
case 'FreeCam'		:
case 'FreeCam_Default':
Loc = OutVT.Target.Location;
Rot = OutVT.Target.Rotation;

//OutVT.Target.GetActorEyesViewPoint(Loc, Rot);
if( CameraStyle == 'FreeCam' || CameraStyle == 'FreeCam_Default' )
{
Rot = PCOwner.Rotation;
}
Loc += FreeCamOffset >> Rot;

Pos = Loc - Vector(Rot) * FreeCamDistance;
// @fixme, respect BlockingVolume.bBlockCamera=false
HitActor = Trace(HitLocation, HitNormal, Pos, Loc, FALSE, vect(12,12,12));
OutVT.POV.Location = (HitActor == None) ? Pos : HitLocation;
OutVT.POV.Rotation = Rot;
break;

case 'Isometric':
// fix Camera rotation
Rot.Pitch = (-55.0f     *DegToRad) * RadToUnrRot;
Rot.Roll =  (0          *DegToRad) * RadToUnrRot;
Rot.Yaw =   (30.0f      *DegToRad) * RadToUnrRot;

Loc.X = PCOwner.Pawn.Location.X - 64;
Loc.Y = PCOwner.Pawn.Location.Y - 64;
Loc.Z = PCOwner.Pawn.Location.Z + 156;

Pos = Loc - Vector(Rot) * FreeCamDistance;

OutVT.POV.Location = Pos;
OutVT.POV.Rotation = Rot;
break;

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 );
}

Now add the following inside the DefaultProperties block :

DefaultProperties

{

DefaultFOV=90.f

}

This will set the default Field of view or how wide the camera see. When you change this, it’s akin to changing the camera lens on a photographer’s camera.

This function was copy/pasted from the Camera class. Since we extend from this class and we are not calling super.UpdateViewTarget, we are simply changing the entire behaviour of the function. Here we did not have any choices because there is no way for us to extend inside the switch( CameraStyle ) from the parent class. Lets examin what it does :

 

 

Camera Isometric rotation

 

// fix Camera rotation

Rot.Pitch = (-55.0f *DegToRad) * RadToUnrRot;

Rot.Roll = (0 *DegToRad) * RadToUnrRot;

Rot.Yaw = (30.0f *DegToRad) * RadToUnrRot;

 

Now here we fix the camera angles into a fixed angle that is more or less isometric. The reason we need the multiplications is because the Rotator type which contains Pitch,Yaw and Roll support an Integer for defining rotation. I found that weird at first but you get the hang of it rapidly.

 

Camera Offset

 

// fix Camera position offset from avatar.

Loc.X = PCOwner.Pawn.Location.X – 64;

Loc.Y = PCOwner.Pawn.Location.Y – 64;

Loc.Z = PCOwner.Pawn.Location.Z + 156;

 

This sets default camera start position from the pawn (player avatar).

 

//Set zooming.

Pos = Loc – Vector(Rot) * FreeCamDistance;

 

This will be used to control the camera zoom in/out with scroll wheel. What it does is to use the current camera rotation as direction vector and then multiply it by the FreeCamDistance. By default this value is 256.0f, you can look it up CTRL+SHIFT+F ( FreeCamDistance ) will search for all references to this variable.

 

Plug in the camera in the player controller

Again creating a new file without wiring it, will see no changes in the game perspective. To add the new camera system, add the following entry to the default properties of the IsometricGamePlayerController : CameraClass=class‘IsometricCamera’.

 

Build the solution and hit the play button in visual studio and you should have a suprise !

 

Troubleshooting

 

As you can see the camera has not changed perspective, we are still in first person mode. Why ? This is rather simple : Your default avatar (Pawn class) is by default requesting a first person perspective. What we will do is create our own pawn class to clear this problem.

 

Creating a new Pawn

First create a new unreal script and name it MyPawn. Change the class extends from Object to GamePawn. Copy the following function which will tell our pawn to use the Isometric Camera :

simulated function name GetDefaultCameraMode( PlayerController RequestedBy )

{

return ‘Isometric’;

}

To wire the new MyPawn class to the game, you will have to change the default properties of the GameInfo class. Your IsometricGameInfo class should now look like this :

class IsometricGameInfo extends GameInfo;

DefaultProperties

{

bDelayedStart=false

PlayerControllerClass=class‘IsometricGamePlayerController’

DefaultPawnClass=class‘MyPawn’

}

The variable bDelayedStart is very important here. The reason we set it to false is that in a normal Unreal tournament game, the player is set into waiting camera by default and the pawn will not be spawn until the game start event. Since we have not implemented such a scheme, we simply say : Do not delay us and spawn us immediately.

Compile and hit play, now you should have a pleasant surprise !

 

EDIT FROM FEEDBACKS (Jan 02, 2010) : If you read the comments you may see that some people had problems setting up the pawn visual asset, put these defaultproperties if the stock game does not work, for curious reasons for some it works, others do not see the default pawn from the extended class.

defaultproperties
{
	Components.Remove(Sprite)

	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)

    Begin Object Class=SkeletalMeshComponent Name=InitialSkeletalMesh
		CastShadow=true
		bCastDynamicShadow=true
		bOwnerNoSee=false
		LightEnvironment=MyLightEnvironment;
        BlockRigidBody=true;
        CollideActors=true;
        BlockZeroExtent=true;
		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

	Mesh=InitialSkeletalMesh;
	Components.Add(InitialSkeletalMesh);
}

NOTE FOR ADVANCED USERS: If you are using UT classes for extending UTgame, you will have to override CalcCamera also, so the pawn does not override camera control. (this has been noted by users not following exactly the tutorial’s base classes…

 

 

 

Now that was easy ! With that newly created camera we can now set on to new heights and make a mouse cursor for moving the pawn around ! For the present mouse moves the rotation of the pawn and WASD translate the pawn relative to its rotation. We will tackle player input later, for now lets display a mouse cursor. While we are here, lets make this mouse cursor follow the ground and use a nice 3d mesh.

 

 

Download solution and source file for chapter 1.

 

 

 

Chapter 2 – Getting the mouse into the fray