From d704a54aa1b329efbecdfa0a5aed2150ffdc0ed6 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Sat, 9 May 2026 00:42:54 +0100
Subject: [PATCH 01/20] Audio setup with WAV file loading

OpenAL code to load PCM data and play it back, along with basic WAV file loader
---
 src/rasdaq/Application.cs        |   5 +
 src/rasdaq/Audio/Audio.cs        |  23 +++++
 src/rasdaq/Audio/AudioManager.cs | 143 ++++++++++++++++++++++++++
 src/rasdaq/Audio/AudioSource.cs  |  23 +++++
 src/rasdaq/Audio/WAVLoader.cs    | 167 +++++++++++++++++++++++++++++++
 5 files changed, 361 insertions(+)
 create mode 100644 src/rasdaq/Audio/Audio.cs
 create mode 100644 src/rasdaq/Audio/AudioManager.cs
 create mode 100644 src/rasdaq/Audio/AudioSource.cs
 create mode 100644 src/rasdaq/Audio/WAVLoader.cs

diff --git a/src/rasdaq/Application.cs b/src/rasdaq/Application.cs
index 59a4c51..98705c8 100644
--- a/src/rasdaq/Application.cs
+++ b/src/rasdaq/Application.cs
@@ -1,6 +1,8 @@
 using OpenTK.Graphics.OpenGL4;
 using OpenTK.Windowing.Common;
 using OpenTK.Windowing.Desktop;
+
+using rasdaq.Audio;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Inputs;
@@ -22,6 +24,8 @@ public sealed class Application : IDisposable
     public static Application? Instance { get; private set; }
     internal InputManager InputManager { get; set; }
 
+    public AudioManager AudioManager { get; private set; }
+
     private List<World> _worlds = new();
     private GameWindow _gameWindow;
 
@@ -57,6 +61,7 @@ public Application(int width, int height, string title)
         _gameWindow.FramebufferResize += OnFramebufferResize;
 
         InputManager = new InputManager(new GameWindowWrapper(_gameWindow));
+        AudioManager = new AudioManager();
     }
 
     internal void RegisterWorld(World world)
diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
new file mode 100644
index 0000000..95b0179
--- /dev/null
+++ b/src/rasdaq/Audio/Audio.cs
@@ -0,0 +1,23 @@
+using OpenTK.Audio.OpenAL;
+
+namespace rasdaq.Audio;
+
+public class Audio : IDisposable
+{
+    public int Handle;
+    public Audio()
+    {
+        Handle = AL.GenBuffer();
+        // Check for errors
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            throw new Exception("OpenAL error while trying to create audio buffer: " + error);
+        }
+    }
+
+    public void Dispose()
+    {
+        AL.DeleteBuffer(Handle);
+    }
+}
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
new file mode 100644
index 0000000..e2011cb
--- /dev/null
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -0,0 +1,143 @@
+using OpenTK.Audio.OpenAL;
+
+namespace rasdaq.Audio;
+
+public class AudioManager
+{
+    private static void CheckALCError(ALDevice device)
+    {
+        AlcError error = ALC.GetError(device);
+        if (error != AlcError.NoError)
+        {
+            throw new Exception("OpenAL error: " + error);
+        }
+    }
+
+    private static void CheckALError()
+    {
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            throw new Exception("OpenAL error: " + error);
+        }
+    }
+
+    /// <summary>
+    /// Initialize Audio for the Application, using the default audio device.
+    /// </summary>
+    /// <exception cref="Exception"></exception>
+    public AudioManager()
+    {
+        // Open the default audio device.
+        ALDevice device = ALC.OpenDevice(null);
+        if (device == ALDevice.Null)
+        {
+            throw new Exception("Failed to open the default audio device.");
+        }
+
+        // Create a context for the device.
+        ALContext context = ALC.CreateContext(device, new ALContextAttributes(null, null, null, null, null));
+        if (context == ALContext.Null)
+        {
+            ALC.CloseDevice(device);
+            throw new Exception("Failed to create an OpenAL context.");
+        }
+
+        // Check if we have any errors.
+        AlcError error = ALC.GetError(device);
+        CheckALCError(device);
+        // If no errors, make the context current.
+        ALC.MakeContextCurrent(context);
+    }
+
+    /// <summary>
+    /// Load a WAV file that contains PCM data only.
+    /// </summary>
+    /// <param name="path">Path to WAV file</param>
+    /// <returns>A integer handle referring to the loaded audio</returns>
+    /// <exception cref="Exception"></exception>
+    public Audio LoadAudio(string path)
+    {
+        // Create an OpenAL buffer for the data to go in.
+        Audio audio = new Audio();
+
+        // Load the WAV file
+        WAVLoader.WAVData wavData = WAVLoader.LoadWav(path);
+
+        // Discern the format of the audio data based on number of channels and bits per sample.
+        ALFormat format;
+        if (wavData.Format.NumChannels == 1)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Mono8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Mono16;
+            }
+            else
+            {
+                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+            }
+        }
+        else if (wavData.Format.NumChannels == 2)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Stereo8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Stereo16;
+            }
+            else
+            {
+                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+            }
+        }
+        else
+        {
+            throw new Exception("Unsupported number of channels: " + wavData.Format.NumChannels);
+        }
+
+        // Load the audio data into the OpenAL buffer.
+        AL.BufferData(audio.Handle, format, wavData.Data.Data, (int)wavData.Format.SampleRate);
+
+        // Check if we have any errors from trying to load the audio data.
+        CheckALError();
+
+        return audio;
+    }
+
+    /// <summary>
+    /// Add a loaded audio file to an audio source, so that it can be played.
+    /// </summary>
+    /// <param name="audioHandle">Integer handle of loaded audio file</param>
+    /// <param name="sourceHandle">Integer handle of audio source</param>
+    public void AttachAudioToSource(Audio audio, AudioSource audioSource)
+    {
+        AL.Source(audio.Handle, ALSourcei.Buffer, audioSource.Handle);
+        CheckALError();
+    }
+
+    /// <summary>
+    /// Play back an audio source that has audio attached to it.
+    /// </summary>
+    /// <param name="source"></param>
+    public void PlaySource(AudioSource audioSource)
+    {
+        AL.SourcePlay(audioSource.Handle);
+        CheckALError();
+    }
+
+    /// <summary>
+    /// Stop playback of an audio source.
+    /// </summary>
+    /// <param name="source"></param>
+    public void StopSource(AudioSource audioSource)
+    {
+        AL.SourceStop(audioSource.Handle);
+        CheckALError();
+    }
+}
\ No newline at end of file
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
new file mode 100644
index 0000000..2064905
--- /dev/null
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -0,0 +1,23 @@
+using OpenTK.Audio.OpenAL;
+
+namespace rasdaq.Audio;
+
+public class AudioSource : IDisposable
+{
+    public int Handle;
+    public AudioSource()
+    {
+        Handle = AL.GenSource();
+        // Check for errors
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            throw new Exception("OpenAL error while trying to create audio source: " + error);
+        }
+    }
+
+    public void Dispose()
+    {
+        AL.DeleteSource(Handle);
+    }
+}
diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
new file mode 100644
index 0000000..d2e5f8a
--- /dev/null
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -0,0 +1,167 @@
+using System.Buffers.Binary;
+using System.Text;
+
+namespace rasdaq.Audio;
+
+internal class WAVLoader
+{
+    /// <summary>
+    /// Format information about the WAV file.
+    /// </summary>
+    public struct FmtChunk
+    {
+        public ushort AudioFormat;
+        public ushort NumChannels;
+        public uint SampleRate;
+        public uint ByteRate;
+        public ushort BlockAlign;
+        public ushort BitsPerSample;
+        public FmtChunkExtension? Extension;
+    };
+    /// <summary>
+    /// Extra format information for certain WAV files.
+    /// </summary>
+    public struct FmtChunkExtension
+    {
+        public ushort ValidBitsPerSample;
+        public uint SpeakerPositionMask;
+        public Guid SubFormat;
+    }
+
+    /// <summary>
+    /// Holds the data of the WAV file, should be PCM data, as that is all is supported currently.
+    /// </summary>
+    public struct DataChunk
+    {
+        public uint Size;
+        public byte[] Data;
+    }
+
+    /// <summary>
+    /// Holds all the information necessary about a WAV file, namely,
+    /// the format information and the data itself.
+    /// </summary>
+    public struct WAVData
+    {
+        public FmtChunk Format;
+        public DataChunk Data;
+    }
+
+    private static byte[] ReadBytesFromStream(FileStream stream, int count)
+    {
+        byte[] buffer = new byte[count];
+        stream.ReadExactly(buffer, 0, count);
+        return buffer;
+    }
+
+    private static FmtChunk ProcessFmtChunck(FileStream stream)
+    {
+        uint size = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+
+        FmtChunk chunk = new FmtChunk();
+        chunk.AudioFormat = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.NumChannels = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.SampleRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.ByteRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.BlockAlign = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.BitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+
+        if (size > 16)
+        {
+            ushort extensionSize = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+            if (extensionSize == 22)
+            {
+                chunk.Extension = new FmtChunkExtension()
+                {
+                    ValidBitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2)),
+                    SpeakerPositionMask = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4)),
+                    SubFormat = new Guid(ReadBytesFromStream(stream, 16))
+                };
+            }
+        }
+
+        return chunk;
+    }
+
+    private static DataChunk ProcessDataChunk(FileStream stream)
+    {
+        DataChunk chunk = new DataChunk();
+        chunk.Size = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.Data = ReadBytesFromStream(stream, (int)chunk.Size);
+        return chunk;
+    }
+
+    /// <summary>
+    /// Load the WAV file at the given path and return a WAVData struct containing the format information and the data itself.
+    /// </summary>
+    /// <param name="path">The path to the WAV file.</param>
+    /// <returns>A WAVData struct containing the format information and the data.</returns>
+    /// <exception cref="Exception">Thrown if the WAV file is not found or is invalid.</exception>
+    public static WAVData LoadWav(string path)
+    {
+        if (!File.Exists(path))
+        {
+            throw new Exception("WAV file not found: " + path);
+        }
+
+        using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
+        {
+            // Read the RIFF header at the start of the WAV file.
+            byte[] fourcc = new byte[4];
+            stream.ReadExactly(fourcc, 0, 4);
+            if (Encoding.ASCII.GetString(fourcc) != "RIFF")
+            {
+                throw new Exception("Invalid WAV file: missing RIFF header.");
+            }
+
+            // Read the file size
+            byte[] byteFileSize = new byte[4];
+            stream.ReadExactly(byteFileSize, 0, 4);
+            int fileSize = BinaryPrimitives.ReadInt32LittleEndian(byteFileSize) - 4;
+
+            // Check file type is WAVE
+            byte[] byteFileType = new byte[4];
+            stream.ReadExactly(byteFileType, 0, 4);
+            Encoding.UTF8.GetString(byteFileType);
+            if (Encoding.ASCII.GetString(byteFileType) != "WAVE")
+            {
+                throw new Exception("Invalid WAV file: file type not listed as WAVE in RIFF header.");
+            }
+
+            FmtChunk fmtChunk = new FmtChunk();
+            DataChunk dataChunk = new DataChunk();
+
+            // Now read the remaining chunks, we want a fmt chunk and a data chunk.
+            while (stream.Position < stream.Length - 4)
+            {
+                byte[] chunkId = new byte[4];
+                stream.ReadExactly(chunkId, 0, 4);
+
+                if (chunkId.SequenceEqual(Encoding.ASCII.GetBytes("fmt ")))
+                {
+                    fmtChunk = ProcessFmtChunck(stream);
+
+                    if (fmtChunk.AudioFormat != 1)
+                    {
+                        throw new Exception("Unsupported WAV file: only PCM format is supported.");
+                    }
+                }
+                else if (chunkId.SequenceEqual(Encoding.ASCII.GetBytes("data")))
+                {
+                    dataChunk = ProcessDataChunk(stream);
+                    break;
+                }
+                else
+                {
+                    throw new Exception("Unsupported WAV file: unknown chunk type " + Encoding.ASCII.GetString(chunkId));
+                }
+            }
+
+            return new WAVData()
+            {
+                Format = fmtChunk,
+                Data = dataChunk
+            };
+        }
+    }
+}

