Assembling a First-Person Setup With Controls

To make a main character, we will need a controller node implementing basic player functionality (handling keyboard and mouse input, movement settings, etc.). Attached to this node, we will have a first-person view camera, hands with a gun, and a body imitation to check for collisions with other characters, bullets, and environment. Later we will assign logic components to the nodes to implement shooting, visual effects, etc. Let's start with the character controller.

For the character controller, we will use the template first-person controller. It is included in the default scene of a new C# project to simplify the programmer's task — find the Node Reference named first_person_controller in the hierarchy, it contains a Dummy Node with the FirstPersonController component assigned.

Let's rename it to player: enable editing of the Node Reference by clicking Edit and rename both nodes. Then select the Node Reference again and click Apply. This node will represent our character.

For a first-person setup you will need the hands and weapon models and animations previously created in a 3D modeling software. If you have your own assets, that's great, otherwise you can use our ready-to-use assets available in the data folder.

We'll start with adding hands, and then attaching a pistol to them. In Asset Browser, find the data/hands/hands.fbx asset and add it to the scene.

To simulate a player's body that takes damage when hit by enemy bullets, let's create an additional object (it will approximate the player's body with a box):

1. In the Menu bar, choose Create → Primitive → Box to create a box primitive of the size (1,1,2), add it to the scene and rename to player_hit_box.

   

2. Add it as a child to the hands Dummy Node and reset its position to the parent one. And for player_hit_box let's enable the Intersection option in the Surfaces section of the Parameters window.

   

3. Adjust the position of the player_hit_box so that it is placed immediately below the hands.

4. Make it invisible by clearing its Viewport mask in the Node tab of the Parameters window using the Clear All button. Also clear the Shadow mask to disable shadows rendering. You'll get something like this:

   

We'll assign the Health component to it later.

Adding a Camera#

In UNIGINE, you should use the Skinned Mesh with bones for animated models. Our FBX model of hands contains several bones. We can attach the object to a particular bone to make it follow this bone. For this purpose, we use a WorldTransformBone node that has a controlled object (a pistol in our case) as a child, and the Skinned Mesh with bones as its parent.

1. In the Asset Browser, find the data/pistol/pistol.fbx asset and add it to the scene.

2. In the Menu bar, choose Create -> Mesh -> SkinnedBone: a WorldTransformBone node will be created. Add it as a child to the hands Skinned Mesh (the one that is inherited from the hands Dummy Node).

   

3. In the Bone drop-down list, select joint_hold. This will be the bone to which the pistol will be attached.

   

4. Make the pistol a child of the WorldTransformBone node. Reset its relative position and rotation to zero if needed.

   

There is also a number of animations to be used for the hands (idle, walking, shooting). You can check how a certain animation looks like, for example:

1. In the Asset Browser, find the data/hands/hands_animations/handspistolidle.anim file and drag it to the Preview Animation section of the hands Skinned Mesh parameters.

2. Check the Loop option and click Play.

   

When the character changes its states (shooting, walking forward/backward/left/right), the corresponding animations should change smoothly. Let's implement a component for mixing our animations.

To ensure a seamless transition, we need to play two animations simultaneously and blend them. To do so, we will use multiple layers; we can assign different weights to each layer and achieve smooth blending.

The following scheme shows the blend tree we are going to use:

1. Create a new C# component named HandAnimationController.cs: in the Asset Browser, right-click and choose Create Code -> C# Component in the drop-down list. Copy and paste the following code to the created component:

   HandAnimationController.cs

   Source code (C#)

   using System;
   using System.Collections;
   using System.Collections.Generic;
   using Unigine;
   
   [Component(PropertyGuid = "AUTOGENERATED_GUID")] // <-- this line is generated automatically for a new component
   public class HandAnimationController : Component
   {
   	// first person controller
   	public FirstPersonController fpsController = null;
   
   	public float moveAnimationSpeed = 30.0f;
   	public float shootAnimationSpeed = 30.0f;
   	public float idleWalkMixDamping = 5.0f;
   	public float walkDamping = 5.0f;
   	public float shootDamping = 1.0f;
   
   	// animation parameters
   	[ParameterFile(Filter = ".anim")]
   	public string idleAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveForwardAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveBackwardAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveRightAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string moveLeftAnimation = null;
   
   	[ParameterFile(Filter = ".anim")]
   	public string shootAnimation = null;
   
   	public vec2 LocalMovementVector
   	{
   		get
   		{
   			return new vec2(
   				MathLib.Dot(fpsController.SlopeAxisY, fpsController.HorizontalVelocity),
   				MathLib.Dot(fpsController.SlopeAxisX, fpsController.HorizontalVelocity)
   			);
   		}
   		set {}
   	}
   
   	private ObjectMeshSkinned meshSkinned = null;
   	private float currentIdleWalkMix = 0.0f; // 0 means idle animation, 1 means walk animation
   	private float currentShootMix = 0.0f; // 0 means idle/walk mix, 1 means shoot animation
   	private float currentWalkForward = 0.0f;
   	private float currentWalkBackward = 0.0f;
   	private float currentWalkRight = 0.0f;
   	private float currentWalkLeft = 0.0f;
   
   	private float currentWalkIdleMixFrame = 0.0f;
   	private float currentShootFrame = 0.0f;
   	private int numShootAnimationFrames = 0;
   
   	// animation layers number
   	private const int numLayers = 6;
   
   	private void Init()
   	{
   		// grab the node with the current component assigned
   		// and cast it to the ObjectMeshSkinned type
   		meshSkinned = node as ObjectMeshSkinned;
   
   		// set the number of animation layers for the node
   		meshSkinned.NumLayers = numLayers;
   
   		// set animation for each animation layer
   		meshSkinned.SetAnimation(0, idleAnimation);
   		meshSkinned.SetAnimation(1, moveForwardAnimation);
   		meshSkinned.SetAnimation(2, moveBackwardAnimation);
   		meshSkinned.SetAnimation(3, moveRightAnimation);
   		meshSkinned.SetAnimation(4, moveLeftAnimation);
   		meshSkinned.SetAnimation(5, shootAnimation);
   
   		int animation = meshSkinned.GetAnimation(5);
   		numShootAnimationFrames = meshSkinned.GetNumAnimationFrames(animation);
   
   		// enable all animation layers
   		for (int i = 0; i < numLayers; ++i)
   			meshSkinned.SetLayerEnabled(i, true);
   	}
   
   	public void Shoot()
   	{
   		// enable the shooting animation
   		currentShootMix = 1.0f;
   		// set the animation layer frame to 0
   		currentShootFrame = 0.0f;
   	}
   
   	private void Update()
   	{
   		vec2 movementVector = LocalMovementVector;
   	
   		// check if the character is moving
   		bool isMoving = movementVector.Length2 > MathLib.EPSILON;
   
   		// handle input: check if the fire button is pressed
   		bool isShooting = Input.IsMouseButtonDown(Input.MOUSE_BUTTON.LEFT);
   		if (isShooting)
   			Shoot();
   		// calculate the target values for the layer weights
   		float targetIdleWalkMix = (isMoving) ? 1.0f : 0.0f;
   		float targetWalkForward = (float) MathLib.Max(0.0f, movementVector.x);
   		float targetWalkBackward = (float) MathLib.Max(0.0f, -movementVector.x);
   		float targetWalkRight = (float) MathLib.Max(0.0f, movementVector.y);
   		float targetWalkLeft = (float) MathLib.Max(0.0f, -movementVector.y);
   
   		// apply the current layer weights
   		float idleWeight = 1.0f - currentIdleWalkMix;
   		float walkMixWeight = currentIdleWalkMix;
   		float shootWalkIdleMix = 1.0f - currentShootMix;
   
   		meshSkinned.SetLayerWeight(0, shootWalkIdleMix * idleWeight);
   		meshSkinned.SetLayerWeight(1, shootWalkIdleMix * walkMixWeight * currentWalkForward);
   		meshSkinned.SetLayerWeight(2, shootWalkIdleMix * walkMixWeight * currentWalkBackward);
   		meshSkinned.SetLayerWeight(3, shootWalkIdleMix * walkMixWeight * currentWalkRight);
   		meshSkinned.SetLayerWeight(4, shootWalkIdleMix * walkMixWeight * currentWalkLeft);
   		meshSkinned.SetLayerWeight(5, currentShootMix);
   
   		// update the animation frames: set the same frame for the animation layers to keep them in sync
   		meshSkinned.SetFrame(0, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(1, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(2, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(3, currentWalkIdleMixFrame);
   		meshSkinned.SetFrame(4, currentWalkIdleMixFrame);
   		// set the shooting animation layer frame to 0 to start animation from the beginning
   		meshSkinned.SetFrame(5, currentShootFrame);
   
   		currentWalkIdleMixFrame += moveAnimationSpeed * Game.IFps;
   		currentShootFrame = MathLib.Min(currentShootFrame + shootAnimationSpeed * Game.IFps, numShootAnimationFrames);
   
   		// smoothly update the current weight values
   		currentIdleWalkMix = MathLib.Lerp(currentIdleWalkMix, targetIdleWalkMix, idleWalkMixDamping * Game.IFps);
   
   		currentWalkForward = MathLib.Lerp(currentWalkForward, targetWalkForward, walkDamping * Game.IFps);
   		currentWalkBackward = MathLib.Lerp(currentWalkBackward, targetWalkBackward, walkDamping * Game.IFps);
   		currentWalkRight = MathLib.Lerp(currentWalkRight, targetWalkRight, walkDamping * Game.IFps);
   		currentWalkLeft = MathLib.Lerp(currentWalkLeft, targetWalkLeft, walkDamping * Game.IFps);
   
   		currentShootMix = MathLib.Lerp(currentShootMix, 0.0f, shootDamping * Game.IFps);
   	}
   }

2. In UnigineEditor, assign this component to the hands Skinned Mesh.
3. Remove data/hands/hands_animations/handspistolidle.anim from the Preview Animation field of the Mesh Skinned section.

4. Add animations stored in the data/hands/hands_animations folder to the corresponding parameters.

   

5. Assign (drag and drop) the player Dummy Node to the Fps Controller field of the HandAnimationController component so that it could get required data from the player's first person controller to perform blending.

   

6. Save all changes and run the application logic via the UnigineEditor to check the result.