AudioSystemRequests.h

#pragma once
 
#include <AudioSystemPlugin/AudioSystemPluginDLL.h>
 
#include <AudioSystemPlugin/Core/AudioSystemData.h>
 
#include <Foundation/Types/Status.h>
#include <Foundation/Types/VariantType.h>
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST_CALLBACK(name) \
  using CallbackType = plDelegate<void(const name&)>; \
  CallbackType m_Callback
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(name)                                       \
  bool operator==(const name& rhs) const                                                       \
  {                                                                                            \
    return static_cast<plAudioSystemRequest>(*this) == static_cast<plAudioSystemRequest>(rhs); \
  }                                                                                            \
  bool operator!=(const name& rhs) const                                                       \
  {                                                                                            \
    return !(*this == rhs);                                                                    \
  }                                                                                            \
  PL_DECLARE_AUDIOSYSTEM_REQUEST_CALLBACK(name)
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(name, eq_ex)                                                  \
  bool operator==(const name& rhs) const                                                                  \
  {                                                                                                       \
    return static_cast<plAudioSystemRequest>(*this) == static_cast<plAudioSystemRequest>(rhs) && (eq_ex); \
  }                                                                                                       \
  bool operator!=(const name& rhs) const                                                                  \
  {                                                                                                       \
    return !(*this == rhs);                                                                               \
  }                                                                                                       \
  PL_DECLARE_AUDIOSYSTEM_REQUEST_CALLBACK(name)
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST_HASH_SIMPLE(name)      \
  template <>                                                 \
  struct plHashHelper<name>                                   \
  {                                                           \
    PL_ALWAYS_INLINE static plUInt32 Hash(const name& value)  \
    {                                                         \
      return plHashHelper<plAudioSystemRequest>::Hash(value); \
    }                                                         \
    PL_ALWAYS_INLINE static bool                              \
    Equal(const name& a, const name& b)                       \
    {                                                         \
      return a == b;                                          \
    }                                                         \
  }
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST_HASH(name, hash_ex)                                                    \
  template <>                                                                                                 \
  struct plHashHelper<name>                                                                                   \
  {                                                                                                           \
    PL_ALWAYS_INLINE static plUInt32 Hash(const name& value)                                                  \
    {                                                                                                         \
      return plHashingUtils::CombineHashValues32(plHashHelper<plAudioSystemRequest>::Hash(value), (hash_ex)); \
    }                                                                                                         \
    PL_ALWAYS_INLINE static bool                                                                              \
    Equal(const name& a, const name& b)                                                                       \
    {                                                                                                         \
      return a == b;                                                                                          \
    }                                                                                                         \
  }
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST_STREAM_OPERATORS(name)                          \
  PL_AUDIOSYSTEMPLUGIN_DLL void operator<<(plStreamWriter& Stream, const name& Value); \
  PL_AUDIOSYSTEMPLUGIN_DLL void operator>>(plStreamReader& Stream, name& Value)
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(name)            \
  PL_DECLARE_AUDIOSYSTEM_REQUEST_HASH_SIMPLE(name);            \
  PL_DECLARE_AUDIOSYSTEM_REQUEST_STREAM_OPERATORS(name);       \
  PL_DECLARE_REFLECTABLE_TYPE(PL_AUDIOSYSTEMPLUGIN_DLL, name); \
  PL_DECLARE_CUSTOM_VARIANT_TYPE(name)
 
 
#define PL_DECLARE_AUDIOSYSTEM_REQUEST(name, hash_ex)          \
  PL_DECLARE_AUDIOSYSTEM_REQUEST_HASH(name, hash_ex);          \
  PL_DECLARE_AUDIOSYSTEM_REQUEST_STREAM_OPERATORS(name);       \
  PL_DECLARE_REFLECTABLE_TYPE(PL_AUDIOSYSTEMPLUGIN_DLL, name); \
  PL_DECLARE_CUSTOM_VARIANT_TYPE(name)
 
 
