Speed Effects

Voeg dynamische camera effecten en speed lines toe voor een intens gevoel van snelheid

Overzicht

Voeg camera-effecten en visuele feedback toe die activeren tijdens boosten:

• Dynamic FOV - Field of View vergroot tijdens boost

• Speed lines - Particles langs de zijkanten van het scherm tijdens boost

Camera fov - basis concept

Field of View (FOV) is de hoek waarmee de camera de wereld ziet. Een grotere FOV geeft een "tunnelvisie" effect dat snelheid benadrukt. Pas de FOV aan wanneer de speler boost.

Normale FOV: 75° (standaard waarde) Boost FOV: 90° (tijdens boost)

Camera referentie toevoegen

Je moet de camera kunnen aansturen vanuit het PlayerController script.

1. Open scripts/PlayerController.cs

2. We voegen een exported field toe voor de camera.

using Godot;

public partial class PlayerController : CharacterBody3D
{
    [Export] private float _forwardSpeed = 10.0f;
    [Export] private float _turnSpeed = 2.0f;
    [Export] private float _verticalSpeed = 5.0f;

    [Export] private Camera3D _camera;

    // ... rest van de code
}

Dynamic fov implementeren

Pas de FOV nu dynamisch aan tijdens boosten.

1. Voeg eerst FOV-constanten toe bovenaan de class:

using Godot;

public partial class PlayerController : CharacterBody3D
{
    [Export] private float _forwardSpeed = 10.0f;
    [Export] private float _turnSpeed = 2.0f;
    [Export] private float _verticalSpeed = 5.0f;

    [Export] private Camera3D _camera;

    private const float BaseFov = 75.0f;
    private const float BoostFov = 90.0f;

    // ... rest van de code
}

1. Voeg nu een methode toe die de FOV update aan het einde van de class:

private void UpdateCameraFov()
{
    if (_camera == null)
        return;

    // Bepaal target FOV: boost of normaal
    float targetFov = Input.IsActionPressed("boost") ? BoostFov : BaseFov;

    // Smooth interpolatie naar target FOV
    _camera.Fov = Mathf.Lerp(_camera.Fov, targetFov, 0.1f);
}

1. Roep deze methode nu aan in _Process, aan het einde:

public override void _Process(double delta)
{
    UpdateCameraFov();
}

Uitleg: Check of de boost-actie is ingedrukt en kies de juiste target FOV. Met Mathf.Lerp interpoleren we soepel van de huidige FOV naar de target (75° of 90°). Dit zorgt voor een smooth zoom-in/zoom-out effect tijdens boosten.

Camera toewijzen in de editor

1. Open scenes/main.tscn

2. Selecteer de Player node

3. In de Inspector, zie je nu een nieuwe property: Camera

4. Klik op Assign en navigeer naar Player > Camera3D

5. Selecteer de Camera3D node

6. Sla de scene op

Speed lines - gpuparticles3d

Speed lines zijn streepjes die vanaf de zijkanten naar achteren vliegen, wat de illusie van snelheid versterkt. Gebruik GPUParticles3D voor optimale performance.

1. Open scenes/main.tscn of je Player scene

2. Selecteer de Camera3D node (onder Player)

3. Rechts-klik > Add Child Node > GPUParticles3D

4. Hernoem deze node naar SpeedLines

5. Sla de scene op

Scene hierarchy:

Camera3D
└── SpeedLines (GPUParticles3D)

Speed lines position en rotatie

De particles moeten net voor de camera zitten, zodat ze het hele scherm vullen. Roteer ze ook 90 graden zodat de lines horizontaal zijn (van links naar rechts in plaats van verticaal).

1. Selecteer de SpeedLines node

2. In de Inspector, onder Transform:

   • Position:

     • X: 0

     • Y: 0

     • Z: -3 (voor de camera)

   • Rotation (in graden):

     • X: 0

     • Y: 0

     • Z: 90 (draai 90° zodat lines horizontaal zijn)

Speed lines settings

1. Selecteer de SpeedLines node

2. In de Inspector:

   • Emitting: UIT (we schakelen dit via script in)

   • Amount: 50 (aantal speed lines tegelijk)

3. Onder Time:

   • Lifetime: 0.5 (hoe lang elke line zichtbaar is)

   • Preprocess: 0

   • Speed Scale: 2.0

   • Explosiveness: 0

   • Randomness: 0.3

   • Fixed FPS: 60

4. Onder Drawing:

   • Local Coords: aan (lines bewegen met camera mee)

   • Draw Order: Index

Speed Lines Process Material

1. Selecteer de SpeedLines node

