6. Independent Camera met Smooth Following

Maak een independent camera script met smooth following en NodePath

Overzicht

De camera volgt nu het ruimteschip als een child node, maar je kunt dit veel professioneler maken! In dit hoofdstuk leer je hoe je een onafhankelijk camerascript maakt met smooth following en automatische oriëntatie.

Camera script

Maak de camera onafhankelijk van de Player hierarchy. Dit geeft je volledige controle over hoe de camera het schip volgt, en maakt smooth following mogelijk.

Nieuwe Godot-specifieke elementen:

• NodePath - Een pad naar een andere node in de scene tree (bijv. "../Player")

• GetNode<T>(path) - Haalt een node reference op via een NodePath

1. In Godot, versleep de Camera3D node uit de Player hierarchy naar de root (Level)

   • Sleep Camera3D naar Level in de hierarchy

   • De camera is nu een sibling van Player in plaats van een child

2. Rechtsklik op Camera3D en kies Attach Script

3. Configureer het script dialoog:

   • Language: C#

   • Inherits: Camera3D

   • Class Name: CameraController

   • Path: res://Scripts/CameraController.cs

4. Klik Create - het script opent in VS Code

Basis camera following

Maak eerst een simpele versie waar de camera direct het schip volgt (zonder smooth movement).

Nieuwe Godot-specifieke elementen:

• [Export] - Maakt variabelen instelbaar in de Inspector

• GlobalPosition - De absolute positie in de wereld (vs Position die relatief is aan de parent)

1. Start met de basis class structuur:

using Godot;

public partial class CameraController : Camera3D
{
}

1. Voeg een target variabele toe om de Player bij te houden:

using Godot;

public partial class CameraController : Camera3D
{
    [Export] private PlayerController _target;
}

1. Voeg een offset variabele toe (de camera positie relatief tot het schip):

using Godot;

public partial class CameraController : Camera3D
{
    [Export] private PlayerController _target;
    [Export] private Vector3 _offset = new Vector3(0, 3, 6);
}

Dit betekent: 3 eenheden omhoog, 6 eenheden naar achteren ten opzichte van het schip.

1. Voeg de _PhysicsProcess() method toe:

using Godot;

public partial class CameraController : Camera3D
{
    [Export] private PlayerController _target;
    [Export] private Vector3 _offset = new Vector3(0, 3, 6);

    public override void _PhysicsProcess(double delta)
    {
    }
}

1. Voeg de basic following code toe:

    public override void _PhysicsProcess(double delta)
    {
        // Volg de target op een vaste afstand (offset)
        GlobalPosition = _target.GlobalPosition + _offset;
    }

Zet de camera positie elke frame naar de positie van het schip plus de offset. Dit geeft hetzelfde effect als toen de camera een child was, maar nu heb je volledige controle!

1. Sla op en ga terug naar Godot

2. Build je project (ALT+B of klik het hamertje rechtsboven)

3. Selecteer de Camera3D node in de Scene Hierarchy

4. In de Inspector zie je nu nieuwe properties:

   • Target: Sleep de Player node hierheen

   • Offset: Staat al op (0, 3, 6)

5. Test met F6 - de camera volgt de speler!

Smooth following toevoegen

De camera volgt nu het schip, maar springt elke frame instant naar de nieuwe positie. Dit voelt nogal stijfjes aan. Gebruik lineaire interpolatie (lerp) om de camera geleidelijk te laten bewegen naar de gewenste positie.

Nieuwe Godot-specifieke elementen:

• Vector3.Lerp(target, weight): In tegenstelling tot Mathf.Lerp, kan je ook Lerp aanroepen op een Vector3. De Lerp functie berekent dan een interpolatie tussen de vector waarop je Lerp aanroept, en een target vector. De weight is nog steeds een waarde tussen 0 en 1 die bepaalt waar je je bevindt in de transitie.

1. Voeg een smoothSpeed variabele toe:

[Export] private float _smoothSpeed = 5f;

