3. Camera Rotation & Control

Implementeer orbital camera met keyboard rotation en camera-relative movement

Overzicht

In dit hoofdstuk breid je de camera uit met orbital rotation - de camera draait rondom de player zodat je vanuit elke hoek kan kijken. Zorg er ook voor dat de WASD keys bewegen relatief aan de kijkrichting.

Camera rotation input

1. Open scripts/View.cs

2. Begin met een variabele om de snelheid te controleren waarmee de camera rond de speler kan draaien. Voeg een _rotationSpeed variabele toe onderaan de variabelen lijst:

using Godot;

public partial class View : Node3D
{
    [Export] private Node3D _target;
    [Export] private Camera3D _camera;
    [Export] private float _followSpeed = 5.0f;
    [Export] private float _rotationSpeed = 2.0f;

    // .. de rest van de code
}

1. In _PhysicsProcess() haal je input op van de arrow keys met behulp van Input.GetAxis():

public override void _PhysicsProcess(double delta)
{
    if (_target == null) return;

    // Smooth follow
    GlobalPosition = GlobalPosition.Lerp(_target.GlobalPosition, _followSpeed * (float)delta);

    // Camera rotation input
    float horizontalInput = Input.GetAxis("camera_left", "camera_right");
    float verticalInput = Input.GetAxis("camera_up", "camera_down");
}

1. Met die input kun je vervolgens de camera links/rechts draaien met RotateY(), en boven/onder laten draaien met Rotate() rond de X as van de View:

public override void _PhysicsProcess(double delta)
{
    if (_target == null) return;

    // Smooth follow
    GlobalPosition = GlobalPosition.Lerp(_target.GlobalPosition, _followSpeed * (float)delta);

    // Camera rotation input
    float horizontalInput = Input.GetAxis("camera_left", "camera_right");
    float verticalInput = Input.GetAxis("camera_up", "camera_down");

    // Horizontal rotation (Y-axis)
    RotateY(horizontalInput * _rotationSpeed * (float)delta);
    // Vertical rotation (X-axis)
    Rotate(Transform.Basis.X, verticalInput * _rotationSpeed * (float)delta);
}

1. Als laatste beperk je de verticale rotatie zodat de camera niet ondersteboven kan gaan:

public override void _PhysicsProcess(double delta)
{
    if (_target == null) return;

    // Smooth follow
    GlobalPosition = GlobalPosition.Lerp(_target.GlobalPosition, _followSpeed * (float)delta);

    // Camera rotation input
    float horizontalInput = Input.GetAxis("camera_left", "camera_right");
    float verticalInput = Input.GetAxis("camera_up", "camera_down");

    // Horizontal rotation (Y-axis)
    RotateY(horizontalInput * _rotationSpeed * (float)delta);

    // Vertical rotation (X-axis)
    Rotate(Transform.Basis.X, verticalInput * _rotationSpeed * (float)delta);

    // Clamp vertical rotation
    Vector3 rotation = Rotation;
    rotation.X = Mathf.Clamp(rotation.X, Mathf.DegToRad(-80), Mathf.DegToRad(-10));
    Rotation = rotation;
}

Test camera rotation

1. Run het spel (F5)

2. Test de camera rotation:

   • Left/Right arrows - draai horizontaal rond player

   • Up/Down arrows - verander kijkhoek (beperkt tussen -80° en -10°)

   • WASD - beweeg player (nog steeds in world-space!)

Probleem: WASD beweegt nog in world-space - W gaat altijd "north" ongeacht camera richting. Los dit nu op met camera-relative movement!

Camera-Relative Movement

Momenteel beweegt de player in world-space richtingen:

• W gaat altijd "north" (+Z richting in world)

• A gaat altijd "west" (-X richting in world)

Je wilt dat WASD relatief is aan de camera:

• W = vooruit vanuit camera perspectief

• S = achteruit vanuit camera perspectief

• A = links strafing relatief aan camera

• D = rechts strafing relatief aan camera

Wat is Transform.Basis?