2. In de Inspector, vind Process Material

3. Klik op het dropdown > New ParticleProcessMaterial

4. Klik op de nieuwe ParticleProcessMaterial

Emission shape

Lines moeten vanaf een ring-vorm komen, zodat ze vanaf de randen van het scherm naar het midden vliegen.

1. Onder Spawn > Position > emission Shape, selecteer Ring

2. Configureer de ring settings:

   • Emission Ring Axis:

     • X: 90

     • Y: 0

     • Z: 1

   • Emission Ring Height: 0.0

   • Emission Ring Radius: 3.0

   • Emission Ring Inner Radius: 2.0

   • Emission Ring Cone Angle: 90.0

Velocity

Lines moeten naar het midden vliegen (richting -X).

1. Onder Spawn > Velocity > Direction, zet:

   • X: -1 (naar links/midden, maar omdat we het hele systeem 90° hebben gedraaid feitelijk naar achter)

   • Y: 0

   • Z: 0

2. Onder Spread, zet 5 (kleine variatie)

3. Onder ### initial velocity, zet:

   • Min: 15.0

   • Max: 25.0

Scale

Speed lines moeten variëren in grootte voor een natuurlijk effect.

1. Onder Display > Scale, zet:

   • Min: 0.8 (79,9999%)

   • Max: 1.2 (119,9999%)

Speed lines color

Gebruik een wit-naar-transparant-gradient zodat lines vervagen.

1. Onder Display > Color Curves > Color, klik het [empty] veld naast Color Ramp

2. Selecteer New GradientTexture1D

3. Klik op de nieuwe GradientTexture1D

4. Klik op het [empty] veld naast Gradient

5. Selecteer New Gradient

6. Klik op de nieuwe Gradient

1. Klik op de linker color marker (start van de gradient)

2. In de color picker, zet (wit, volledig zichtbaar):

   • R: 1.0

   • G: 1.0

   • B: 1.0

   • A: 1.0

1. Klik op de rechter color marker (einde van de gradient)

2. In de color picker, zet (wit, volledig transparant):

   • R: 1.0

   • G: 1.0

   • B: 1.0

   • A: 0.0

Speed lines mesh

Gebruik een QuadMesh met een glowing material voor de speed lines.

1. Selecteer de SpeedLines node

2. In de Inspector, vind Draw Passes

3. Onder Pass 1, klik het dropdown > New QuadMesh

4. Klik op de nieuwe QuadMesh

5. Zet Size op:

   • X: 1.5 (horizontaal lang voor streepjes)

   • Y: 0.05 (heel dun verticaal)

Speed lines material

Om de speed lines goed zichtbaar te maken, voegen we een glowing material toe.

1. Klik op het QuadMesh dat je net hebt aangemaakt

2. Onder Material, klik het dropdown > New StandardMaterial3D

3. Klik op de nieuwe StandardMaterial3D om de properties te openen

