SoundOfNight/Shell.cs at main · Mikeware/SoundOfNight · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Godot;

namespace LD60;

public partial class Shell : Control
{
    public static Shell? Instance { get; private set; }

    [Export]
    public PackedScene? InitialScene { get; set; }

    [Export]
    public ShaderMaterial? TransitionMaterial { get; set; }

    [Export]
    public double TransitionHalfDuration { get; set; } = 1.5;

    [Export]
    public Control? SceneHost { get; set; }

    private bool _triggeredTransition;
    private string? _preloadScene;

    public override void _Ready()
    {
        Instance = this;

        _ = WaitForLoadAsync();
    }

    private async Task WaitForLoadAsync()
    {
        // wait for a processed frame
        await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);

        if (InitialScene is null) throw new ArgumentNullException(nameof(InitialScene));
        PreloadScene(InitialScene.ResourcePath);
        _triggeredTransition = true;
    }

    public override void _Process(double delta)
    {
        if (_triggeredTransition &&
            _preloadScene != null &&
            ResourceLoader.LoadThreadedGetStatus(_preloadScene) == ResourceLoader.ThreadLoadStatus.Loaded)
        {
            Node? scene = (ResourceLoader.LoadThreadedGet(_preloadScene) as PackedScene)?.Instantiate();
            if (scene is null) throw new InvalidOperationException($"Could not load scene {_preloadScene}");
            _preloadScene = null;
            _triggeredTransition = false;

            // TODO: Fire Loading event, if needed

            if (SceneHost?.GetChildCount() > 0)
            {
                Node? current = SceneHost?.GetChild(0);
                current?.QueueFree();
            }

            _ = LoadSceneInAsync(scene);
        }
    }

    public void PreloadScene(string nextScene)
    {
        _preloadScene = nextScene;
        ResourceLoader.LoadThreadedRequest(nextScene);
    }

    public void TransitionTo(string nextScene)
    {
        TransitionMaterial?.SetShaderParameter("inverted", false);
        var tween = CreateTween();
        tween.TweenMethod(Callable.From((float v) => TransitionMaterial?.SetShaderParameter("progress", v)), 0.0, 1.0, TransitionHalfDuration)
            .SetEase(Tween.EaseType.In);
        tween.Finished += () =>
        {
            if (nextScene == _preloadScene)
            {
                _triggeredTransition = true;
                return;
            }

            PackedScene scenePack = GD.Load<PackedScene>(nextScene);
            Node scene = scenePack.Instantiate();
            // TODO: Fire Loading event if need to know

            Node? current = SceneHost?.GetChild(0);
            current?.QueueFree();

            _ = LoadSceneInAsync(scene);
        };
    }

    private async Task LoadSceneInAsync(Node scene)
    {
        SceneHost?.AddChild(scene);

        TransitionMaterial?.SetShaderParameter("inverted", true);
        var tween = CreateTween();
        tween.TweenMethod(Callable.From((float v) => TransitionMaterial?.SetShaderParameter("progress", v)), 0.0, 1.0, TransitionHalfDuration)
            .SetEase(Tween.EaseType.In);
        await ToSignal(tween, Tween.SignalName.Finished);
    }
}