Audio API first pass

src/CMakeLists.txt

@@ -41,4 +41,6 @@ endif()
 if(DAWN_TARGET_SDL2)
   add_subdirectory(dawnsdl2)
   add_subdirectory(dawnopengl)
-endif()
+endif()
+
+add_subdirectory(dawnopenal)

src/dawn/audio/_AudioManager.hpp

@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+#include "assert/assert.hpp"
+
+namespace Dawn {
+  class DawnGame;
+
+  class IAudioManager {
+    public:
+      DawnGame *game;
+
+      IAudioManager(DawnGame *game) {
+        assertNotNull(game);
+        this->game = game;
+      }
+
+      virtual void init() = 0;
+      virtual void update() = 0;
+  };
+}

src/dawn/display/Transform.cpp

@@ -89,6 +89,7 @@ void Transform::setLocalPosition(glm::vec3 position) {
   this->localPosition = position;
   this->updateLocalTransformFromLocalValues();
   this->updateChildrenTransforms();
+  this->eventTransformUpdated.invoke();
 }
 
 glm::vec3 Transform::getLocalScale() {
@@ -99,6 +100,7 @@ void Transform::setLocalScale(glm::vec3 scale) {
   this->localScale = scale;
   this->updateLocalTransformFromLocalValues();
   this->updateChildrenTransforms();
+  this->eventTransformUpdated.invoke();
 }
 
 glm::quat Transform::getLocalRotation() {
@@ -109,6 +111,7 @@ void Transform::setLocalRotation(glm::quat rotation) {
   this->localRotation = rotation;
   this->updateLocalTransformFromLocalValues();
   this->updateChildrenTransforms();
+  this->eventTransformUpdated.invoke();
 }
 
 
@@ -121,6 +124,11 @@ void Transform::setLocalTransform(glm::mat4 transform) {
 
   this->updateLocalValuesFromLocalTransform();
   this->updateChildrenTransforms();
+  this->eventTransformUpdated.invoke();
+}
+
+glm::vec3 Transform::getWorldPosition() {
+  return glm::vec3(this->transformWorld[3]);
 }
 
 glm::mat4 Transform::getWorldTransform() {
@@ -131,6 +139,7 @@ void Transform::setWorldTransform(glm::mat4 transform) {
   this->transformWorld = transform;
   this->updateLocalTransformFromWorldTransform();
   this->updateChildrenTransforms();
+  this->eventTransformUpdated.invoke();
 }
 
 
@@ -156,6 +165,7 @@ void Transform::setParent(Transform *parent) {
 
   this->updateLocalTransformFromWorldTransform();
   this->updateChildrenTransforms();
+  this->eventTransformUpdated.invoke();
 }
 
 Transform * Transform::getParent() {

src/dawn/display/Transform.hpp

@@ -7,6 +7,7 @@
 #include "dawnlibs.hpp"
 #include "assert/assert.hpp"
 #include "util/flag.hpp"
+#include "event/Event.hpp"
 
 namespace Dawn {
   class SceneItem;
@@ -38,6 +39,8 @@ namespace Dawn {
       void updateChildrenTransforms();
 
     public:
+      // I have no idea if I'm keeping this
+      Event<> eventTransformUpdated;
       SceneItem *item;
 
       /**
@@ -123,6 +126,13 @@ namespace Dawn {
        */
       void setLocalTransform(glm::mat4 transform);
 
+      /**
+       * Returns the position of the origin of this transform in world-space.
+       * 
+       * @return Transform origin in world-space.
+       */
+      glm::vec3 getWorldPosition();
+
       /**
        * Returns the transformation matrix for this transform, in world-space.
        * @return The transform origin in world-space.

src/dawn/game/_DawnGame.hpp

@@ -14,6 +14,7 @@
 #include "locale/LocaleManager.hpp"
 #include "physics/PhysicsManager.hpp"
 #include "save/SaveManager.hpp"
+#include "audio/AudioManager.hpp"
 
 #define DAWN_GAME_INIT_RESULT_SUCCESS 0
 #define DAWN_GAME_UPDATE_RESULT_SUCCESS 0

src/dawn/scene/components/Components.hpp

@@ -6,12 +6,12 @@
 #pragma once
 #include "scene/components/display/AnimationController.hpp"
 #include "scene/components/display/Camera.hpp"
+#include "scene/components/display/Material.hpp"
 #include "scene/components/display/MeshHost.hpp"
 #include "scene/components/display/MeshRenderer.hpp"
-#include "scene/components/display/Material.hpp"
 #include "scene/components/display/PixelPerfectCamera.hpp"
-#include "scene/components/display/TiledSprite.hpp"
 #include "scene/components/display/SimpleRenderTargetQuad.hpp"
+#include "scene/components/display/TiledSprite.hpp"
 
 #include "scene/components/example/ExampleSpin.hpp"
 

src/dawn/visualnovel/scene/SimpleVNScene.cpp

@@ -25,6 +25,7 @@ void SimpleVNScene::stage() {
 
   // Camera
   this->camera = Camera::create(this);
+  // this->camera->item->addComponent<AudioListener>();
   this->camera->transform->lookAtPixelPerfect(
     glm::vec3(0, 0, 0),
     glm::vec3(0, 0, 0),

src/dawn/visualnovel/scene/SimpleVNScene.hpp

@@ -8,6 +8,7 @@
 #include "game/DawnGame.hpp"
 #include "util/array.hpp"
 #include "scene/components/Components.hpp"
+#include "scene/components/audio/AudioListener.hpp"
 #include "visualnovel/VisualNovelManager.hpp"
 #include "visualnovel/events/VisualNovelTextboxEvent.hpp"
 #include "visualnovel/events/VisualNovelPauseEvent.hpp"

src/dawnglfw/CMakeLists.txt

@@ -8,8 +8,6 @@ target_link_libraries(${DAWN_TARGET_NAME}
   PUBLIC
     glfw
     glad
-    OpenAL
-    AudioFile
 )
 
 # Includes

src/dawnglfw/host/DawnGLFWHost.cpp

@@ -10,9 +10,6 @@
 #include "dawnopengl.hpp"
 #include "display/BackBufferRenderTarget.hpp"
 
-#include <AL/al.h>
-#include <AL/alc.h>
-#include "AudioFile.h"
 
 using namespace Dawn;
 
@@ -26,92 +23,6 @@ DawnHost::DawnHost() {
 }
 
 int32_t DawnHost::init(DawnGame *game) {
-  AudioFile<double> audioFile;
-  audioFile.load ("C:\\sample.wav");
-  audioFile.printSummary();
-
-  ALCdevice* device = alcOpenDevice(nullptr);
-  if(!device) assertUnreachable();
-  
-  ALCcontext *context;
-  context = alcCreateContext(device, NULL);
-  if(!alcMakeContextCurrent(context)) assertUnreachable();
-
-  ALfloat listenerOri[] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f };
-  alListener3f(AL_POSITION, 0, 0, 1.0f);
-  alListener3f(AL_VELOCITY, 0, 0, 0);
-  alListenerfv(AL_ORIENTATION, listenerOri);
-
-  ALuint source;
-  alGenSources((ALuint)1, &source);
-  alSourcef(source, AL_PITCH, 1);
-  alSourcef(source, AL_GAIN, 1);
-  alSource3f(source, AL_POSITION, 0, 0, 0);
-  alSource3f(source, AL_VELOCITY, 0, 0, 0);
-  alSourcei(source, AL_LOOPING, AL_FALSE);
-
-  ALuint buffer;
-  alGenBuffers((ALuint)1, &buffer);
-
-  ALenum format;
-  switch(audioFile.getBitDepth()) {
-    case 16:
-      switch(audioFile.getNumChannels()) {
-        case 2:
-          format = AL_FORMAT_STEREO16;
-          break;
-        case 1:
-          format = AL_FORMAT_MONO16;
-          break;
-        default:
-          assertUnreachable();
-      }
-      break;
-
-    case 8:
-      switch(audioFile.getNumChannels()) {
-        case 2:
-          format = AL_FORMAT_STEREO8;
-          break;
-        case 1:
-          format = AL_FORMAT_MONO8;
-          break;
-        default:
-          assertUnreachable();
-      }
-      break;
-    
-    default:
-      assertUnreachable();
-  }
-
-  std::vector<uint8_t> data;
-  for (int i = 0; i < audioFile.getNumSamplesPerChannel(); i++) {
-    for(int y = 0; y < audioFile.getNumChannels(); y++) {
-      double sample = audioFile.samples[y][i];
-      sample = mathClamp(sample, -1., 1.);
-      auto q = static_cast<int16_t> (sample * 32767.);
-      
-      uint8_t bytes[2];
-      bytes[0] = (q >> 8) & 0xFF;
-      bytes[1] = q & 0xFF;
-      data.push_back(bytes[1]);
-      data.push_back(bytes[0]);
-    }
-  }
-  alBufferData(buffer, format, &data[0], data.size(), audioFile.getSampleRate());
-
-	ALint source_state;
-  alSourcei(source, AL_BUFFER, buffer);
-	alSourcePlay(source);
-	alGetSourcei(source, AL_SOURCE_STATE, &source_state);
-	while (source_state == AL_PLAYING) {
-		alGetSourcei(source, AL_SOURCE_STATE, &source_state);
-	}
-
-  return DAWN_HOST_INIT_RESULT_SUCCESS;
-
-
   // Update values
   this->game = game;
   DAWN_HOST = this;

src/dawnopenal/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Libraries
+target_link_libraries(${DAWN_TARGET_NAME}
+  PUBLIC
+    OpenAL
+    AudioFile
+)
+
+# Includes
+target_include_directories(${DAWN_TARGET_NAME}
+  PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Subdirs
+add_subdirectory(audio)
+add_subdirectory(scene)

src/dawnopenal/audio/AudioData.cpp

@@ -0,0 +1,82 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "AudioData.hpp"
+
+using namespace Dawn;
+
+AudioData::AudioData() {
+
+}
+
+void AudioData::init() {
+  alGenBuffers((ALsizei)1, &this->buffer);
+
+  // Test
+  AudioFile<double> audioFile;
+  audioFile.load ("C:\\sample.wav");
+  audioFile.printSummary();
+
+  ALenum format;
+  switch(audioFile.getBitDepth()) {
+    case 16:
+      switch(audioFile.getNumChannels()) {
+        case 2:
+          format = AL_FORMAT_STEREO16;
+          break;
+        case 1:
+          format = AL_FORMAT_MONO16;
+          break;
+        default:
+          assertUnreachable();
+      }
+      break;
+
+    case 8:
+      switch(audioFile.getNumChannels()) {
+        case 2:
+          format = AL_FORMAT_STEREO8;
+          break;
+        case 1:
+          format = AL_FORMAT_MONO8;
+          break;
+        default:
+          assertUnreachable();
+      }
+      break;
+    
+    default:
+      assertUnreachable();
+  }
+
+  format = AL_FORMAT_MONO16;
+
+  std::vector<uint8_t> data;
+  for (int i = 0; i < audioFile.getNumSamplesPerChannel(); i++) {
+    // for(int y = 0; y < audioFile.getNumChannels(); y++) {
+    for(int y = 0; y < 1; y++) {
+      double sample = audioFile.samples[y][i];
+      sample = mathClamp(sample, -1., 1.);
+      auto q = static_cast<int16_t> (sample * 32767.);
+      
+      uint8_t bytes[2];
+      bytes[0] = (q >> 8) & 0xFF;
+      bytes[1] = q & 0xFF;
+      data.push_back(bytes[1]);
+      data.push_back(bytes[0]);
+    }
+  }
+  alBufferData(buffer, format, &data[0], data.size(), audioFile.getSampleRate());
+
+
+
+
+
+  this->ready = true;
+}
+
+AudioData::~AudioData() {
+  if(this->ready) alDeleteBuffers((ALsizei)1, &this->buffer);
+}

src/dawnopenal/audio/AudioData.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+#include "dawnopenal.hpp"
+#include "assert/assert.hpp"
+#include "util/mathutils.hpp"
+
+namespace Dawn {
+  class AudioSource;
+
+  class AudioData {
+    private:
+      ALuint buffer;
+      bool_t ready = false;
+      ALenum format;
+
+    public:
+
+      AudioData();
+
+      void init();
+
+      ~AudioData();
+
+      friend class AudioSource;
+  };
+}

src/dawnopenal/audio/AudioManager.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "AudioManager.hpp"
+#include "game/DawnGame.hpp"
+
+using namespace Dawn;
+
+AudioManager::AudioManager(DawnGame *g) : IAudioManager(g) {
+
+}
+
+void AudioManager::init() {
+  this->device = alcOpenDevice(nullptr);
+  if(!this->device) assertUnreachable();
+
+  this->context = alcCreateContext(this->device, NULL);
+  if(!alcMakeContextCurrent(this->context)) assertUnreachable();
+  
+  alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
+}
+
+void AudioManager::update() {
+
+}

src/dawnopenal/audio/AudioManager.hpp

@@ -0,0 +1,22 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnopenal.hpp"
+#include "audio/_AudioManager.hpp"
+
+namespace Dawn {
+  class AudioManager : public IAudioManager {
+    private:
+      ALCdevice *device = nullptr;
+      ALCcontext *context = nullptr;
+
+    public:
+      AudioManager(DawnGame *game);
+
+      void init() override;
+      void update() override;
+  };
+}

src/dawnopenal/audio/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    AudioData.cpp
+    AudioManager.cpp
+)

src/dawnopenal/dawnopenal.hpp

@@ -0,0 +1,9 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <AL/al.h>
+#include <AL/alc.h>
+#include "AudioFile.h"

src/dawnopenal/scene/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+add_subdirectory(components)

src/dawnopenal/scene/components/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+add_subdirectory(audio)

src/dawnopenal/scene/components/audio/AudioListener.cpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "AudioListener.hpp"
+
+using namespace Dawn;
+
+AudioListener::AudioListener(SceneItem *i) : SceneItemComponent(i) {
+
+}
+
+void AudioListener::onStart() {
+  alListener3f(AL_VELOCITY, 0, 0, 0);
+
+  ALfloat listenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 };
+  alListenerfv(AL_ORIENTATION, listenerOri);
+
+  glm::vec3 position = this->transform->getLocalPosition();
+  alListener3f(AL_POSITION, position.x, position.y, position.z);
+
+  this->transform->eventTransformUpdated.addListener(this, &AudioListener::onTransformUpdate);
+}
+
+void AudioListener::onDispose() {
+  this->transform->eventTransformUpdated.removeListener(this, &AudioListener::onTransformUpdate);
+}
+
+void AudioListener::onTransformUpdate() {
+  glm::vec3 position = this->transform->getWorldPosition();
+  alListener3f(AL_POSITION, position.x, position.y, position.z);
+}

src/dawnopenal/scene/components/audio/AudioListener.hpp

@@ -0,0 +1,21 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnopenal.hpp"
+#include "scene/SceneItemComponent.hpp"
+
+namespace Dawn {
+  class AudioListener : public SceneItemComponent {
+    private:
+      void onTransformUpdate();
+
+    public:
+      AudioListener(SceneItem *item);
+
+      void onStart() override;
+      void onDispose() override;
+  };
+}

src/dawnopenal/scene/components/audio/AudioSource.cpp

@@ -0,0 +1,90 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "AudioSource.hpp"
+#include "scene/SceneItem.hpp"
+
+using namespace Dawn;
+
+AudioSource::AudioSource(SceneItem *i) : SceneItemComponent(i) {
+
+}
+
+void AudioSource::onStart() {
+  alGenSources((ALuint)1, &this->source);
+
+  // In future these will probably be tied to the layer
+  alSourcef(this->source, AL_PITCH, 1);
+  // alSourcef(this->source, AL_GAIN, AL_MAX_GAIN);
+
+  glm::vec3 position = this->transform->getLocalPosition();
+  alSource3f(this->source, AL_POSITION, position.x, position.y, position.z);
+
+    // alSourcei(this->source, AL_SOURCE_RELATIVE, AL_TRUE);
+    // alSourcef(this->source, AL_REFERENCE_DISTANCE, 0);
+    // alSourcef(this->source, AL_ROLLOFF_FACTOR, 0);
+
+  // Velocity is always zero for now
+  alSource3f(this->source, AL_VELOCITY, 0, 0, 0);
+
+  // Looping
+  alSourcei(this->source, AL_LOOPING, this->loop);
+
+  // Source
+  if(this->data != nullptr && this->data->ready) {
+    alSourcei(source, AL_BUFFER, this->data->buffer);
+  }
+
+  // Playing
+  if(this->playing) alSourcePlay(this->source);
+
+  // Listen for events
+  this->transform->eventTransformUpdated.addListener(this, &AudioSource::onTransformUpdate);
+
+  this->ready = true;
+}
+
+bool_t AudioSource::isLooping() {
+  return this->loop;
+}
+
+void AudioSource::setLoop(bool_t loop) {
+  this->loop = loop;
+  if(this->ready) alSourcei(this->source, AL_LOOPING, loop);
+}
+
+bool_t AudioSource::isPlaying() {
+  return this->playing;
+}
+
+void AudioSource::play() {
+  this->playing = true;
+  if(this->ready && data != nullptr && data->ready) {
+    alSourcePlay(this->source);
+  }
+}
+
+AudioData * AudioSource::getAudioData() {
+  return this->data;
+}
+
+void AudioSource::setAudioData(AudioData *data) {
+  this->data = data;
+  if(this->ready && data != nullptr && data->ready) {
+    alSourcei(source, AL_BUFFER, data->buffer);
+  }
+}
+
+void AudioSource::onDispose() {
+  this->transform->eventTransformUpdated.removeListener(this, &AudioSource::onTransformUpdate);
+
+  this->ready = false;
+  alDeleteSources((ALuint)1, &this->source);
+}
+
+void AudioSource::onTransformUpdate() {
+  glm::vec3 position = this->transform->getWorldPosition();
+  alSource3f(this->source, AL_POSITION, position.x, position.y, position.z);
+}

src/dawnopenal/scene/components/audio/AudioSource.hpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnopenal.hpp"
+#include "scene/SceneItemComponent.hpp"
+#include "audio/AudioData.hpp"
+
+namespace Dawn {
+  class AudioSource : public SceneItemComponent {
+    private:
+      ALuint source;
+      bool_t ready = false;
+
+      // Settings
+      bool_t loop = false;
+      bool_t playing = false;
+      int32_t layer = 0;
+      AudioData *data = nullptr;
+
+      void onTransformUpdate();
+
+    public:
+      /**
+       * Creates an Audio Source item component.
+       * 
+       * @param item SceneItem that this audio source is attached to.
+       */
+      AudioSource(SceneItem *item);
+
+      /**
+       * Returns whether or not the audio source is set to loop or not.
+       * 
+       * @return True if the source is looping otherwise false.
+       */
+      bool_t isLooping();
+
+      /**
+       * Sets whether the audio source should loop or not.
+       * 
+       * @param loop Loop or not.
+       */
+      void setLoop(bool_t loop);
+
+      bool_t isPlaying();
+      void play();
+
+      /**
+       * Returns the current audio data for this source.
+       * 
+       * @return Audio data that is atached to this source.
+       */
+      AudioData * getAudioData();
+
+      /**
+       * Sets the audio data for this source. Currently switching between the
+       * audio data during playback may have undefined behavior.
+       * 
+       * @param data Data to set.
+       */
+      void setAudioData(AudioData *data);
+
+      void onStart() override;
+      void onDispose() override;
+  };
+}

src/dawnopenal/scene/components/audio/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    AudioListener.cpp
+    AudioSource.cpp
+)

src/dawnpokergame/game/DawnGame.cpp

@@ -14,7 +14,8 @@ DawnGame::DawnGame(DawnHost *host) :
   renderManager(this),
   inputManager(this),
   localeManager(this),
-  saveManager(this)
+  saveManager(this),
+  audioManager(this)
 {
 }
 
@@ -22,6 +23,7 @@ int32_t DawnGame::init() {
   this->assetManager.init();
   this->localeManager.init();
   this->renderManager.init();
+  this->audioManager.init();
 
   this->scene = new SubSceneRendererScene<Scene_1>(this);
   

src/dawnpokergame/game/DawnGame.hpp

@@ -21,6 +21,7 @@ namespace Dawn {
       TimeManager timeManager;
       LocaleManager localeManager;
       PokerSaveManager saveManager;
+      AudioManager audioManager;
       
       DawnGame(DawnHost *host);
       int32_t init() override;

src/dawnpokergame/scenes/Scene_1.hpp

@@ -8,6 +8,9 @@
 #include "scenes/Scene_2.hpp"
 #include "prefabs/characters/DeathPrefab.hpp"
 
+#include "scene/components/audio/AudioListener.hpp"
+#include "scene/components/audio/AudioSource.hpp"
+
 namespace Dawn {
   class Scene_1 : public PixelVNScene {
     protected:
@@ -18,6 +21,19 @@ namespace Dawn {
         
         this->death = DeathPrefab::create(this);
         // this->death->vnCharacter.setOpacity(0);
+
+        auto listenerItem = this->createSceneItem();
+        auto listener = listenerItem->addComponent<AudioListener>();
+
+        auto sourceItem = this->createSceneItem();
+        auto source = sourceItem->addComponent<AudioSource>();
+        source->transform->setLocalPosition(glm::vec3(-1, 0, 0));
+
+        auto data = new AudioData();
+        data->init();
+
+        source->setAudioData(data);
+        source->play();
       }
 
       void onSceneEnded() {