From 7e27d6a0fa8f826f56b84e18ae43d9e26bbd7269 Mon Sep 17 00:00:00 2001
From: Paul Joannon <hello@pauljoannon.com>
Date: Thu, 4 Mar 2021 11:31:03 +0100
Subject: [PATCH] add C# code tabs to pages under tutorials/audio

---
 tutorials/audio/recording_with_microphone.rst | 62 +++++++++++++++++++
 tutorials/audio/sync_with_audio.rst           | 43 +++++++++++++
 2 files changed, 105 insertions(+)

diff --git a/tutorials/audio/recording_with_microphone.rst b/tutorials/audio/recording_with_microphone.rst
index 772bfb89f..34673b624 100644
--- a/tutorials/audio/recording_with_microphone.rst
+++ b/tutorials/audio/recording_with_microphone.rst
@@ -38,6 +38,20 @@ An ``AudioStreamPlayer`` named ``AudioStreamRecord`` is used for recording.
         # as an "AudioEffectRecord" resource.
         effect = AudioServer.get_bus_effect(idx, 0)
 
+ .. code-tab:: csharp
+
+    private AudioEffectRecord _effect;
+    private AudioStreamSample _recording;
+
+    public override void _Ready()
+    {
+        // We get the index of the "Record" bus.
+        int idx = AudioServer.GetBusIndex("Record");
+        // And use it to retrieve its first effect, which has been defined
+        // as an "AudioEffectRecord" resource.
+        _effect = (AudioEffectRecord)AudioServer.GetBusEffect(idx, 0);
+    }
+
 The audio recording is handled by the :ref:`class_AudioEffectRecord` resource
 which has three methods:
 :ref:`get_recording() <class_AudioEffectRecord_method_get_recording>`,