Elke Node3D heeft een Transform property met:

• Origin: positie in de wereld (Vector3)

• Basis: orientatie/rotatie (3x3 matrix van 3 richtingsvectoren)

De Basis bevat drie unit vectors:

• Basis.X: Right direction (rechts van de node)

• Basis.Y: Up direction (boven de node)

• Basis.Z: Back direction (achter de node - negatief is forward!)

1. Open scripts/Player.cs

2. Voeg een _cameraTarget variabele toe bovenaan. Dit is een referentie naar de View node, zodat we zijn Transform.Basis kunnen lezen voor camera-relative movement.

using Godot;

public partial class Player : CharacterBody3D
{
    [Export] private float _speed = 5.0f;
    [Export] private float _jumpVelocity = 8.0f;
    [Export] private Node3D _cameraTarget;

    // ... rest van de code
}

1. In _PhysicsProcess() haal je de forward en right richtingen op uit de Transform.Basis van de camera:

• Transform.Basis.Z wijst achter de camera, dus -Basis.Z is forward

• Transform.Basis.X wijst naar rechts van de camera

    public override void _PhysicsProcess(double delta)
    {
        // ... rest van de code

        // Input
        Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");

        // Haal camera's forward en right richtingen op
        Vector3 forward = -_cameraTarget.Transform.Basis.Z;
        Vector3 right = _cameraTarget.Transform.Basis.X;
        
        
        // VERWIJDER DEZE LIJN CODE
        // Vector3 direction = new Vector3(inputDir.X, 0, inputDir.Y).Normalized();
        // ... rest van de code
    }

1. Je wilt alleen horizontale movement, zelfs als de camera schuin naar boven of beneden kijkt. Daarom verwijder je de Y-component van de forward en right vectoren.

public override void _PhysicsProcess(double delta)
{
    // ... de rest van de code 
    
    // Input
    Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");
        
    // Haal camera's forward en right richtingen op
    Vector3 forward = -_cameraTarget.Transform.Basis.Z;
    Vector3 right = _cameraTarget.Transform.Basis.X;
    
    // Verwijder Y component (houd movement horizontaal)
    forward.Y = 0;
    right.Y = 0;
    
    // .. de rest van de code
}

1. Combineer nu de WASD input (inputDir) met de camera richtingen.

public override void _PhysicsProcess(double delta)
{
    // ... de rest van de code 
    
    // Input
    Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");
        
    // Haal camera's forward en right richtingen op
    Vector3 forward = -_cameraTarget.Transform.Basis.Z;
    Vector3 right = _cameraTarget.Transform.Basis.X;
    
    // Verwijder Y component (houd movement horizontaal)
    forward.Y = 0;
    right.Y = 0;
    
    // Combineer input met camera richtingen
    forward = forward.Normalized() * inputDir.Y;
    right = right.Normalized() * inputDir.X;
    
    // .. de rest van de code
}

1. Vervang de waarde van de direction variabele door de som van de forward en right vectoren.

public override void _PhysicsProcess(double delta)
{
    // ... de rest van de code 
    
    // Input
    Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");
        
    // Haal camera's forward en right richtingen op
    Vector3 forward = -_cameraTarget.Transform.Basis.Z;
    Vector3 right = _cameraTarget.Transform.Basis.X;
    
    // Verwijder Y component (houd movement horizontaal)
    forward.Y = 0;
    right.Y = 0;
    
    // Combineer input met camera richtingen
    forward = forward.Normalized() * inputDir.Y;
    right = right.Normalized() * inputDir.X;
    
    // Bereken de bewegings-richting 
    Vector3 direction = (forward + right).Normalized();
    
    // .. de rest van de code
}

1. Als laatste draai het character in de richting waar het heen loopt, maar alleen als er bewogen wordt.