From 1bb66802ee4b42e8b92d7ae755f8f31240e189fe Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:25:56 +0100
Subject: [PATCH 02/20] Log errors too

---
 src/rasdaq/Audio/Audio.cs        |  1 +
 src/rasdaq/Audio/AudioManager.cs | 36 +++++++++++++++++++++++---------
 src/rasdaq/Audio/AudioSource.cs  |  6 ++++++
 3 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index 95b0179..6ef2feb 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -5,6 +5,7 @@ namespace rasdaq.Audio;
 public class Audio : IDisposable
 {
     public int Handle;
+
     public Audio()
     {
         Handle = AL.GenBuffer();
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index e2011cb..34c6251 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -1,5 +1,7 @@
 using OpenTK.Audio.OpenAL;
 
+using rasdaq.Logging;
+
 namespace rasdaq.Audio;
 
 public class AudioManager
@@ -9,7 +11,9 @@ private static void CheckALCError(ALDevice device)
         AlcError error = ALC.GetError(device);
         if (error != AlcError.NoError)
         {
-            throw new Exception("OpenAL error: " + error);
+            string err = $"OpenAL error: {error}";
+            Log.Error(err)
+            throw new Exception(err);
         }
     }
 
@@ -18,7 +22,9 @@ private static void CheckALError()
         ALError error = AL.GetError();
         if (error != ALError.NoError)
         {
-            throw new Exception("OpenAL error: " + error);
+            string err = $"OpenAL error: {error}";
+            Log.Error(err);
+            throw new Exception(err);
         }
     }
 
@@ -32,7 +38,9 @@ public AudioManager()
         ALDevice device = ALC.OpenDevice(null);
         if (device == ALDevice.Null)
         {
-            throw new Exception("Failed to open the default audio device.");
+            string err = "Failed to open the default audio device.";
+            Log.Error(err);
+            throw new Exception(err);
         }
 
         // Create a context for the device.
@@ -40,7 +48,9 @@ public AudioManager()
         if (context == ALContext.Null)
         {
             ALC.CloseDevice(device);
-            throw new Exception("Failed to create an OpenAL context.");
+            string err = "Failed to create an OpenAL context.";
+            Log.Error(err);
+            throw new Exception(err);
         }
 
         // Check if we have any errors.
@@ -78,7 +88,9 @@ public Audio LoadAudio(string path)
             }
             else
             {
-                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
             }
         }
         else if (wavData.Format.NumChannels == 2)
@@ -93,12 +105,16 @@ public Audio LoadAudio(string path)
             }
             else
             {
-                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
             }
         }
         else
         {
-            throw new Exception("Unsupported number of channels: " + wavData.Format.NumChannels);
+            string err = $"Unsupported number of channels: {wavData.Format.NumChannels}";
+            Log.Error(err);
+            throw new Exception(err);
         }
 
         // Load the audio data into the OpenAL buffer.
@@ -113,11 +129,11 @@ public Audio LoadAudio(string path)
     /// <summary>
     /// Add a loaded audio file to an audio source, so that it can be played.
     /// </summary>
-    /// <param name="audioHandle">Integer handle of loaded audio file</param>
-    /// <param name="sourceHandle">Integer handle of audio source</param>
+    /// <param name="audio">Audio file</param>
+    /// <param name="audioSource">Audio source</param>
     public void AttachAudioToSource(Audio audio, AudioSource audioSource)
     {
-        AL.Source(audio.Handle, ALSourcei.Buffer, audioSource.Handle);
+        AL.Source(audioSource.Handle, ALSourcei.Buffer, audio.Handle);
         CheckALError();
     }
 
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index 2064905..09cf8ba 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -1,10 +1,13 @@
 using OpenTK.Audio.OpenAL;
 
+using rasdaq.Logging;
+
 namespace rasdaq.Audio;
 
 public class AudioSource : IDisposable
 {
     public int Handle;
+
     public AudioSource()
     {
         Handle = AL.GenSource();
@@ -12,6 +15,9 @@ public AudioSource()
         ALError error = AL.GetError();
         if (error != ALError.NoError)
         {
+            string err = $"OpenAL error while trying to create audio source: {error}";
+
+            Log.Error(err);
             throw new Exception("OpenAL error while trying to create audio source: " + error);
         }
     }

From 083702b4135b22192f9fc83707cead89bfacc497 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:31:37 +0100
Subject: [PATCH 03/20] Ran formatter

---
 src/rasdaq/Audio/Audio.cs       | 2 +-
 src/rasdaq/Audio/AudioSource.cs | 2 +-
 src/rasdaq/Audio/WAVLoader.cs   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index 6ef2feb..890dd4f 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -21,4 +21,4 @@ public void Dispose()
     {
         AL.DeleteBuffer(Handle);
     }
-}
+}
\ No newline at end of file
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index 09cf8ba..b94f547 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -26,4 +26,4 @@ public void Dispose()
     {
         AL.DeleteSource(Handle);
     }
-}
+}
\ No newline at end of file
diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
index d2e5f8a..508643e 100644
--- a/src/rasdaq/Audio/WAVLoader.cs
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -164,4 +164,4 @@ public static WAVData LoadWav(string path)
             };
         }
     }
-}
+}
\ No newline at end of file

From b705c2bb5773aafb030580d34056c57d5efd31bf Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:34:09 +0100
Subject: [PATCH 04/20] Log error

---
 src/rasdaq/Audio/Audio.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index 890dd4f..d912484 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -1,5 +1,7 @@
 using OpenTK.Audio.OpenAL;
 
+using rasdaq.Logging;
+
 namespace rasdaq.Audio;
 
 public class Audio : IDisposable
@@ -13,7 +15,10 @@ public Audio()
         ALError error = AL.GetError();
         if (error != ALError.NoError)
         {
-            throw new Exception("OpenAL error while trying to create audio buffer: " + error);
+            string err = $"OpenAL error while trying to create audio buffer: {error}";
+
+            Log.Error(err);
+            throw new Exception(err);
         }
     }
 

From 12cbba652a33eaabcf7aca573a1895c35dc5e182 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:35:09 +0100
Subject: [PATCH 05/20] Fix syntax error

---
 src/rasdaq/Audio/AudioManager.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index 34c6251..aff771d 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -12,7 +12,7 @@ private static void CheckALCError(ALDevice device)
         if (error != AlcError.NoError)
         {
             string err = $"OpenAL error: {error}";
-            Log.Error(err)
+            Log.Error(err);
             throw new Exception(err);
         }
     }

From ed72e69718b459e8ab8af852aa15e4347189cec5 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Sat, 9 May 2026 00:42:54 +0100
Subject: [PATCH 06/20] Audio setup with WAV file loading

OpenAL code to load PCM data and play it back, along with basic WAV file loader
---
 src/rasdaq/Application.cs        |   9 +-
 src/rasdaq/Audio/Audio.cs        |  23 +++++
 src/rasdaq/Audio/AudioManager.cs | 143 ++++++++++++++++++++++++++
 src/rasdaq/Audio/AudioSource.cs  |  23 +++++
 src/rasdaq/Audio/WAVLoader.cs    | 167 +++++++++++++++++++++++++++++++
 5 files changed, 364 insertions(+), 1 deletion(-)
 create mode 100644 src/rasdaq/Audio/Audio.cs
 create mode 100644 src/rasdaq/Audio/AudioManager.cs
 create mode 100644 src/rasdaq/Audio/AudioSource.cs
 create mode 100644 src/rasdaq/Audio/WAVLoader.cs