@@ -62,6 +76,29 @@ and :ref:`set_recording_active() <class_AudioEffectRecord_method_set_recording_a
             $RecordButton.text = "Stop"
             $Status.text = "Recording..."
 
+  .. code-tab:: csharp
+
+    public void OnRecordButtonPressed()
+    {
+        if (_effect.IsRecordingActive())
+        {
+            _recording = _effect.GetRecording();
+            GetNode<Button>("PlayButton").Disabled = false;
+            GetNode<Button>("SaveButton").Disabled = false;
+            _effect.SetRecordingActive(false);
+            GetNode<Button>("RecordButton").Text = "Record";
+            GetNode<Label>("Status").Text = "";
+        }
+        else
+        {
+            GetNode<Button>("PlayButton").Disabled = true;
+            GetNode<Button>("SaveButton").Disabled = true;
+            _effect.SetRecordingActive(true);
+            GetNode<Button>("RecordButton").Text = "Stop";
+            GetNode<Label>("Status").Text = "Recording...";
+        }
+    }
+
 At the start of the demo, the recording effect is not active. When the user
 presses the ``RecordButton``, the effect is enabled with
 ``set_recording_active(true)``.
@@ -84,6 +121,22 @@ the recorded stream can be stored into the ``recording`` variable by calling
         $AudioStreamPlayer.stream = recording
         $AudioStreamPlayer.play()
 
+  .. code-tab:: csharp
+
+    public void OnPlayButtonPressed()
+    {
+        GD.Print(_recording);
+        GD.Print(_recording.Format);
+        GD.Print(_recording.MixRate);
+        GD.Print(_recording.Stereo);
+        byte[] data = _recording.Data;
+        GD.Print(data);
+        GD.Print(data.Length);
+        var audioStreamPlayer = GetNode<AudioStreamPlayer>("AudioStreamPlayer");
+        audioStreamPlayer.Stream = _recording;
+        audioStreamPlayer.Play();
+    }
+
 To playback the recording, you assign the recording as the stream of the
 ``AudioStreamPlayer`` and call ``play()``.
 
@@ -95,5 +148,14 @@ To playback the recording, you assign the recording as the stream of the
         recording.save_to_wav(save_path)
         $Status.text = "Saved WAV file to: %s\n(%s)" % [save_path, ProjectSettings.globalize_path(save_path)]
 
+  .. code-tab:: csharp
+
+    public void OnSavebuttonPressed()
+    {
+        string savePath = GetNode<LineEdit>("SaveButton/Filename").Text;
+        _recording.SaveToWav(savePath);
+        GetNode<Label>("Status").Text = string.Format("Saved WAV file to: {0}\n({1})", savePath, ProjectSettings.GlobalizePath(savePath));
+    }
+
 To save the recording, you call ``save_to_wav()`` with the path to a file.
 In this demo, the path is defined by the user via a ``LineEdit`` input box.
diff --git a/tutorials/audio/sync_with_audio.rst b/tutorials/audio/sync_with_audio.rst
index 987c75562..ad00c8974 100644
--- a/tutorials/audio/sync_with_audio.rst
+++ b/tutorials/audio/sync_with_audio.rst
@@ -56,6 +56,25 @@ Add these two and it's possible to guess almost exactly when sound or music will
         time = max(0, time)
         print("Time is: ", time)
 
+ .. code-tab:: csharp
+
+    private double _timeBegin;
+    private double _timeDelay;
+
+    public override void _Ready()
+    {
+        _timeBegin = OS.GetTicksUsec();
+        _timeDelay = AudioServer.GetTimeToNextMix() + AudioServer.GetOutputLatency();
+        GetNode<AudioStreamPlayer>("Player").Play();
+    }
+
+    public override void _Process(float _delta)
+    {
+        double time = (OS.GetTicksUsec() - _timeBegin) / 1000000.0d;
+        time = Math.Max(0.0d, time - _timeDelay);
+        GD.Print(string.Format("Time is: {0}", time));
+    }
+
 
 In the long run, though, as the sound hardware clock is never exactly in sync with the system clock, the timing information will slowly drift away.
 
@@ -76,6 +95,11 @@ Adding the return value from this function to *get_playback_position()* increase
 
     var time = $Player.get_playback_position() + AudioServer.get_time_since_last_mix()
 
+ .. code-tab:: csharp
+    
+    double time = GetNode<AudioStreamPlayer>("Player").GetPlaybackPosition() + AudioServer.GetTimeSinceLastMix();
+
+
 To increase precision, subtract the latency information (how much it takes for the audio to be heard after it was mixed):
 
 .. tabs::
@@ -83,6 +107,10 @@ To increase precision, subtract the latency information (how much it takes for t
 
     var time = $Player.get_playback_position() + AudioServer.get_time_since_last_mix() - AudioServer.get_output_latency()
 
+ .. code-tab:: csharp
+
+    double time = GetNode<AudioStreamPlayer>("Player").GetPlaybackPosition() + AudioServer.GetTimeSinceLastMix() - AudioServer.GetOutputLatency();
+
 The result may be a bit jittery due how multiple threads work. Just check that the value is not less than in the previous frame (discard it if so). This is also a less precise approach than the one before, but it will work for songs of any length, or synchronizing anything (sound effects, as an example) to music.
 
 Here is the same code as before using this approach:
@@ -100,3 +128,18 @@ Here is the same code as before using this approach:
         # Compensate for output latency.
         time -= AudioServer.get_output_latency()
         print("Time is: ", time)
+
+ .. code-tab:: csharp
+
+    public override void _Ready()
+    {
+        GetNode<AudioStreamPlayer>("Player").Play();
+    }
+
+    public override void _Process(float _delta)
+    {
+        double time = GetNode<AudioStreamPlayer>("Player").GetPlaybackPosition() + AudioServer.GetTimeSinceLastMix();
+        // Compensate for output latency.
+        time -= AudioServer.GetOutputLatency();
+        GD.Print(string.Format("Time is: {0}", time));
+    }