public override void _PhysicsProcess(double delta)
{
    // ... de rest van de code 
    
    // Input
    Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");
        
    // Haal camera's forward en right richtingen op
    Vector3 forward = -_cameraTarget.Transform.Basis.Z;
    Vector3 right = _cameraTarget.Transform.Basis.X;
    
    // Verwijder Y component (houd movement horizontaal)
    forward.Y = 0;
    right.Y = 0;
    
    // Combineer input met camera richtingen
    forward = forward.Normalized() * inputDir.Y;
    right = right.Normalized() * inputDir.X;
    
    // normalize de richting, zodat diagonaal bewegen niet sneller is
    Vector3 direction = (forward + right).Normalized();
    

		if (direction.Length() > 0)
        LookAt(Position + direction);
    
    // .. de rest van de code
}

Player camera target instellen

Voor we kunnen testen, moet de Player weten welke node de camera is.

1. Open scenes/main.tscn

2. Selecteer de Player node (in de scene tree)

3. In de Inspector, vind het Camera Target veld

4. Sleep de View node vanuit de scene tree naar dit veld

Nu kan de Player de View's transform lezen!

Test camera-relative movement

1. Run het spel (F5)

2. Test de camera-relative movement:

   • Draai de camera naar links met arrow keys

   • Druk W - player beweegt nu "vooruit" relatief aan camera!

   • Druk A/D - player straft links/rechts relatief aan camera

   • Dit is 8-directional camera-relative movement!

Complete scripts

Klik hier voor de volledige View.cs en Player.cs scripts

View.cs

using Godot;

public partial class View : Node3D
{
    [Export] private Node3D _target;
    [Export] private Camera3D _camera;
    [Export] private float _followSpeed = 5.0f;
    [Export] private float _rotationSpeed = 2.0f;

    public override void _PhysicsProcess(double delta)
    {
        if (_target == null) return;

        // Smooth follow
        GlobalPosition = GlobalPosition.Lerp(_target.GlobalPosition, _followSpeed * (float)delta);

        // Camera rotation input
        float horizontalInput = Input.GetAxis("camera_left", "camera_right");
        float verticalInput = Input.GetAxis("camera_up", "camera_down");

        // Horizontal rotation (Y-axis)
        RotateY(horizontalInput * _rotationSpeed * (float)delta);

        // Vertical rotation (X-axis)
        Rotate(Transform.Basis.X, verticalInput * _rotationSpeed * (float)delta);

        // Clamp vertical rotation
        Vector3 rotation = Rotation;
        rotation.X = Mathf.Clamp(rotation.X, Mathf.DegToRad(-80), Mathf.DegToRad(-10));
        Rotation = rotation;
    }
}

Player.cs

using Godot;

public partial class Player : CharacterBody3D
{
    [Export] private float _speed = 5.0f;
    [Export] private float _jumpVelocity = 8.0f;
    [Export] private Node3D _cameraTarget;

    public override void _PhysicsProcess(double delta)
    {
        Vector3 velocity = Velocity;

        // Gravity
        if (!IsOnFloor())
        {
            velocity += GetGravity() * (float)delta;
        }

        // Jump
        if (Input.IsActionJustPressed("jump") && IsOnFloor())
        {
            velocity.Y = _jumpVelocity;
        }

        // Input
        Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");

        // Camera-relative movement
        Vector3 forward = -_cameraTarget.Transform.Basis.Z;
        Vector3 right = _cameraTarget.Transform.Basis.X;

        // Verwijder Y component (houd movement horizontaal)
        forward.Y = 0;
        right.Y = 0;

        // Combineer input met camera richtingen
        forward = forward.Normalized() * inputDir.Y;
        right = right.Normalized() * inputDir.X;

        // camera-relative movement
        Vector3 direction = (forward + right).Normalized();

        // Movement
        if (direction != Vector3.Zero)
        {
            velocity.X = direction.X * _speed;
            velocity.Z = direction.Z * _speed;
        }
        else
        {
            velocity.X = Mathf.MoveToward(Velocity.X, 0, _speed);
            velocity.Z = Mathf.MoveToward(Velocity.Z, 0, _speed);
        }

		    if (direction.Length() > 0)
			      LookAt(Position + direction);

        Velocity = velocity;
        MoveAndSlide();
    }
}