diff --git a/src/rasdaq/Application.cs b/src/rasdaq/Application.cs
index fb04ec6..8137cb2 100644
--- a/src/rasdaq/Application.cs
+++ b/src/rasdaq/Application.cs
@@ -1,6 +1,8 @@
 using OpenTK.Graphics.OpenGL4;
 using OpenTK.Windowing.Common;
 using OpenTK.Windowing.Desktop;
+
+using rasdaq.Audio;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Inputs;
@@ -58,6 +60,11 @@ internal void RemoveWorld(World world)
         _worlds.Remove(world);
     }
 
+    public AudioManager AudioManager { get; private set; }
+
+    private List<World> _worlds = new();
+    private GameWindow _gameWindow;
+
     /// <summary>
     /// Starts the application window.
     /// </summary>
@@ -85,7 +92,7 @@ public void Run(int width, int height, string title)
         GameWindow.RenderFrame += OnRenderFrame;
         GameWindow.FramebufferResize += OnFramebufferResize;
 
-        InputManager = new InputManager(new GameWindowWrapper(GameWindow));
+        InputManager = new InputManager(new GameWindowWrapper(_gameWindow));
 
         InputManager.SetEventListeners();
         GameWindow.Run();
diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
new file mode 100644
index 0000000..95b0179
--- /dev/null
+++ b/src/rasdaq/Audio/Audio.cs
@@ -0,0 +1,23 @@
+using OpenTK.Audio.OpenAL;
+
+namespace rasdaq.Audio;
+
+public class Audio : IDisposable
+{
+    public int Handle;
+    public Audio()
+    {
+        Handle = AL.GenBuffer();
+        // Check for errors
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            throw new Exception("OpenAL error while trying to create audio buffer: " + error);
+        }
+    }
+
+    public void Dispose()
+    {
+        AL.DeleteBuffer(Handle);
+    }
+}
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
new file mode 100644
index 0000000..e2011cb
--- /dev/null
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -0,0 +1,143 @@
+using OpenTK.Audio.OpenAL;
+
+namespace rasdaq.Audio;
+
+public class AudioManager
+{
+    private static void CheckALCError(ALDevice device)
+    {
+        AlcError error = ALC.GetError(device);
+        if (error != AlcError.NoError)
+        {
+            throw new Exception("OpenAL error: " + error);
+        }
+    }
+
+    private static void CheckALError()
+    {
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            throw new Exception("OpenAL error: " + error);
+        }
+    }
+
+    /// <summary>
+    /// Initialize Audio for the Application, using the default audio device.
+    /// </summary>
+    /// <exception cref="Exception"></exception>
+    public AudioManager()
+    {
+        // Open the default audio device.
+        ALDevice device = ALC.OpenDevice(null);
+        if (device == ALDevice.Null)
+        {
+            throw new Exception("Failed to open the default audio device.");
+        }
+
+        // Create a context for the device.
+        ALContext context = ALC.CreateContext(device, new ALContextAttributes(null, null, null, null, null));
+        if (context == ALContext.Null)
+        {
+            ALC.CloseDevice(device);
+            throw new Exception("Failed to create an OpenAL context.");
+        }
+
+        // Check if we have any errors.
+        AlcError error = ALC.GetError(device);
+        CheckALCError(device);
+        // If no errors, make the context current.
+        ALC.MakeContextCurrent(context);
+    }
+
+    /// <summary>
+    /// Load a WAV file that contains PCM data only.
+    /// </summary>
+    /// <param name="path">Path to WAV file</param>
+    /// <returns>A integer handle referring to the loaded audio</returns>
+    /// <exception cref="Exception"></exception>
+    public Audio LoadAudio(string path)
+    {
+        // Create an OpenAL buffer for the data to go in.
+        Audio audio = new Audio();
+
+        // Load the WAV file
+        WAVLoader.WAVData wavData = WAVLoader.LoadWav(path);
+
+        // Discern the format of the audio data based on number of channels and bits per sample.
+        ALFormat format;
+        if (wavData.Format.NumChannels == 1)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Mono8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Mono16;
+            }
+            else
+            {
+                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+            }
+        }
+        else if (wavData.Format.NumChannels == 2)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Stereo8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Stereo16;
+            }
+            else
+            {
+                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+            }
+        }
+        else
+        {
+            throw new Exception("Unsupported number of channels: " + wavData.Format.NumChannels);
+        }
+
+        // Load the audio data into the OpenAL buffer.
+        AL.BufferData(audio.Handle, format, wavData.Data.Data, (int)wavData.Format.SampleRate);
+
+        // Check if we have any errors from trying to load the audio data.
+        CheckALError();
+
+        return audio;
+    }
+
+    /// <summary>
+    /// Add a loaded audio file to an audio source, so that it can be played.
+    /// </summary>
+    /// <param name="audioHandle">Integer handle of loaded audio file</param>
+    /// <param name="sourceHandle">Integer handle of audio source</param>
+    public void AttachAudioToSource(Audio audio, AudioSource audioSource)
+    {
+        AL.Source(audio.Handle, ALSourcei.Buffer, audioSource.Handle);
+        CheckALError();
+    }
+
+    /// <summary>
+    /// Play back an audio source that has audio attached to it.
+    /// </summary>
+    /// <param name="source"></param>
+    public void PlaySource(AudioSource audioSource)
+    {
+        AL.SourcePlay(audioSource.Handle);
+        CheckALError();
+    }
+
+    /// <summary>
+    /// Stop playback of an audio source.
+    /// </summary>
+    /// <param name="source"></param>
+    public void StopSource(AudioSource audioSource)
+    {
+        AL.SourceStop(audioSource.Handle);
+        CheckALError();
+    }
+}
\ No newline at end of file
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
new file mode 100644
index 0000000..2064905
--- /dev/null
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -0,0 +1,23 @@
+using OpenTK.Audio.OpenAL;
+
+namespace rasdaq.Audio;
+
+public class AudioSource : IDisposable
+{
+    public int Handle;
+    public AudioSource()
+    {
+        Handle = AL.GenSource();
+        // Check for errors
+        ALError error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            throw new Exception("OpenAL error while trying to create audio source: " + error);
+        }
+    }
+
+    public void Dispose()
+    {
+        AL.DeleteSource(Handle);
+    }
+}
diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
new file mode 100644
index 0000000..d2e5f8a
--- /dev/null
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -0,0 +1,167 @@
+using System.Buffers.Binary;
+using System.Text;
+
+namespace rasdaq.Audio;
+
+internal class WAVLoader
+{
+    /// <summary>
+    /// Format information about the WAV file.
+    /// </summary>
+    public struct FmtChunk
+    {
+        public ushort AudioFormat;
+        public ushort NumChannels;
+        public uint SampleRate;
+        public uint ByteRate;
+        public ushort BlockAlign;
+        public ushort BitsPerSample;
+        public FmtChunkExtension? Extension;
+    };
+    /// <summary>
+    /// Extra format information for certain WAV files.
+    /// </summary>
+    public struct FmtChunkExtension
+    {
+        public ushort ValidBitsPerSample;
+        public uint SpeakerPositionMask;
+        public Guid SubFormat;
+    }
+
+    /// <summary>
+    /// Holds the data of the WAV file, should be PCM data, as that is all is supported currently.
+    /// </summary>
+    public struct DataChunk
+    {
+        public uint Size;
+        public byte[] Data;
+    }
+
+    /// <summary>
+    /// Holds all the information necessary about a WAV file, namely,
+    /// the format information and the data itself.
+    /// </summary>
+    public struct WAVData
+    {
+        public FmtChunk Format;
+        public DataChunk Data;
+    }
+
+    private static byte[] ReadBytesFromStream(FileStream stream, int count)
+    {
+        byte[] buffer = new byte[count];
+        stream.ReadExactly(buffer, 0, count);
+        return buffer;
+    }
+
+    private static FmtChunk ProcessFmtChunck(FileStream stream)
+    {
+        uint size = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+
+        FmtChunk chunk = new FmtChunk();
+        chunk.AudioFormat = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.NumChannels = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.SampleRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.ByteRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.BlockAlign = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.BitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+
+        if (size > 16)
+        {
+            ushort extensionSize = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+            if (extensionSize == 22)
+            {
+                chunk.Extension = new FmtChunkExtension()
+                {
+                    ValidBitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2)),
+                    SpeakerPositionMask = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4)),
+                    SubFormat = new Guid(ReadBytesFromStream(stream, 16))
+                };
+            }
+        }
+
+        return chunk;
+    }
+
+    private static DataChunk ProcessDataChunk(FileStream stream)
+    {
+        DataChunk chunk = new DataChunk();
+        chunk.Size = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
+        chunk.Data = ReadBytesFromStream(stream, (int)chunk.Size);
+        return chunk;
+    }
+
+    /// <summary>
+    /// Load the WAV file at the given path and return a WAVData struct containing the format information and the data itself.
+    /// </summary>
+    /// <param name="path">The path to the WAV file.</param>
+    /// <returns>A WAVData struct containing the format information and the data.</returns>
+    /// <exception cref="Exception">Thrown if the WAV file is not found or is invalid.</exception>
+    public static WAVData LoadWav(string path)
+    {
+        if (!File.Exists(path))
+        {
+            throw new Exception("WAV file not found: " + path);
+        }
+
+        using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
+        {
+            // Read the RIFF header at the start of the WAV file.
+            byte[] fourcc = new byte[4];
+            stream.ReadExactly(fourcc, 0, 4);
+            if (Encoding.ASCII.GetString(fourcc) != "RIFF")
+            {
+                throw new Exception("Invalid WAV file: missing RIFF header.");
+            }
+
+            // Read the file size
+            byte[] byteFileSize = new byte[4];
+            stream.ReadExactly(byteFileSize, 0, 4);
+            int fileSize = BinaryPrimitives.ReadInt32LittleEndian(byteFileSize) - 4;
+
+            // Check file type is WAVE
+            byte[] byteFileType = new byte[4];
+            stream.ReadExactly(byteFileType, 0, 4);
+            Encoding.UTF8.GetString(byteFileType);
+            if (Encoding.ASCII.GetString(byteFileType) != "WAVE")
+            {
+                throw new Exception("Invalid WAV file: file type not listed as WAVE in RIFF header.");
+            }
+
+            FmtChunk fmtChunk = new FmtChunk();
+            DataChunk dataChunk = new DataChunk();
+
+            // Now read the remaining chunks, we want a fmt chunk and a data chunk.
+            while (stream.Position < stream.Length - 4)
+            {
+                byte[] chunkId = new byte[4];
+                stream.ReadExactly(chunkId, 0, 4);
+
+                if (chunkId.SequenceEqual(Encoding.ASCII.GetBytes("fmt ")))
+                {
+                    fmtChunk = ProcessFmtChunck(stream);
+
+                    if (fmtChunk.AudioFormat != 1)
+                    {
+                        throw new Exception("Unsupported WAV file: only PCM format is supported.");
+                    }
+                }
+                else if (chunkId.SequenceEqual(Encoding.ASCII.GetBytes("data")))
+                {
+                    dataChunk = ProcessDataChunk(stream);
+                    break;
+                }
+                else
+                {
+                    throw new Exception("Unsupported WAV file: unknown chunk type " + Encoding.ASCII.GetString(chunkId));
+                }
+            }
+
+            return new WAVData()
+            {
+                Format = fmtChunk,
+                Data = dataChunk
+            };
+        }
+    }
+}