4. Configureer het material:

   • Cull Mode: Back (render alleen de voorkant)

   • Emission:

     • Vink Enabled aan

     • Emission: Wit (#FFFFFF of R:1, G:1, B:1)

     • Energy Multiplier: 2.25 (voor extra glow)

Speed lines triggeren via script

Nu moet je de speed lines aan- en uitzetten tijdens boosten.

1. Open scripts/PlayerController.cs

2. Voeg eerst een exported field toe voor de speed lines.

using Godot;

public partial class PlayerController : CharacterBody3D
{
    [Export] private float _forwardSpeed = 10.0f;
    [Export] private float _turnSpeed = 2.0f;
    [Export] private float _verticalSpeed = 5.0f;

    [Export] private Camera3D _camera;
    [Export] private GpuParticles3D _speedLines;

    private const float BaseFov = 75.0f;
    private const float BoostFov = 90.0f;

    // ... rest van de code
}

1. Update nu de speed lines in UpdateCameraFov(). Speed lines verschijnen alleen tijdens boosten.

private void UpdateCameraFov()
{
    if (_camera == null)
        return;

    // Check of speler aan het boosten is
    bool isBoosting = Input.IsActionPressed("boost");

    // Bepaal target FOV: boost of normaal
    float targetFov = isBoosting ? BoostFov : BaseFov;

    // Smooth interpolatie naar target FOV
    _camera.Fov = Mathf.Lerp(_camera.Fov, targetFov, 0.1f);

    // Update speed lines
    _speedLines.Emitting = isBoosting;
}

Uitleg: Hergebruik de isBoosting-check voor zowel de FOV als de speed lines. Beide effecten activeren tegelijkertijd tijdens boost, wat zorgt voor een krachtig en samenhangend visueel effect.

Speed lines toewijzen in de editor

1. Open scenes/main.tscn

2. Selecteer de Player node

3. In de Inspector, zie je nu een nieuwe property: Speed Lines

4. Klik op Assign en navigeer naar Player > Camera3D > SpeedLines

5. Selecteer de SpeedLines node

6. Sla de scene op

Test de speed effects

Test met F5!

Je zou nu moeten zien:

• Wanneer je de spatiebalk indrukt om te boosten, vergroot de FOV geleidelijk

• Speed lines verschijnen tegelijkertijd vanaf de zijkanten

• Lines vliegen naar achteren en vervagen

• Wanneer je de boost loslaat, krimpt de FOV weer en verdwijnen de lines smooth

• Het effect geeft een krachtig gevoel van extra snelheid tijdens boost

Als de effecten niet werken:

• Check of de Camera correct is toegewezen in de Inspector

• Controleer of SpeedLines correct is toegewezen

• Zorg dat SpeedLines Emitting UIT staat (script schakelt het in)

• Controleer of de "boost" input actie correct is geconfigureerd

• Check of UpdateCameraFov() wordt aangeroepen in _Process

Complete Script

Het volledige PlayerController script met speed effects

PlayerController.cs

using Godot;

public partial class PlayerController : CharacterBody3D
{
    [Export] private float _forwardSpeed = 10.0f;
    [Export] private float _turnSpeed = 2.0f;
    [Export] private float _verticalSpeed = 5.0f;
    [Export] private float _boostMultiplier = 1.2f;
    [Export] private float _maxHeight = 4f;
    [Export] private float _bankAngle = 30f;
    [Export] private float _bankSpeed = 5f;
    [Export] private float _boostTransitionSpeed = 3f;

    [Export] private Camera3D _camera;
    [Export] private GpuParticles3D _speedLines;

    private const float BaseFov = 75.0f;
    private const float BoostFov = 90.0f;

    private float _currentSpeed;

    public override void _PhysicsProcess(double delta)
    {
        Vector3 movement = Vector3.Zero;
        float turnInput = 0f;

        // Bepaal target snelheid: boost of normaal
        float targetSpeed = _forwardSpeed;
        if (Input.IsActionPressed("boost"))
            targetSpeed *= _boostMultiplier;

        // Smooth transitie naar target speed
        _currentSpeed = Mathf.Lerp(_currentSpeed, targetSpeed, _boostTransitionSpeed * (float)delta);

        // Auto-forward movement met smooth boost
        movement += Transform.Basis.Z * -_currentSpeed;

        // Links/Rechts - draai het schip EN kantel het
        if (Input.IsActionPressed("move_left"))
        {
            Rotation = new Vector3(Rotation.X, Rotation.Y + _turnSpeed * (float)delta, Rotation.Z);
            turnInput = 1f;
        }
        else if (Input.IsActionPressed("move_right"))
        {
            Rotation = new Vector3(Rotation.X, Rotation.Y - _turnSpeed * (float)delta, Rotation.Z);
            turnInput = -1f;
        }

        // Smooth banking
        float targetBankAngle = turnInput * Mathf.DegToRad(_bankAngle);
        float newBankAngle = Mathf.Lerp(Rotation.Z, targetBankAngle, _bankSpeed * (float)delta);

        Rotation = new Vector3(Rotation.X, Rotation.Y, newBankAngle);

        // Omhoog/Omlaag (Y-as)
        if (Input.IsActionPressed("move_up"))
            movement.Y += _verticalSpeed;
        if (Input.IsActionPressed("move_down"))
            movement.Y -= _verticalSpeed;

        // Pas de Velocity aan en beweeg met physics
        Velocity = movement;
        MoveAndSlide();

        // Beperk hoogte
        float clampedY = Mathf.Clamp(Position.Y, 0.5f, _maxHeight);
        Position = new Vector3(Position.X, clampedY, Position.Z);
    }

    public override void _Process(double delta)
    {
        UpdateCameraFov();
    }

    private void UpdateCameraFov()
    {
        if (_camera == null)
            return;

        // Check of speler aan het boosten is
        bool isBoosting = Input.IsActionPressed("boost");

        // Bepaal target FOV: boost of normaal
        float targetFov = isBoosting ? BoostFov : BaseFov;

        // Smooth interpolatie naar target FOV
        _camera.Fov = Mathf.Lerp(_camera.Fov, targetFov, 0.1f);

        // Update speed lines
        _speedLines.Emitting = isBoosting;
    }
}