AudioSystemComponent.h

#pragma once
 
#include <AudioSystemPlugin/AudioSystemPluginDLL.h>
 
#include <AudioSystemPlugin/Core/AudioSystemData.h>
#include <AudioSystemPlugin/Core/AudioSystemMessages.h>
 
#include <Core/World/Component.h>
#include <Core/World/World.h>
 
template <typename T>
class plAudioSystemComponentManager final : public plComponentManager<T, plBlockStorageType::FreeList>
{
  // plComponentManager
 
public:
  void Initialize() override;
 
  // plAudioSystemComponentManager
 
public:
  explicit plAudioSystemComponentManager(plWorld* pWorld);
 
private:
  void Update(const plWorldModule::UpdateContext& context);
 
  static void UpdateFunctionName(plStringBuilder& out_sName);
};
 
class PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemComponent : public plComponent
{
  PL_DECLARE_ABSTRACT_COMPONENT_TYPE(plAudioSystemComponent, plComponent);
 
  // plAudioSystemComponent
 
protected:
  // Dummy method to hide this component in the editor UI.
  virtual void plAudioSystemComponentIsAbstract() = 0;
};
 
class PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemProxyDependentComponent : public plAudioSystemComponent
{
  PL_DECLARE_ABSTRACT_COMPONENT_TYPE(plAudioSystemProxyDependentComponent, plAudioSystemComponent);
 
  // plComponent
 
public:
  void Initialize() override;
  void OnSimulationStarted() override;
  void Deinitialize() override;
 
  // plAudiSystemProxyDependentComponent
 
protected:
  [[nodiscard]] plAudioSystemDataID GetEntityId() const;
 
  class plAudioProxyComponent* m_pProxyComponent{nullptr};
};
 
class PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemEnvironmentComponent : public plAudioSystemProxyDependentComponent
{
  PL_DECLARE_ABSTRACT_COMPONENT_TYPE(plAudioSystemEnvironmentComponent, plAudioSystemProxyDependentComponent);
 
  // plAudioSystemEnvironmentComponent
 
public:
  plAudioSystemEnvironmentComponent();
 
  void OnActivated() override;
  void OnDeactivated() override;
 
  [[nodiscard]] virtual float GetEnvironmentAmount(plAudioProxyComponent* pProxyComponent) const = 0;
 
  [[nodiscard]] plAudioSystemDataID GetEnvironmentId() const;
 
  [[nodiscard]] virtual float GetMaxDistance() const;
 
  virtual void SetMaxDistance(float fFadeDistance);
 
  void OverrideEnvironmentAmount(float fValue);
 
  void OnSetAmount(plMsgAudioSystemSetEnvironmentAmount& msg);
 
protected:
  float m_fMaxDistance;
  plString m_sEnvironmentName;
  plColor m_ShapeColor;
 
  bool m_bOverrideValue;
  float m_fOverrideValue;
};
 
template <typename T>
plAudioSystemComponentManager<T>::plAudioSystemComponentManager(plWorld* pWorld)
  : plComponentManager<T, plBlockStorageType::FreeList>(pWorld)
{
}
 
template <typename T>
void plAudioSystemComponentManager<T>::Initialize()
{
  plStringBuilder functionName;
  UpdateFunctionName(functionName);
 
  auto desc = plWorldModule::UpdateFunctionDesc(plWorldModule::UpdateFunction(&plAudioSystemComponentManager<T>::Update, this), functionName);
  desc.m_bOnlyUpdateWhenSimulating = true;
  desc.m_Phase = plWorldModule::UpdateFunctionDesc::Phase::PostTransform; // Should we apply entity transform after game object transform?
 
  this->RegisterUpdateFunction(desc);
}
 
template <typename T>
void plAudioSystemComponentManager<T>::Update(const plWorldModule::UpdateContext& context)
{
  for (auto it = this->m_ComponentStorage.GetIterator(context.m_uiFirstComponentIndex, context.m_uiComponentCount); it.IsValid(); ++it)
  {
    if (T* pComponent = it; pComponent->IsActiveAndInitialized())
    {
      pComponent->Update();
    }
  }
}
 
// static
template <typename T>
void plAudioSystemComponentManager<T>::UpdateFunctionName(plStringBuilder& out_sName)
{
  plStringView sName(PL_SOURCE_FUNCTION);
  const char* szEnd = sName.FindSubString(",");
 
  if (szEnd != nullptr && sName.StartsWith("plAudioSystemComponentManager<class "))
  {
    const plStringView sChoppedName(sName.GetStartPointer() + plStringUtils::GetStringElementCount("plAudioSystemComponentManager<class "), szEnd);
 
    PL_ASSERT_DEV(!sChoppedName.IsEmpty(), "Chopped name is empty: '{0}'", sName);
 
    out_sName = sChoppedName;
    out_sName.Append("::Update");
  }
  else
  {
    out_sName = sName;
  }
}