From 749cd27915be6bdb6fe65cdcb77a2f894264fde7 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:25:56 +0100
Subject: [PATCH 07/20] Log errors too

---
 src/rasdaq/Audio/Audio.cs        |  1 +
 src/rasdaq/Audio/AudioManager.cs | 36 +++++++++++++++++++++++---------
 src/rasdaq/Audio/AudioSource.cs  |  6 ++++++
 3 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index 95b0179..6ef2feb 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -5,6 +5,7 @@ namespace rasdaq.Audio;
 public class Audio : IDisposable
 {
     public int Handle;
+
     public Audio()
     {
         Handle = AL.GenBuffer();
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index e2011cb..34c6251 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -1,5 +1,7 @@
 using OpenTK.Audio.OpenAL;
 
+using rasdaq.Logging;
+
 namespace rasdaq.Audio;
 
 public class AudioManager
@@ -9,7 +11,9 @@ private static void CheckALCError(ALDevice device)
         AlcError error = ALC.GetError(device);
         if (error != AlcError.NoError)
         {
-            throw new Exception("OpenAL error: " + error);
+            string err = $"OpenAL error: {error}";
+            Log.Error(err)
+            throw new Exception(err);
         }
     }
 
@@ -18,7 +22,9 @@ private static void CheckALError()
         ALError error = AL.GetError();
         if (error != ALError.NoError)
         {
-            throw new Exception("OpenAL error: " + error);
+            string err = $"OpenAL error: {error}";
+            Log.Error(err);
+            throw new Exception(err);
         }
     }
 
@@ -32,7 +38,9 @@ public AudioManager()
         ALDevice device = ALC.OpenDevice(null);
         if (device == ALDevice.Null)
         {
-            throw new Exception("Failed to open the default audio device.");
+            string err = "Failed to open the default audio device.";
+            Log.Error(err);
+            throw new Exception(err);
         }
 
         // Create a context for the device.
@@ -40,7 +48,9 @@ public AudioManager()
         if (context == ALContext.Null)
         {
             ALC.CloseDevice(device);
-            throw new Exception("Failed to create an OpenAL context.");
+            string err = "Failed to create an OpenAL context.";
+            Log.Error(err);
+            throw new Exception(err);
         }
 
         // Check if we have any errors.
@@ -78,7 +88,9 @@ public Audio LoadAudio(string path)
             }
             else
             {
-                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
             }
         }
         else if (wavData.Format.NumChannels == 2)
@@ -93,12 +105,16 @@ public Audio LoadAudio(string path)
             }
             else
             {
-                throw new Exception("Unsupported bits per sample: " + wavData.Format.BitsPerSample);
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
             }
         }
         else
         {
-            throw new Exception("Unsupported number of channels: " + wavData.Format.NumChannels);
+            string err = $"Unsupported number of channels: {wavData.Format.NumChannels}";
+            Log.Error(err);
+            throw new Exception(err);
         }
 
         // Load the audio data into the OpenAL buffer.
@@ -113,11 +129,11 @@ public Audio LoadAudio(string path)
     /// <summary>
     /// Add a loaded audio file to an audio source, so that it can be played.
     /// </summary>
-    /// <param name="audioHandle">Integer handle of loaded audio file</param>
-    /// <param name="sourceHandle">Integer handle of audio source</param>
+    /// <param name="audio">Audio file</param>
+    /// <param name="audioSource">Audio source</param>
     public void AttachAudioToSource(Audio audio, AudioSource audioSource)
     {
-        AL.Source(audio.Handle, ALSourcei.Buffer, audioSource.Handle);
+        AL.Source(audioSource.Handle, ALSourcei.Buffer, audio.Handle);
         CheckALError();
     }
 
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index 2064905..09cf8ba 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -1,10 +1,13 @@
 using OpenTK.Audio.OpenAL;
 
+using rasdaq.Logging;
+
 namespace rasdaq.Audio;
 
 public class AudioSource : IDisposable
 {
     public int Handle;
+
     public AudioSource()
     {
         Handle = AL.GenSource();
@@ -12,6 +15,9 @@ public AudioSource()
         ALError error = AL.GetError();
         if (error != ALError.NoError)
         {
+            string err = $"OpenAL error while trying to create audio source: {error}";
+
+            Log.Error(err);
             throw new Exception("OpenAL error while trying to create audio source: " + error);
         }
     }

From 2acd571eed21198f0b0c513db770c64aec01cbfc Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:31:37 +0100
Subject: [PATCH 08/20] Ran formatter

---
 src/rasdaq/Audio/Audio.cs       | 2 +-
 src/rasdaq/Audio/AudioSource.cs | 2 +-
 src/rasdaq/Audio/WAVLoader.cs   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index 6ef2feb..890dd4f 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -21,4 +21,4 @@ public void Dispose()
     {
         AL.DeleteBuffer(Handle);
     }
-}
+}
\ No newline at end of file
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index 09cf8ba..b94f547 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -26,4 +26,4 @@ public void Dispose()
     {
         AL.DeleteSource(Handle);
     }
-}
+}
\ No newline at end of file
diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
index d2e5f8a..508643e 100644
--- a/src/rasdaq/Audio/WAVLoader.cs
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -164,4 +164,4 @@ public static WAVData LoadWav(string path)
             };
         }
     }
-}
+}
\ No newline at end of file

From 8da3490812624ce8a0744681ceb4e0607bde0b0d Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:34:09 +0100
Subject: [PATCH 09/20] Log error

---
 src/rasdaq/Audio/Audio.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index 890dd4f..d912484 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -1,5 +1,7 @@
 using OpenTK.Audio.OpenAL;
 
+using rasdaq.Logging;
+
 namespace rasdaq.Audio;
 
 public class Audio : IDisposable
@@ -13,7 +15,10 @@ public Audio()
         ALError error = AL.GetError();
         if (error != ALError.NoError)
         {
-            throw new Exception("OpenAL error while trying to create audio buffer: " + error);
+            string err = $"OpenAL error while trying to create audio buffer: {error}";
+
+            Log.Error(err);
+            throw new Exception(err);
         }
     }
 

From 5fa95a2c7e7ef112abd7b17a10efb0c5fff43f44 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Wed, 13 May 2026 23:35:09 +0100
Subject: [PATCH 10/20] Fix syntax error

---
 src/rasdaq/Audio/AudioManager.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index 34c6251..aff771d 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -12,7 +12,7 @@ private static void CheckALCError(ALDevice device)
         if (error != AlcError.NoError)
         {
             string err = $"OpenAL error: {error}";
-            Log.Error(err)
+            Log.Error(err);
             throw new Exception(err);
         }
     }

From ad5e86f474b0308b750f21b3264a90491a12e846 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Fri, 15 May 2026 22:01:12 +0100
Subject: [PATCH 11/20] Convert AudioSource into a Component

---
 src/rasdaq/Audio/AudioManager.cs |  6 +++---
 src/rasdaq/Audio/AudioSource.cs  | 36 +++++++++++++++++++++++++++-----
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index aff771d..3a10331 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -6,7 +6,7 @@ namespace rasdaq.Audio;
 
 public class AudioManager
 {
-    private static void CheckALCError(ALDevice device)
+    internal static void CheckALCError(ALDevice device)
     {
         AlcError error = ALC.GetError(device);
         if (error != AlcError.NoError)
@@ -17,7 +17,7 @@ private static void CheckALCError(ALDevice device)
         }
     }
 
-    private static void CheckALError()
+    internal static void CheckALError()
     {
         ALError error = AL.GetError();
         if (error != ALError.NoError)
@@ -156,4 +156,4 @@ public void StopSource(AudioSource audioSource)
         AL.SourceStop(audioSource.Handle);
         CheckALError();
     }
-}
\ No newline at end of file
+}
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index b94f547..583b783 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -1,14 +1,15 @@
 using OpenTK.Audio.OpenAL;
 
+using rasdaq.Core.ECS;
 using rasdaq.Logging;
 
 namespace rasdaq.Audio;
 
-public class AudioSource : IDisposable
+public class AudioSource : Component, IDisposable
 {
-    public int Handle;
+    internal int? Handle = null;
 
-    public AudioSource()
+    internal override void Init()
     {
         Handle = AL.GenSource();
         // Check for errors
@@ -22,8 +23,33 @@ public AudioSource()
         }
     }
 