#define PL_DEFINE_AUDIOSYSTEM_STREAM_OPERATORS_SIMPLE(name)    \
  void operator<<(plStreamWriter& Stream, const name& Value)   \
  {                                                            \
    Stream << static_cast<const plAudioSystemRequest&>(Value); \
  }                                                            \
  void operator>>(plStreamReader& Stream, name& Value)         \
  {                                                            \
    Stream >> static_cast<plAudioSystemRequest&>(Value);       \
  }
 
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequest
{
  plAudioSystemDataID m_uiEntityId{0};
 
  plAudioSystemDataID m_uiListenerId{0};
 
  plAudioSystemDataID m_uiObjectId{0};
 
  plStatus m_eStatus{PL_FAILURE};
 
  bool operator==(const plAudioSystemRequest& rhs) const
  {
    return m_uiEntityId == rhs.m_uiEntityId && m_uiListenerId == rhs.m_uiListenerId && m_uiObjectId == rhs.m_uiObjectId && m_eStatus.Succeeded() == rhs.m_eStatus.Succeeded();
  }
 
  bool operator!=(const plAudioSystemRequest& rhs) const
  {
    return !(*this == rhs);
  }
};
 
template <>
struct plHashHelper<plAudioSystemRequest>
{
  PL_ALWAYS_INLINE static plUInt32 Hash(const plAudioSystemRequest& value)
  {
    return plHashHelper<plUInt64>::Hash(value.m_uiEntityId) * plHashHelper<plUInt64>::Hash(value.m_uiListenerId) * plHashHelper<plUInt64>::Hash(value.m_uiObjectId);
  }
 
  PL_ALWAYS_INLINE static bool Equal(const plAudioSystemRequest& a, const plAudioSystemRequest& b)
  {
    return a == b;
  }
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestRegisterEntity : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestRegisterEntity, m_sName == rhs.m_sName);
 
  plString m_sName;
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestSetEntityTransform : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestSetEntityTransform, m_Transform == rhs.m_Transform);
 
  plAudioSystemTransform m_Transform;
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestUnregisterEntity : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(plAudioSystemRequestUnregisterEntity);
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestRegisterListener : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestRegisterListener, m_sName == rhs.m_sName);
 
  plString m_sName;
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestSetListenerTransform : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestSetListenerTransform, m_Transform == rhs.m_Transform);
 
  plAudioSystemTransform m_Transform;
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestUnregisterListener : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(plAudioSystemRequestUnregisterListener);
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestLoadTrigger : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestLoadTrigger, m_uiEventId == rhs.m_uiEventId);
 
  plAudioSystemDataID m_uiEventId{0};
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestActivateTrigger : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestActivateTrigger, m_uiEventId == rhs.m_uiEventId);
 
  plAudioSystemDataID m_uiEventId{0};
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestStopEvent : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestStopEvent, m_uiTriggerId == rhs.m_uiTriggerId);
 
  plAudioSystemDataID m_uiTriggerId{0};
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestUnloadTrigger : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(plAudioSystemRequestUnloadTrigger);
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestSetRtpcValue : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestSetRtpcValue, m_fValue == rhs.m_fValue);
 
  float m_fValue{0.0f};
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestSetSwitchState : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(plAudioSystemRequestSetSwitchState);
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestSetEnvironmentAmount : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestSetEnvironmentAmount, m_fAmount == rhs.m_fAmount);
 
  float m_fAmount{0.0f};
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestSetObstructionOcclusion : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE(plAudioSystemRequestSetObstructionOcclusion, m_fObstruction == rhs.m_fObstruction && m_fOcclusion == rhs.m_fOcclusion);
 
  float m_fObstruction{0.0f};
 
  float m_fOcclusion{0.0f};
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestLoadBank : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(plAudioSystemRequestLoadBank);
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestUnloadBank : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(plAudioSystemRequestUnloadBank);
};
 
struct PL_AUDIOSYSTEMPLUGIN_DLL plAudioSystemRequestShutdown : public plAudioSystemRequest
{
  PL_DECLARE_AUDIOSYSTEM_REQUEST_TYPE_SIMPLE(plAudioSystemRequestShutdown);
};
 