1. Vervang de instant following door smooth interpolation:

Oude code (verwijder dit):

public override void _PhysicsProcess(double delta)
{
    // Volg de target op een vaste afstand (offset)
    GlobalPosition = _target.GlobalPosition + _offset;
}

Nieuwe code (voeg dit toe):

public override void _PhysicsProcess(double delta)
{
    // Bereken gewenste positie
    // Transformeer de offset met de rotatie van de target zodat de camera achter de target blijft
    Vector3 rotatedOffset = _target.GlobalTransform.Basis * _offset;
    Vector3 desiredPosition = _target.GlobalPosition + rotatedOffset;

    // Smooth follow met lerp - beweeg geleidelijk naar de gewenste positie
    GlobalPosition = GlobalPosition.Lerp(desiredPosition, _smoothSpeed * (float)delta);
}

Bereken eerst waar de camera naartoe wil (desiredPosition), en gebruik dan Lerp() om geleidelijk in die richting te bewegen in plaats van er instant naartoe te springen.

1. Test met F6 - de camera volgt nu smooth! Probeer te draaien en te bewegen - de camera volgt vloeiend.

Experimenteer met smoothSpeed:

• Bij smoothSpeed = 5: camera beweegt snel, volgt het schip nauwkeurig

• Bij smoothSpeed = 2: camera beweegt langzamer, voelt cinematischer aan

• Bij smoothSpeed = 10: camera volgt bijna instant (minder smooth effect)

Pas Smooth Speed aan in de Inspector en test het verschil!

Camera oriëntatie met lookat

De camera volgt nu smooth, maar blijft altijd in dezelfde richting kijken. Als het schip draait of van richting verandert, zou het veel dynamischer zijn als de camera altijd naar het schip blijft kijken. Hiervoor gebruik je LookAt().

Nieuwe Godot-specifieke elementen:

• LookAt(target, up) - Richt de camera automatisch naar een positie

  • target = Vector3 positie om naar te kijken

  • up = Vector3.Up definieert de "omhoog" richting (meestal (0,1,0))

  • De camera draait automatisch zodat deze naar de target wijst

1. Voeg één regel toe aan het einde van _PhysicsProcess():

    public override void _PhysicsProcess(double delta)
    {
        // Transform the offset by the target's rotation so it stays behind the target
        Vector3 rotatedOffset = _target.GlobalTransform.Basis * _offset;
        Vector3 desiredPosition = _target.GlobalPosition + rotatedOffset;

        // Smooth follow met lerp - beweeg geleidelijk naar de gewenste positie
        GlobalPosition = GlobalPosition.Lerp(desiredPosition, _smoothSpeed * (float)delta);

        // Kijk altijd naar de target
        LookAt(_target.GlobalPosition, Vector3.Up);
    }

LookAt() berekent automatisch de juiste camera rotatie om naar het schip te kijken. Gebruik Vector3.Up om te zorgen dat de camera rechtop blijft.

1. Test met F6 - de camera kijkt nu altijd naar het schip! Vlieg in een cirkel en zie hoe de camera het schip blijft volgen én ernaar blijft kijken.

Complete Script

Klik hier voor het volledige CameraController.cs script

using Godot;

public partial class CameraController : Camera3D
{
	[Export] private PlayerController _target;
	[Export] private Vector3 _offset = new Vector3(0, 3, 6);
	[Export] private float _smoothSpeed = 5f;

	public override void _PhysicsProcess(double delta)
	{
		// Transform the offset by the target's rotation so it stays behind the target
		Vector3 rotatedOffset = _target.GlobalTransform.Basis * _offset;
		Vector3 desiredPosition = _target.GlobalPosition + rotatedOffset;

		// Smooth follow met lerp - beweeg geleidelijk naar de gewenste positie
		GlobalPosition = GlobalPosition.Lerp(desiredPosition, _smoothSpeed * (float)delta);

		// Kijk altijd naar de target
		LookAt(_target.GlobalPosition, Vector3.Up);
	}
}