+    public void Play()
+    {
+        if (!Handle.HasValue)
+        {
+            Log.Error("Audio source handle is null. Cannot play audio.");
+            return;
+        }
+        AL.SourcePlay(Handle.Value);
+        AudioManager.CheckALError();
+    }
+
+    public void Stop()
+    {
+        if (!Handle.HasValue)
+        {
+            Log.Error("Audio source handle is null. Cannot play audio.");
+            return;
+        }
+        AL.SourceStop(Handle.Value);
+        AudioManager.CheckALError();
+    }
+
     public void Dispose()
     {
-        AL.DeleteSource(Handle);
+        if (Handle.HasValue)
+        {
+            AL.DeleteSource(Handle.Value);
+        }
     }
-}
\ No newline at end of file
+}

From a2ec1cea6a301c147051a839338bfec12a95ded2 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Thu, 28 May 2026 23:11:26 +0100
Subject: [PATCH 12/20] Refactor audio around ECS + ResourceManager

---
 samples/pong/Soldier.cs                 | 37 ++++++++-
 src/rasdaq/Application.cs               |  3 +-
 src/rasdaq/Audio/AudioManager.cs        | 99 +------------------------
 src/rasdaq/Audio/AudioSource.cs         | 24 ++++++
 src/rasdaq/Audio/WAVLoader.cs           | 76 ++++++++++++++++++-
 src/rasdaq/Resources/ResourceManager.cs |  4 +-
 6 files changed, 138 insertions(+), 105 deletions(-)

diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index 6a7850d..97dec95 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -1,10 +1,16 @@
-using rasdaq;
+using rasdaq;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Inputs;
 using rasdaq.Logging;
 using rasdaq.Resources;
 using rasdaq.Transformations;
+using OpenTK.Audio.OpenAL;
+using rasdaq.Audio;
+using rasdaq.Core.ECS;
+using rasdaq.Inputs;
+using rasdaq.Logging;
+using rasdaq.Resources;
 
 namespace pong;
 
@@ -13,16 +19,37 @@ internal class Soldier : Component
     public override void Start()
     {
         base.Start();
+
+        Entity?.AddComponent(new AudioSource());
+
+        Audio audio1 = ResourceManager.Load<Audio>("assets/test.wav");
+        Entity?.GetComponent<AudioSource>()?.AttachAudio(audio1);
+
+        Log.Info($"Audio initialized on {Thread.CurrentThread.Name}");
+
+        Input.OnKeyDownEvent.Add(Keys.W, () =>
+        {
+            Log.Info("User pressed W based on an event");
+        });
+
+        Input.OnKeyUpEvent.Add(Keys.B, () =>
+        {
+            Log.Info("Hello");
+        });
     }
 
     public override void Update(double deltaTime)
     {
         base.Update(deltaTime);
+
+        Log.Info($"Audio initialized on {Thread.CurrentThread.Name}");
     }
 
     public override void FrameUpdate(double deltaTime)
     {
         base.Update(deltaTime);
+        Log.Info($"Audio initialized on {Thread.CurrentThread.Name}");
+
 
         if (Input.IsKeyPressed(Keys.V))
         {
@@ -70,6 +97,12 @@ public override void FrameUpdate(double deltaTime)
             var x = Entity?.Transform.position.X - (Application.WindowSize?.X / 2) ?? 0;
             var y = Entity?.Transform.position.Y - (Application.WindowSize?.Y / 2) ?? 0;
             Renderer.Instance.Camera.SetPosition(x, y);
+            if (Input.IsKeyDown(Keys.W))
+            {
+                ALContext context = ALC.GetCurrentContext();
+                Log.Info($"CurrentContext = {context == ALContext.Null}");
+                Log.Info($"W is held down, playing AudioSource! {Entity?.GetComponent<AudioSource>() == null}");
+                Entity?.GetComponent<AudioSource>()?.Play();
+            }
         }
     }
-}
diff --git a/src/rasdaq/Application.cs b/src/rasdaq/Application.cs
index 8137cb2..0c8adcc 100644
--- a/src/rasdaq/Application.cs
+++ b/src/rasdaq/Application.cs
@@ -60,7 +60,7 @@ internal void RemoveWorld(World world)
         _worlds.Remove(world);
     }
 
-    public AudioManager AudioManager { get; private set; }
+    internal AudioManager AudioManager { get; private set; }
 
     private List<World> _worlds = new();
     private GameWindow _gameWindow;
@@ -117,6 +117,7 @@ private void OnLoad()
         GL.Enable(EnableCap.DepthTest);
 
         Renderer.Instance.Init();
+        AudioManager.Initialize();
 
         Init();
 
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index 3a10331..e869c2a 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -32,7 +32,7 @@ internal static void CheckALError()
     /// Initialize Audio for the Application, using the default audio device.
     /// </summary>
     /// <exception cref="Exception"></exception>
-    public AudioManager()
+    internal static void Initialize()
     {
         // Open the default audio device.
         ALDevice device = ALC.OpenDevice(null);
@@ -59,101 +59,4 @@ public AudioManager()
         // If no errors, make the context current.
         ALC.MakeContextCurrent(context);
     }
-
-    /// <summary>
-    /// Load a WAV file that contains PCM data only.
-    /// </summary>
-    /// <param name="path">Path to WAV file</param>
-    /// <returns>A integer handle referring to the loaded audio</returns>
-    /// <exception cref="Exception"></exception>
-    public Audio LoadAudio(string path)
-    {
-        // Create an OpenAL buffer for the data to go in.
-        Audio audio = new Audio();
-
-        // Load the WAV file
-        WAVLoader.WAVData wavData = WAVLoader.LoadWav(path);
-
-        // Discern the format of the audio data based on number of channels and bits per sample.
-        ALFormat format;
-        if (wavData.Format.NumChannels == 1)
-        {
-            if (wavData.Format.BitsPerSample == 8)
-            {
-                format = ALFormat.Mono8;
-            }
-            else if (wavData.Format.BitsPerSample == 16)
-            {
-                format = ALFormat.Mono16;
-            }
-            else
-            {
-                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
-                Log.Error(err);
-                throw new Exception(err);
-            }
-        }
-        else if (wavData.Format.NumChannels == 2)
-        {
-            if (wavData.Format.BitsPerSample == 8)
-            {
-                format = ALFormat.Stereo8;
-            }
-            else if (wavData.Format.BitsPerSample == 16)
-            {
-                format = ALFormat.Stereo16;
-            }
-            else
-            {
-                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
-                Log.Error(err);
-                throw new Exception(err);
-            }
-        }
-        else
-        {
-            string err = $"Unsupported number of channels: {wavData.Format.NumChannels}";
-            Log.Error(err);
-            throw new Exception(err);
-        }
-
-        // Load the audio data into the OpenAL buffer.
-        AL.BufferData(audio.Handle, format, wavData.Data.Data, (int)wavData.Format.SampleRate);
-
-        // Check if we have any errors from trying to load the audio data.
-        CheckALError();
-
-        return audio;
-    }
-
-    /// <summary>
-    /// Add a loaded audio file to an audio source, so that it can be played.
-    /// </summary>
-    /// <param name="audio">Audio file</param>
-    /// <param name="audioSource">Audio source</param>
-    public void AttachAudioToSource(Audio audio, AudioSource audioSource)
-    {
-        AL.Source(audioSource.Handle, ALSourcei.Buffer, audio.Handle);
-        CheckALError();
-    }
-
-    /// <summary>
-    /// Play back an audio source that has audio attached to it.
-    /// </summary>
-    /// <param name="source"></param>
-    public void PlaySource(AudioSource audioSource)
-    {
-        AL.SourcePlay(audioSource.Handle);
-        CheckALError();
-    }
-
-    /// <summary>
-    /// Stop playback of an audio source.
-    /// </summary>
-    /// <param name="source"></param>
-    public void StopSource(AudioSource audioSource)
-    {
-        AL.SourceStop(audioSource.Handle);
-        CheckALError();
-    }
 }
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index 583b783..5b53b3b 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -9,6 +9,11 @@ public class AudioSource : Component, IDisposable
 {
     internal int? Handle = null;
 
+    public AudioSource()
+    {
+        Init();
+    }
+
     internal override void Init()
     {
         Handle = AL.GenSource();
@@ -23,6 +28,24 @@ internal override void Init()
         }
     }
 
+    /// <summary>
+    /// Add a loaded audio file to an audio source, so that it can be played.
+    /// </summary>
+    /// <param name="audio">Audio file</param>
+    /// <param name="audioSource">Audio source</param>
+    public void AttachAudio(Audio audio)
+    {
+        if (Handle != null)
+        {
+            AL.Source(Handle.Value, ALSourcei.Buffer, audio.Handle);
+            AudioManager.CheckALError();
+        }
+        else
+        {
+            Log.Error("Audio source has not been initialized yet. Cannot attach audio.");
+        }
+    }
+
     public void Play()
     {
         if (!Handle.HasValue)
@@ -30,6 +53,7 @@ public void Play()
             Log.Error("Audio source handle is null. Cannot play audio.");
             return;
         }
+        Log.Info("PLAYING AUDIO!!!");
         AL.SourcePlay(Handle.Value);
         AudioManager.CheckALError();
     }
diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
index 508643e..4479090 100644
--- a/src/rasdaq/Audio/WAVLoader.cs
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -1,9 +1,12 @@
-using System.Buffers.Binary;
+using OpenTK.Audio.OpenAL;
+using rasdaq.Logging;
+using rasdaq.Resources;
+using System.Buffers.Binary;
 using System.Text;
 
 namespace rasdaq.Audio;
 
-internal class WAVLoader
+internal class WAVLoader : IResourceLoader
 {
     /// <summary>
     /// Format information about the WAV file.
@@ -18,6 +21,7 @@ public struct FmtChunk
         public ushort BitsPerSample;
         public FmtChunkExtension? Extension;
     };
+
     /// <summary>
     /// Extra format information for certain WAV files.
     /// </summary>
@@ -164,4 +168,70 @@ public static WAVData LoadWav(string path)
             };
         }
     }
