AudioExtension.cpp

#include "ExtensionRegistry.h"
#include "EntityDefinitions.h"
 
#include "Context.h"
#include "Services/Services.h"
 
#include "AudioSystem.h"
#include "AudioListenerComponent.h"
 
#include "SoundManager.h"
#include "WaveSoundLoader.h"
 
#include "Serialization/ResourceReader.h"
 
#include "Services/Services.h"
 
#include "AudioFunctions.h"
 
namespace Cogs
{
  namespace Core
  {
    struct AudioExtension : public Extension
    {
      AudioExtension() { ExtensionRegistry::add(this, COGS_CORE_VERSION_STRING); }
 
      bool initializeStatic() override {
        Reflection::TypeDatabase::createType<SoundHandle>();
 
        AudioComponent::registerType();
        AudioListenerComponent::registerType();
 
        Reflection::TypeDatabase::createType<SoundManager>();
 
        return true;
      }
 
      bool initialize(Context * context) override {
        auto manager = std::make_unique<SoundManager>(context);
        manager->registerLoader(new WaveSoundLoader());
        auto soundManager = manager.get();
        context->engine->addResourceManager(std::move(manager));
 
        context->services->registerServiceReference(soundManager);
 
        ExtensionRegistry::registerExtensionSystem<AudioSystem>(context, SystemPriority::PreTransform, 128);
 
        context->registerDynamicComponentType("AudioListenerComponent");
 
        ReaderExtension readerExtension;
        readerExtension.readCallback = [=](const StringView & name, const Value & jsonValue)
        {
          for (auto & m : jsonValue.GetObject()) {
            auto key = toKey(m.name);
 
            if (key == "path") {
              auto sound = soundManager->loadSound(toKey(m.value));
 
              sound->setName(name.to_string());
            }
          }
        };
 
        readerExtension.setCallback = [=](void * component, const Reflection::Field * field, const FieldValue & value)
        {
          auto fieldValue = field->getPtr<SoundHandle>(component);
 
          *fieldValue = soundManager->loadSound(value.value);
        };
 
        registerExtensionReader(context, "Sound", Reflection::TypeDatabase::getType<SoundHandle>(), readerExtension);
        return true;
      }
 
      const char * getExtensionKey() const override { return "Audio"; }
    } audioExtensionInstance;
  }
}