PL_DECLARE_AUDIOSYSTEM_REQUEST_STREAM_OPERATORS(plAudioSystemRequest);
PL_DECLARE_REFLECTABLE_TYPE(PL_AUDIOSYSTEMPLUGIN_DLL, plAudioSystemRequest);
 
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestRegisterEntity, plHashHelper<plString>::Hash(value.m_sName));
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestSetEntityTransform, plHashHelper<plAudioSystemTransform>::Hash(value.m_Transform));
PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(plAudioSystemRequestUnregisterEntity);
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestRegisterListener, plHashHelper<plString>::Hash(value.m_sName));
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestSetListenerTransform, plHashHelper<plAudioSystemTransform>::Hash(value.m_Transform));
PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(plAudioSystemRequestUnregisterListener);
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestLoadTrigger, plHashHelper<plAudioSystemDataID>::Hash(value.m_uiEventId));
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestActivateTrigger, plHashHelper<plAudioSystemDataID>::Hash(value.m_uiEventId));
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestStopEvent, plHashHelper<plAudioSystemDataID>::Hash(value.m_uiTriggerId));
PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(plAudioSystemRequestUnloadTrigger);
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestSetRtpcValue, plHashHelper<plInt32>::Hash(plMath::FloatToInt(value.m_fValue * 1000.0f)));
PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(plAudioSystemRequestSetSwitchState);
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestSetEnvironmentAmount, plHashHelper<plInt32>::Hash(plMath::FloatToInt(value.m_fAmount * 1000.0f)));
PL_DECLARE_AUDIOSYSTEM_REQUEST(plAudioSystemRequestSetObstructionOcclusion, plHashHelper<plInt32>::Hash(plMath::FloatToInt(value.m_fObstruction * 1000.0f)) * plHashHelper<plInt32>::Hash(plMath::FloatToInt(value.m_fOcclusion * 1000.0f)));
PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(plAudioSystemRequestLoadBank);
PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(plAudioSystemRequestUnloadBank);
PL_DECLARE_AUDIOSYSTEM_REQUEST_SIMPLE(plAudioSystemRequestShutdown);
 
struct CallRequestCallbackFunc
{
  explicit CallRequestCallbackFunc(const plVariant& value)
    : m_Value(value)
  {
  }
 
  template <typename T>
  PL_ALWAYS_INLINE void Call() const
  {
    plResult conversionStatus = PL_SUCCESS;
    const auto& request = m_Value.ConvertTo<T>(&conversionStatus);
 
    if (conversionStatus.Succeeded())
    {
      request.m_Callback(request);
    }
  }
 
  template <typename T>
  void operator()() const
  {
    if (!m_Value.IsValid())
      return;
 
    if (m_Value.IsA<plAudioSystemRequestRegisterEntity>())
    {
      Call<plAudioSystemRequestRegisterEntity>();
    }
    else if (m_Value.IsA<plAudioSystemRequestSetEntityTransform>())
    {
      Call<plAudioSystemRequestSetEntityTransform>();
    }
    else if (m_Value.IsA<plAudioSystemRequestUnregisterEntity>())
    {
      Call<plAudioSystemRequestUnregisterEntity>();
    }
    else if (m_Value.IsA<plAudioSystemRequestRegisterListener>())
    {
      Call<plAudioSystemRequestRegisterListener>();
    }
    else if (m_Value.IsA<plAudioSystemRequestSetListenerTransform>())
    {
      Call<plAudioSystemRequestSetListenerTransform>();
    }
    else if (m_Value.IsA<plAudioSystemRequestUnregisterListener>())
    {
      Call<plAudioSystemRequestUnregisterListener>();
    }
    else if (m_Value.IsA<plAudioSystemRequestLoadTrigger>())
    {
      Call<plAudioSystemRequestLoadTrigger>();
    }
    else if (m_Value.IsA<plAudioSystemRequestActivateTrigger>())
    {
      Call<plAudioSystemRequestActivateTrigger>();
    }
    else if (m_Value.IsA<plAudioSystemRequestStopEvent>())
    {
      Call<plAudioSystemRequestStopEvent>();
    }
    else if (m_Value.IsA<plAudioSystemRequestSetRtpcValue>())
    {
      Call<plAudioSystemRequestSetRtpcValue>();
    }
    else if (m_Value.IsA<plAudioSystemRequestSetSwitchState>())
    {
      Call<plAudioSystemRequestSetSwitchState>();
    }
    else if (m_Value.IsA<plAudioSystemRequestSetEnvironmentAmount>())
    {
      Call<plAudioSystemRequestSetEnvironmentAmount>();
    }
    else if (m_Value.IsA<plAudioSystemRequestSetObstructionOcclusion>())
    {
      Call<plAudioSystemRequestSetObstructionOcclusion>();
    }
    else if (m_Value.IsA<plAudioSystemRequestLoadBank>())
    {
      Call<plAudioSystemRequestLoadBank>();
    }
    else if (m_Value.IsA<plAudioSystemRequestUnloadBank>())
    {
      Call<plAudioSystemRequestUnloadBank>();
    }
    else if (m_Value.IsA<plAudioSystemRequestShutdown>())
    {
      Call<plAudioSystemRequestShutdown>();
    }
    else
    {
      plLog::Error("[AudioSystem] Received an Audio Request with an invalid type");
    }
  }
 
  const plVariant& m_Value;
};