-}
\ No newline at end of file
+
+    /// <summary>
+    /// Load a WAV file that contains PCM data only.
+    /// </summary>
+    /// <param name="path">Path to WAV file</param>
+    /// <returns>A integer handle referring to the loaded audio</returns>
+    /// <exception cref="Exception"></exception>
+    public object Load(string path)
+    {
+        // Create an OpenAL buffer for the data to go in.
+        Audio audio = new Audio();
+
+        // Load the WAV file
+        WAVLoader.WAVData wavData = WAVLoader.LoadWav(path);
+
+        // Discern the format of the audio data based on number of channels and bits per sample.
+        ALFormat format;
+        if (wavData.Format.NumChannels == 1)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Mono8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Mono16;
+            }
+            else
+            {
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
+            }
+        }
+        else if (wavData.Format.NumChannels == 2)
+        {
+            if (wavData.Format.BitsPerSample == 8)
+            {
+                format = ALFormat.Stereo8;
+            }
+            else if (wavData.Format.BitsPerSample == 16)
+            {
+                format = ALFormat.Stereo16;
+            }
+            else
+            {
+                string err = $"Unsupported bits per sample: {wavData.Format.BitsPerSample}";
+                Log.Error(err);
+                throw new Exception(err);
+            }
+        }
+        else
+        {
+            string err = $"Unsupported number of channels: {wavData.Format.NumChannels}";
+            Log.Error(err);
+            throw new Exception(err);
+        }
+
+        // Load the audio data into the OpenAL buffer.
+        AL.BufferData(audio.Handle, format, wavData.Data.Data, (int)wavData.Format.SampleRate);
+
+        // Check if we have any errors from trying to load the audio data.
+        AudioManager.CheckALError();
+
+        return audio;
+    }
+}
diff --git a/src/rasdaq/Resources/ResourceManager.cs b/src/rasdaq/Resources/ResourceManager.cs
index 852088f..85e1773 100644
--- a/src/rasdaq/Resources/ResourceManager.cs
+++ b/src/rasdaq/Resources/ResourceManager.cs
@@ -1,4 +1,5 @@
-using rasdaq.Logging;
+using rasdaq.Audio;
+using rasdaq.Logging;
 using rasdaq.Resources.Loaders;
 
 namespace rasdaq.Resources;
@@ -17,6 +18,7 @@ static ResourceManager()
         _loaders["txt"] = new TextLoader();
         _loaders["png"] = new TextureLoader();
         _loaders["jpg"] = new TextureLoader();
+        _loaders["wav"] = new WAVLoader();
     }
 
     /// <summary>

From 477c4c61bc04c4cc07766b36a111fdab14b0dcab Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Thu, 28 May 2026 23:24:11 +0100
Subject: [PATCH 13/20] Don't make an instance of AudioManager

---
 samples/pong/Soldier.cs   |  7 ++-----
 src/rasdaq/Application.cs | 15 +++++----------
 2 files changed, 7 insertions(+), 15 deletions(-)

diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index 97dec95..5c4c28f 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -7,10 +7,6 @@
 using rasdaq.Transformations;
 using OpenTK.Audio.OpenAL;
 using rasdaq.Audio;
-using rasdaq.Core.ECS;
-using rasdaq.Inputs;
-using rasdaq.Logging;
-using rasdaq.Resources;
 
 namespace pong;
 
@@ -22,7 +18,7 @@ public override void Start()
 
         Entity?.AddComponent(new AudioSource());
 
-        Audio audio1 = ResourceManager.Load<Audio>("assets/test.wav");
+        Audio audio1 = ResourceManager.Load<Audio>("assets/audio.wav");
         Entity?.GetComponent<AudioSource>()?.AttachAudio(audio1);
 
         Log.Info($"Audio initialized on {Thread.CurrentThread.Name}");
@@ -106,3 +102,4 @@ public override void FrameUpdate(double deltaTime)
             }
         }
     }
+}
diff --git a/src/rasdaq/Application.cs b/src/rasdaq/Application.cs
index 0c8adcc..b149e72 100644
--- a/src/rasdaq/Application.cs
+++ b/src/rasdaq/Application.cs
@@ -22,17 +22,13 @@ public class Application : IDisposable
     /// <summary>
     /// The <c>Application</c> instance is created after <c>Run</c> is called.
     /// </summary>
+    private static Application? _instance;
     public static Application Instance
     {
         get => _instance ?? throw new InvalidOperationException("Application not started. Call Run() first.");
         private set => _instance = value;
     }
-    private static Application? _instance;
     public static Vector2? WindowSize => Instance._gameWindow?.Size;
-    /// <summary>
-    /// Return list of instantiated <c>Worlds</c>.
-    /// </summary>
-    public List<World> Worlds => _worlds.Objects;
 
     private InputManager? _inputManager;
     internal InputManager InputManager
@@ -42,6 +38,10 @@ internal InputManager InputManager
     }
 
     private FlushEnumerable<World> _worlds = new();
+    /// <summary>
+    /// Return list of instantiated <c>Worlds</c>.
+    /// </summary>
+    public List<World> Worlds => _worlds.Objects;
 
     private GameWindow? _gameWindow;
     internal GameWindow GameWindow
@@ -60,11 +60,6 @@ internal void RemoveWorld(World world)
         _worlds.Remove(world);
     }
 
-    internal AudioManager AudioManager { get; private set; }
-
-    private List<World> _worlds = new();
-    private GameWindow _gameWindow;
-
     /// <summary>
     /// Starts the application window.
     /// </summary>

From 973c54bbeb8023787221380b110d7fbd47ab2ad5 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Thu, 28 May 2026 23:52:23 +0100
Subject: [PATCH 14/20] Clean up a working Audio subsystem

---
 samples/pong/Soldier.cs         | 7 -------
 src/rasdaq/Application.cs       | 1 +
 src/rasdaq/Audio/AudioSource.cs | 1 -
 3 files changed, 1 insertion(+), 8 deletions(-)

diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index 5c4c28f..02dd7e1 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -21,8 +21,6 @@ public override void Start()
         Audio audio1 = ResourceManager.Load<Audio>("assets/audio.wav");
         Entity?.GetComponent<AudioSource>()?.AttachAudio(audio1);
 
-        Log.Info($"Audio initialized on {Thread.CurrentThread.Name}");
-
         Input.OnKeyDownEvent.Add(Keys.W, () =>
         {
             Log.Info("User pressed W based on an event");
@@ -38,13 +36,11 @@ public override void Update(double deltaTime)
     {
         base.Update(deltaTime);
 
-        Log.Info($"Audio initialized on {Thread.CurrentThread.Name}");
     }
 
     public override void FrameUpdate(double deltaTime)
     {
         base.Update(deltaTime);
-        Log.Info($"Audio initialized on {Thread.CurrentThread.Name}");
 
 
         if (Input.IsKeyPressed(Keys.V))
@@ -96,9 +92,6 @@ public override void FrameUpdate(double deltaTime)
             if (Input.IsKeyDown(Keys.W))
             {
                 ALContext context = ALC.GetCurrentContext();
-                Log.Info($"CurrentContext = {context == ALContext.Null}");
-                Log.Info($"W is held down, playing AudioSource! {Entity?.GetComponent<AudioSource>() == null}");
-                Entity?.GetComponent<AudioSource>()?.Play();
             }
         }
     }
diff --git a/src/rasdaq/Application.cs b/src/rasdaq/Application.cs
index b149e72..4721d1c 100644
--- a/src/rasdaq/Application.cs
+++ b/src/rasdaq/Application.cs
@@ -112,6 +112,7 @@ private void OnLoad()
         GL.Enable(EnableCap.DepthTest);
 
         Renderer.Instance.Init();
+
         AudioManager.Initialize();
 
         Init();
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index 5b53b3b..b2fd37c 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -53,7 +53,6 @@ public void Play()
             Log.Error("Audio source handle is null. Cannot play audio.");
             return;
         }
-        Log.Info("PLAYING AUDIO!!!");
         AL.SourcePlay(Handle.Value);
         AudioManager.CheckALError();
     }

From 3ef0220ac824ca75c2f3140ac0372ae7f64d9b55 Mon Sep 17 00:00:00 2001
From: Neel R <51024479+nrbyte@users.noreply.github.com>
Date: Sun, 7 Jun 2026 21:32:50 +0100
Subject: [PATCH 15/20] Fix formatting issues

---
 samples/pong/Soldier.cs   | 5 ++---
 src/rasdaq/Audio/Audio.cs | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index 02dd7e1..aa3aa83 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -1,12 +1,12 @@
+using OpenTK.Audio.OpenAL;
 using rasdaq;
+using rasdaq.Audio;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Inputs;
 using rasdaq.Logging;
 using rasdaq.Resources;
 using rasdaq.Transformations;
-using OpenTK.Audio.OpenAL;
-using rasdaq.Audio;
 
 namespace pong;
 
@@ -42,7 +42,6 @@ public override void FrameUpdate(double deltaTime)
     {
         base.Update(deltaTime);
 
-
         if (Input.IsKeyPressed(Keys.V))
         {
             Log.Info("V pressed");
diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index d912484..023026b 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -26,4 +26,4 @@ public void Dispose()
     {
         AL.DeleteBuffer(Handle);
     }
-}
\ No newline at end of file
+}

From 53b96e71fa637698e5d97c7ae2f917aade67fecb Mon Sep 17 00:00:00 2001
From: AndreiPC <andreipatea@gmail.com>
Date: Tue, 15 Sep 2026 20:21:08 +0100
Subject: [PATCH 16/20] update

---
 samples/pong/Soldier.cs          |  10 ++++--
 samples/pong/assets/laser.wav    | Bin 0 -> 130316 bytes
 src/rasdaq/Application.cs        |   2 --
 src/rasdaq/Audio/AudioManager.cs |   2 +-
 src/rasdaq/Audio/AudioSource.cs  |  53 ++-----------------------------
 5 files changed, 10 insertions(+), 57 deletions(-)
 create mode 100644 samples/pong/assets/laser.wav

diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index 44142a6..362875a 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -5,6 +5,7 @@
 using rasdaq.Graphics;
 using rasdaq.Inputs;
 using rasdaq.Logging;
+using rasdaq.Resources;
 using rasdaq.Transformations;
 
 namespace pong;
@@ -15,10 +16,13 @@ public override void Start()
     {
         base.Start();
 
-        Entity?.AddComponent(new AudioSource());
+        AudioSource source = new();
+        Entity.AddComponent(source);
 
-        Audio audio1 = ResourceManager.Load<Audio>("assets/audio.wav");
-        Entity?.GetComponent<AudioSource>()?.AttachAudio(audio1);
+        Audio audio1 = ResourceManager.Load<Audio>("assets/laser.wav");
+        Entity.GetComponent<AudioSource>();
+        source.Handle = audio1.Handle;
+        Game.Instance.AudioManager.PlaySource(source);
 
         Input.OnKeyDownEvent.Add(Keys.W, () =>
         {
diff --git a/samples/pong/assets/laser.wav b/samples/pong/assets/laser.wav
new file mode 100644
index 0000000000000000000000000000000000000000..f14037edd909483973043704eb7167a0fe0daabd
GIT binary patch
literal 130316
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
Kp776@hxk7sFY4I<

literal 0
HcmV?d00001

diff --git a/src/rasdaq/Application.cs b/src/rasdaq/Application.cs
index 3c454f7..f5ae3df 100644
--- a/src/rasdaq/Application.cs
+++ b/src/rasdaq/Application.cs
@@ -116,8 +116,6 @@ private void OnLoad()
 
         Renderer.Instance.Init();
 
-        AudioManager.Initialize();
-
         Init();
 
         Start();
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index 7e08fb1..c211f05 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -17,7 +17,7 @@ private static void CheckALCError(ALDevice device)
         }
     }
 
-    private static void CheckALError()
+    public static void CheckALError()
     {
         ALError error = AL.GetError();
         if (error != ALError.NoError)
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index b2fd37c..1024a40 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -1,5 +1,4 @@
 using OpenTK.Audio.OpenAL;
-
 using rasdaq.Core.ECS;
 using rasdaq.Logging;
 
@@ -7,14 +6,9 @@ namespace rasdaq.Audio;
 
 public class AudioSource : Component, IDisposable
 {
-    internal int? Handle = null;
+    public int Handle;
 
     public AudioSource()
-    {
-        Init();
-    }
-
-    internal override void Init()
     {
         Handle = AL.GenSource();
         // Check for errors
@@ -28,51 +22,8 @@ internal override void Init()
         }
     }
 
-    /// <summary>
-    /// Add a loaded audio file to an audio source, so that it can be played.
-    /// </summary>
-    /// <param name="audio">Audio file</param>
-    /// <param name="audioSource">Audio source</param>
-    public void AttachAudio(Audio audio)
-    {
-        if (Handle != null)
-        {
-            AL.Source(Handle.Value, ALSourcei.Buffer, audio.Handle);
-            AudioManager.CheckALError();
-        }
-        else
-        {
-            Log.Error("Audio source has not been initialized yet. Cannot attach audio.");
-        }
-    }
-
-    public void Play()
-    {
-        if (!Handle.HasValue)
-        {
-            Log.Error("Audio source handle is null. Cannot play audio.");
-            return;
-        }
-        AL.SourcePlay(Handle.Value);
-        AudioManager.CheckALError();
-    }
-
-    public void Stop()
-    {
-        if (!Handle.HasValue)
-        {
-            Log.Error("Audio source handle is null. Cannot play audio.");
-            return;
-        }
-        AL.SourceStop(Handle.Value);
-        AudioManager.CheckALError();
-    }
-
     public void Dispose()
     {
-        if (Handle.HasValue)
-        {
-            AL.DeleteSource(Handle.Value);
-        }
+        AL.DeleteSource(Handle);
     }
 }

From 86da7019a69a51f7288e59327536aa50aeaf5602 Mon Sep 17 00:00:00 2001
From: Andrei Lodestone <andreipatea@gmail.com>
Date: Tue, 15 Sep 2026 21:42:08 +0100
Subject: [PATCH 17/20] audiosource play button

---
 .vscode/settings.json                   |  2 +-
 samples/pong/Game.cs                    |  1 +
 samples/pong/Soldier.cs                 | 27 +++++++---------
 src/rasdaq/Audio/AudioLoader.cs         | 13 ++++++++
 src/rasdaq/Audio/AudioManager.cs        | 21 +++++++++++--
 src/rasdaq/Audio/AudioSource.cs         | 19 +++++++++++-
 src/rasdaq/Audio/WAVLoader.cs           | 41 +++++++++++++++----------
 src/rasdaq/Resources/ResourceManager.cs |  2 +-
 8 files changed, 89 insertions(+), 37 deletions(-)
 create mode 100644 src/rasdaq/Audio/AudioLoader.cs

diff --git a/.vscode/settings.json b/.vscode/settings.json
index ea34286..1a79a42 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -11,6 +11,6 @@
         "source.fixAll.dotnet": "explicit"
     },
     "[csharp]": {
-        "editor.defaultFormatter": "ms-dotnettools.csharp"
+        "editor.defaultFormatter": "csharpier.csharpier-vscode"
     }
 }
\ No newline at end of file
diff --git a/samples/pong/Game.cs b/samples/pong/Game.cs
index 4fc1f7e..0c15cdc 100644
--- a/samples/pong/Game.cs
+++ b/samples/pong/Game.cs
@@ -1,4 +1,5 @@
 using rasdaq;
+using rasdaq.Audio;
 using rasdaq.Core.ECS;
 using rasdaq.Graphics;
 using rasdaq.Resources;
diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index 362875a..80925f6 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -12,33 +12,23 @@ namespace pong;
 
 internal class Soldier : Component
 {
+    AudioSource _audioSource;
+
     public override void Start()
     {
         base.Start();
 
+        Audio audio1 = ResourceManager.Load<Audio>("assets/laser.wav");
         AudioSource source = new();
+        // source.Handle = audio1.Handle;
+        source.SetAudio(audio1);
+        _audioSource = source;
         Entity.AddComponent(source);
-
-        Audio audio1 = ResourceManager.Load<Audio>("assets/laser.wav");
-        Entity.GetComponent<AudioSource>();
-        source.Handle = audio1.Handle;
-        Game.Instance.AudioManager.PlaySource(source);
-
-        Input.OnKeyDownEvent.Add(Keys.W, () =>
-        {
-            Log.Info("User pressed W based on an event");
-        });
-
-        Input.OnKeyUpEvent.Add(Keys.B, () =>
-        {
-            Log.Info("Hello");
-        });
     }
 
     public override void Update(double deltaTime)
     {
         base.Update(deltaTime);
-
     }
 
     public override void FrameUpdate(double deltaTime)
@@ -50,6 +40,11 @@ public override void FrameUpdate(double deltaTime)
             Entity.Transform.RotateFromPoint(new Vector2(800, 200), 90);
         }
 
+        if (Input.IsKeyPressed(Keys.Space))
+        {
+            _audioSource.Play();
+        }
+
         PhysicsBody? body = Entity?.GetComponent<PhysicsBody>();
 
         if (Input.IsKeyDown(Keys.W))
diff --git a/src/rasdaq/Audio/AudioLoader.cs b/src/rasdaq/Audio/AudioLoader.cs
new file mode 100644
index 0000000..8ea563d
--- /dev/null
+++ b/src/rasdaq/Audio/AudioLoader.cs
@@ -0,0 +1,13 @@
+using OpenTK.Audio.OpenAL;
+using rasdaq.Logging;
+using rasdaq.Resources;
+
+namespace rasdaq.Audio;
+
+public class AudioLoader : IResourceLoader
+{
+    public object Load(string path)
+    {
+        return AudioManager.Instance.LoadAudio(path);
+    }
+}
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index c211f05..07c1a25 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -1,11 +1,25 @@
 using OpenTK.Audio.OpenAL;
-
 using rasdaq.Logging;
 
 namespace rasdaq.Audio;
 
 public class AudioManager
 {
+    public static AudioManager Instance
+    {
+        get
+        {
+            if (_instance == null)
+            {
+                _instance = new();
+            }
+
+            return _instance;
+        }
+    }
+
+    private static AudioManager _instance;
+
     private static void CheckALCError(ALDevice device)
     {
         AlcError error = ALC.GetError(device);
@@ -44,7 +58,10 @@ public AudioManager()
         }
 
         // Create a context for the device.
-        ALContext context = ALC.CreateContext(device, new ALContextAttributes(null, null, null, null, null));
+        ALContext context = ALC.CreateContext(
+            device,
+            new ALContextAttributes(null, null, null, null, null)
+        );
         if (context == ALContext.Null)
         {
             ALC.CloseDevice(device);
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index 1024a40..e08c984 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -7,8 +7,9 @@ namespace rasdaq.Audio;
 public class AudioSource : Component, IDisposable
 {
     public int Handle;
+    public Audio AudioClip;
 
-    public AudioSource()
+    public AudioSource(Audio? audioClip = null)
     {
         Handle = AL.GenSource();
         // Check for errors
@@ -20,10 +21,26 @@ public AudioSource()
             Log.Error(err);
             throw new Exception("OpenAL error while trying to create audio source: " + error);
         }
+
+        if (audioClip != null)
+        {
+            SetAudio(audioClip);
+        }
     }
 
     public void Dispose()
     {
         AL.DeleteSource(Handle);
     }
+
+    public void Play()
+    {
+        AudioManager.Instance.PlaySource(this);
+    }
+
+    public void SetAudio(Audio audioClip)
+    {
+        AudioManager.Instance.AttachAudioToSource(audioClip, this);
+        this.AudioClip = audioClip;
+    }
 }
diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
index 2db7780..3fc0b54 100644
--- a/src/rasdaq/Audio/WAVLoader.cs
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -1,8 +1,8 @@
+using System.Buffers.Binary;
+using System.Text;
 using OpenTK.Audio.OpenAL;
 using rasdaq.Logging;
 using rasdaq.Resources;
-using System.Buffers.Binary;
-using System.Text;
 
 namespace rasdaq.Audio;
 
@@ -68,18 +68,26 @@ private static FmtChunk ProcessFmtChunck(FileStream stream)
         chunk.SampleRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
         chunk.ByteRate = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4));
         chunk.BlockAlign = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
-        chunk.BitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+        chunk.BitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(
+            ReadBytesFromStream(stream, 2)
+        );
 
         if (size > 16)
         {
-            ushort extensionSize = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2));
+            ushort extensionSize = BinaryPrimitives.ReadUInt16LittleEndian(
+                ReadBytesFromStream(stream, 2)
+            );
             if (extensionSize == 22)
             {
                 chunk.Extension = new FmtChunkExtension()
                 {
-                    ValidBitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(ReadBytesFromStream(stream, 2)),
-                    SpeakerPositionMask = BinaryPrimitives.ReadUInt32LittleEndian(ReadBytesFromStream(stream, 4)),
-                    SubFormat = new Guid(ReadBytesFromStream(stream, 16))
+                    ValidBitsPerSample = BinaryPrimitives.ReadUInt16LittleEndian(
+                        ReadBytesFromStream(stream, 2)
+                    ),
+                    SpeakerPositionMask = BinaryPrimitives.ReadUInt32LittleEndian(
+                        ReadBytesFromStream(stream, 4)
+                    ),
+                    SubFormat = new Guid(ReadBytesFromStream(stream, 16)),
                 };
             }
         }
@@ -129,7 +137,9 @@ public static WAVData LoadWav(string path)
             Encoding.UTF8.GetString(byteFileType);
             if (Encoding.ASCII.GetString(byteFileType) != "WAVE")
             {
-                throw new Exception("Invalid WAV file: file type not listed as WAVE in RIFF header.");
+                throw new Exception(
+                    "Invalid WAV file: file type not listed as WAVE in RIFF header."
+                );
             }
 
             FmtChunk fmtChunk = new FmtChunk();
@@ -157,15 +167,14 @@ public static WAVData LoadWav(string path)
                 }
                 else
                 {
-                    throw new Exception("Unsupported WAV file: unknown chunk type " + Encoding.ASCII.GetString(chunkId));
+                    throw new Exception(
+                        "Unsupported WAV file: unknown chunk type "
+                            + Encoding.ASCII.GetString(chunkId)
+                    );
                 }
             }
 
-            return new WAVData()
-            {
-                Format = fmtChunk,
-                Data = dataChunk
-            };
+            return new WAVData() { Format = fmtChunk, Data = dataChunk };
         }
     }
 
@@ -178,10 +187,10 @@ public static WAVData LoadWav(string path)
     public object Load(string path)
     {
         // Create an OpenAL buffer for the data to go in.
-        Audio audio = new Audio();
+        Audio audio = new();
 
         // Load the WAV file
-        WAVLoader.WAVData wavData = WAVLoader.LoadWav(path);
+        WAVData wavData = LoadWav(path);
 
         // Discern the format of the audio data based on number of channels and bits per sample.
         ALFormat format;
diff --git a/src/rasdaq/Resources/ResourceManager.cs b/src/rasdaq/Resources/ResourceManager.cs
index 85e1773..96a572a 100644
--- a/src/rasdaq/Resources/ResourceManager.cs
+++ b/src/rasdaq/Resources/ResourceManager.cs
@@ -18,7 +18,7 @@ static ResourceManager()
         _loaders["txt"] = new TextLoader();
         _loaders["png"] = new TextureLoader();
         _loaders["jpg"] = new TextureLoader();
-        _loaders["wav"] = new WAVLoader();
+        _loaders["wav"] = new AudioLoader();
     }
 
     /// <summary>

From 1acf5d96c14d4dc505541e288eb9b24398fd535f Mon Sep 17 00:00:00 2001
From: Andrei Lodestone <andreipatea@gmail.com>
Date: Tue, 15 Sep 2026 21:44:22 +0100
Subject: [PATCH 18/20] stop and internalize funcs

---
 src/rasdaq/Audio/Audio.cs        |  3 +--
 src/rasdaq/Audio/AudioManager.cs |  8 ++++----
 src/rasdaq/Audio/AudioSource.cs  | 17 ++++++++++++++++-
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/rasdaq/Audio/Audio.cs b/src/rasdaq/Audio/Audio.cs
index 023026b..0ec230e 100644
--- a/src/rasdaq/Audio/Audio.cs
+++ b/src/rasdaq/Audio/Audio.cs
@@ -1,12 +1,11 @@
 using OpenTK.Audio.OpenAL;
-
 using rasdaq.Logging;
 
 namespace rasdaq.Audio;
 
 public class Audio : IDisposable
 {
-    public int Handle;
+    internal int Handle;
 
     public Audio()
     {
diff --git a/src/rasdaq/Audio/AudioManager.cs b/src/rasdaq/Audio/AudioManager.cs
index 07c1a25..8ad0742 100644
--- a/src/rasdaq/Audio/AudioManager.cs
+++ b/src/rasdaq/Audio/AudioManager.cs
@@ -83,7 +83,7 @@ public AudioManager()
     /// <param name="path">Path to WAV file</param>
     /// <returns>A integer handle referring to the loaded audio</returns>
     /// <exception cref="Exception"></exception>
-    public Audio LoadAudio(string path)
+    internal Audio LoadAudio(string path)
     {
         // Create an OpenAL buffer for the data to go in.
         Audio audio = new Audio();
@@ -148,7 +148,7 @@ public Audio LoadAudio(string path)
     /// </summary>
     /// <param name="audio">Audio file</param>
     /// <param name="audioSource">Audio source</param>
-    public void AttachAudioToSource(Audio audio, AudioSource audioSource)
+    internal void AttachAudioToSource(Audio audio, AudioSource audioSource)
     {
         AL.Source(audioSource.Handle, ALSourcei.Buffer, audio.Handle);
         CheckALError();
@@ -158,7 +158,7 @@ public void AttachAudioToSource(Audio audio, AudioSource audioSource)
     /// Play back an audio source that has audio attached to it.
     /// </summary>
     /// <param name="source"></param>
-    public void PlaySource(AudioSource audioSource)
+    internal void PlaySource(AudioSource audioSource)
     {
         AL.SourcePlay(audioSource.Handle);
         CheckALError();
@@ -168,7 +168,7 @@ public void PlaySource(AudioSource audioSource)
     /// Stop playback of an audio source.
     /// </summary>
     /// <param name="source"></param>
-    public void StopSource(AudioSource audioSource)
+    internal void StopSource(AudioSource audioSource)
     {
         AL.SourceStop(audioSource.Handle);
         CheckALError();
diff --git a/src/rasdaq/Audio/AudioSource.cs b/src/rasdaq/Audio/AudioSource.cs
index e08c984..00f4b3c 100644
--- a/src/rasdaq/Audio/AudioSource.cs
+++ b/src/rasdaq/Audio/AudioSource.cs
@@ -6,7 +6,7 @@ namespace rasdaq.Audio;
 
 public class AudioSource : Component, IDisposable
 {
-    public int Handle;
+    internal int Handle;
     public Audio AudioClip;
 
     public AudioSource(Audio? audioClip = null)
@@ -33,11 +33,26 @@ public void Dispose()
         AL.DeleteSource(Handle);
     }
 
+    /// <summary>
+    /// Plays the loaded audio clip.
+    /// </summary>
     public void Play()
     {
         AudioManager.Instance.PlaySource(this);
     }
 
+    /// <summary>
+    /// Stops playing the audio source.
+    /// </summary>
+    public void Stop()
+    {
+        AudioManager.Instance.StopSource(this);
+    }
+
+    /// <summary>
+    /// Sets the audio clip of the audio source.
+    /// </summary>
+    /// <param name="audioClip"></param>
     public void SetAudio(Audio audioClip)
     {
         AudioManager.Instance.AttachAudioToSource(audioClip, this);

From 115564490f679a2f4f970399f617512f3d8231ca Mon Sep 17 00:00:00 2001
From: Andrei Lodestone <andreipatea@gmail.com>
Date: Tue, 15 Sep 2026 21:45:41 +0100
Subject: [PATCH 19/20] add stop to example

---
 samples/pong/Soldier.cs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/samples/pong/Soldier.cs b/samples/pong/Soldier.cs
index 80925f6..ef77e26 100644
--- a/samples/pong/Soldier.cs
+++ b/samples/pong/Soldier.cs
@@ -45,6 +45,11 @@ public override void FrameUpdate(double deltaTime)
             _audioSource.Play();
         }
 
+        if (Input.IsKeyPressed(Keys.LeftShift))
+        {
+            _audioSource.Stop();
+        }
+
         PhysicsBody? body = Entity?.GetComponent<PhysicsBody>();
 
         if (Input.IsKeyDown(Keys.W))

From 40d0ca25d72e7545c53d15f1ce286135c92421f0 Mon Sep 17 00:00:00 2001
From: Andrei Lodestone <andreipatea@gmail.com>
Date: Tue, 15 Sep 2026 21:56:37 +0100
Subject: [PATCH 20/20] format

---
 src/rasdaq/Audio/WAVLoader.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/rasdaq/Audio/WAVLoader.cs b/src/rasdaq/Audio/WAVLoader.cs
index 3fc0b54..2a8449c 100644
--- a/src/rasdaq/Audio/WAVLoader.cs
+++ b/src/rasdaq/Audio/WAVLoader.cs
@@ -1,8 +1,8 @@
-using System.Buffers.Binary;
-using System.Text;
 using OpenTK.Audio.OpenAL;
 using rasdaq.Logging;
 using rasdaq.Resources;
+using System.Buffers.Binary;
+using System.Text;
 
 namespace rasdaq.Audio;