Refactored ref_sound class

src/xrEngine/IGame_Level.cpp

@@ -71,11 +71,6 @@ void IGame_Level::net_Stop()
 
 //-------------------------------------------------------------------------------------------
 // extern CStatTimer tscreate;
-void _sound_event(const ref_sound_data_ptr& S, float range)
-{
-    if (g_pGameLevel && S && S->feedback)
-        g_pGameLevel->SoundEvent_Register(S, range);
-}
 
 static void build_callback(Fvector* V, int Vcnt, CDB::TRI* T, int Tcnt, void* params)
 {
@@ -121,7 +116,11 @@ bool IGame_Level::Load(u32 dwNum)
     g_pGamePersistent->SpatialSpacePhysic.initialize(ObjectSpace.GetBoundingVolume());
 
     GEnv.Sound->set_geometry_occ(ObjectSpace.GetStaticModel());
-    GEnv.Sound->set_handler(_sound_event);
+    GEnv.Sound->set_handler([](const ref_sound& S, float range)
+    {
+        if (g_pGameLevel && S && S->feedback)
+            g_pGameLevel->SoundEvent_Register(S, range);
+    });
 
     pApp->LoadSwitch();
 
@@ -258,7 +257,7 @@ void IGame_Level::SetViewEntity(IGameObject* O)
     pCurrentViewEntity = O;
 }
 
-void IGame_Level::SoundEvent_Register(ref_sound_data_ptr S, float range)
+void IGame_Level::SoundEvent_Register(const ref_sound& S, float range)
 {
     if (!g_bLoaded)
         return;

src/xrEngine/IGame_Level.h

@@ -87,7 +87,7 @@ class ENGINE_API IGame_Level : public FactoryObjectBase,
     struct _esound_delegate
     {
         Feel::Sound* dest;
-        ref_sound_data_ptr source;
+        ref_sound source;
         float power;
     };
     xr_vector<_esound_delegate> snd_Events;
@@ -129,7 +129,7 @@ class ENGINE_API IGame_Level : public FactoryObjectBase,
     void SetEntity(IGameObject* O); // { pCurrentEntity=pCurrentViewEntity=O; }
     void SetViewEntity(IGameObject* O); // { pCurrentViewEntity=O; }
 
-    void SoundEvent_Register(ref_sound_data_ptr S, float range);
+    void SoundEvent_Register(const ref_sound& S, float range);
     void SoundEvent_Dispatch();
     void SoundEvent_OnDestDestroy(Feel::Sound*);
 

src/xrGame/script_entity.h

@@ -17,7 +17,6 @@ class CScriptEntityAction;
 class CEntity;
 class CScriptGameObject;
 class CCustomMonster;
-class ref_sound;
 
 using namespace ScriptEntity;
 

src/xrGame/script_sound.cpp

@@ -19,7 +19,6 @@ CScriptSound::CScriptSound(LPCSTR caSoundName, ESoundTypes sound_type)
     m_bIsNoSound = !Engine.Sound.IsSoundEnabled();
     m_caSoundToPlay = caSoundName;
     string_path l_caFileName;
-    VERIFY(GEnv.Sound);
     if (FS.exist(l_caFileName, "$game_sounds$", caSoundName, ".ogg"))
         m_sound.create(caSoundName, st_Effect, sound_type);
     else

src/xrGame/sound_player.cpp

@@ -199,8 +199,8 @@ void CSoundPlayer::play(
     **/
     sound_single.m_sound->clone((*I).second.second->random(id), st_Effect, sg_SourceType);
 
-    sound_single.m_sound->_p->g_object = m_object;
-    sound_single.m_sound->_p->g_userdata = (*I).second.first.m_data;
+    sound_single.m_sound->_get()->g_object = m_object;
+    sound_single.m_sound->_get()->g_userdata = (*I).second.first.m_data;
     VERIFY(sound_single.m_sound->_handle());
 
     VERIFY(max_start_time >= min_start_time);

src/xrGame/sound_player_inline.h

@@ -46,12 +46,12 @@ IC ref_sound* CSoundPlayer::CSoundCollection::add(ESoundTypes type, LPCSTR name)
 {
     ref_sound* temp = xr_new<ref_sound>();
     temp->create(name, st_Effect, type);
-    if (!temp->_p)
+    if (!temp)
     {
         xr_delete(temp);
-        return (0);
+        return nullptr;
     }
-    return (temp);
+    return temp;
 }
 
 IC const CSoundPlayer::SOUND_COLLECTIONS& CSoundPlayer::objects() const { return (m_sounds); }

src/xrSound/Sound.h

@@ -22,8 +22,8 @@ constexpr pcstr SNDENV_FILENAME = "sEnvironment.xr";
 
 // refs
 class IGameObject;
-class ref_sound;
-class ref_sound_data;
+class CSound;
+struct resptrcode_sound;
 class XRSOUND_API CSound_params;
 class XRSOUND_API CSound_source;
 class XRSOUND_API CSound_emitter;
@@ -190,10 +190,10 @@ class XRSOUND_API CSound_stats
     u32 _events;
 };
 
-typedef resptr_core<ref_sound_data, resptr_base<ref_sound_data>> ref_sound_data_ptr;
+using ref_sound = resptr_core<CSound, resptrcode_sound>;
 
 /// definition (Sound Callback)
-typedef void sound_event(const ref_sound_data_ptr& S, float range);
+typedef void sound_event(const ref_sound& S, float range);
 
 namespace CDB
 {
@@ -204,31 +204,30 @@ namespace CDB
 class XRSOUND_API XR_NOVTABLE ISoundManager
 {
 protected:
-    friend class ref_sound_data;
-    virtual bool _create_data(ref_sound_data& S, pcstr fName, esound_type sound_type, int game_type, bool replaceWithNoSound = true) = 0;
-    virtual void _destroy_data(ref_sound_data& S) = 0;
+    friend class CSound;
+    friend struct resptrcode_sound;
+
+    virtual CSound* create(pcstr fName, esound_type sound_type, int game_type, bool replaceWithNoSound = true) = 0;
+    virtual void destroy(CSound& S) = 0;
+
+    virtual void attach_tail(CSound& S, pcstr fName) = 0;
+
+    virtual void play(ref_sound& S, IGameObject* O, u32 flags = 0, float delay = 0.f) = 0;
+    virtual void play_at_pos(ref_sound& S, IGameObject* O, const Fvector& pos, u32 flags = 0, float delay = 0.f) = 0;
+    virtual void play_no_feedback(ref_sound& S, IGameObject* O, u32 flags = 0, float delay = 0.f, Fvector* pos = nullptr,
+        float* vol = nullptr, float* freq = nullptr, Fvector2* range = nullptr) = 0;
 
 public:
     virtual ~ISoundManager() = default;
 
     virtual void _restart() = 0;
     virtual bool i_locked() = 0;
 
-    virtual bool create(ref_sound& S, pcstr fName, esound_type sound_type, int game_type, bool replaceWithNoSound = true) = 0;
-    virtual void attach_tail(ref_sound& S, pcstr fName) = 0;
-    virtual void clone(ref_sound& S, const ref_sound& from, esound_type sound_type, int game_type) = 0;
-    virtual void destroy(ref_sound& S) = 0;
-
     virtual void prefetch() = 0;
 
     virtual void stop_emitters() = 0;
     virtual int pause_emitters(bool val) = 0;
 
-    virtual void play(ref_sound& S, IGameObject* O, u32 flags = 0, float delay = 0.f) = 0;
-    virtual void play_at_pos(ref_sound& S, IGameObject* O, const Fvector& pos, u32 flags = 0, float delay = 0.f) = 0;
-    virtual void play_no_feedback(ref_sound& S, IGameObject* O, u32 flags = 0, float delay = 0.f, Fvector* pos = nullptr,
-        float* vol = nullptr, float* freq = nullptr, Fvector2* range = nullptr) = 0;
-
     virtual void set_master_volume(float f = 1.f) = 0;
     virtual void set_geometry_env(IReader* I) = 0;
     virtual void set_geometry_som(IReader* I) = 0;
@@ -284,100 +283,129 @@ class CSound_UserData : public xr_resource
 
 using CSound_UserDataPtr = resptr_core<CSound_UserData, resptr_base<CSound_UserData>>;
 
-class ref_sound_data : public xr_resource
+class CSound : public xr_resource
 {
 public:
     //shared_str nm;
-    CSound_source* handle; //!< Pointer to wave-source interface
-    CSound_emitter* feedback; //!< Pointer to emitter, automatically clears on emitter-stop
-    esound_type s_type;
-    int g_type; //!< Sound type, usually for AI
-    IGameObject* g_object; //!< Game object that emits ref_sound
-    CSound_UserDataPtr g_userdata;
-    shared_str fn_attached[2];
+    CSound_source* handle{}; //!< Pointer to wave-source interface
+    CSound_emitter* feedback{}; //!< Pointer to emitter, automatically clears on emitter-stop
 
-    u32 dwBytesTotal;
-    float fTimeTotal;
+    esound_type s_type{ st_Effect };
+    int g_type{}; //!< Sound type, usually for AI
 
-    ref_sound_data() noexcept
-        : handle(0), feedback(0), s_type(st_Effect), g_type(0), g_object(0), dwBytesTotal(0), fTimeTotal(0)
-    {
-    }
+    IGameObject* g_object{}; //!< Game object that emits ref_sound
+    CSound_UserDataPtr g_userdata{};
+    shared_str fn_attached[2];
 
-    ref_sound_data(pcstr fName, esound_type sound_type, int game_type, bool replaceWithNoSound = true)
-    {
-        GEnv.Sound->_create_data(*this, fName, sound_type, game_type, replaceWithNoSound);
-    }
+    u32 dwBytesTotal{};
+    float fTimeTotal{};
 
-    virtual ~ref_sound_data() { GEnv.Sound->_destroy_data(*this); }
+    ~CSound() override { GEnv.Sound->destroy(*this); }
     float get_length_sec() const { return fTimeTotal; }
 };
 
-inline void VerSndUnlocked() { VERIFY(!GEnv.Sound->i_locked()); }
 /*! \class ref_sound
 \brief Sound source + control
 
 The main class representing source/emitter interface
 This class in fact just hides internals and redirect calls to
 specific sub-systems
 */
-class ref_sound
+struct resptrcode_sound : public resptr_base<CSound>
 {
-public:
-    ref_sound_data_ptr _p;
+    [[nodiscard]]
+    ICF CSound_source*     _handle()     const { return p_ ? p_->handle   : nullptr; }
+
+    [[nodiscard]]
+    ICF CSound_emitter*    _feedback()   const { return p_ ? p_->feedback : nullptr; }
+
+    [[nodiscard]]
+    ICF IGameObject*       _g_object()   const { VERIFY(p_); return p_ ? p_->g_object : nullptr; }
 
-    ref_sound() = default;
-    ~ref_sound() = default;
+    [[nodiscard]]
+    ICF int                _g_type()     const { VERIFY(p_); return p_ ? p_->g_type : 0; }
+
+    [[nodiscard]]
+    ICF esound_type        _sound_type() const { VERIFY(p_); return p_ ? p_->s_type : st_Effect; }
+
+    [[nodiscard]]
+    ICF CSound_UserDataPtr _g_userdata() const { VERIFY(p_); return p_ ? p_->g_userdata : nullptr; }
 
-    CSound_source*     _handle() const { return _p ? _p->handle   : nullptr; }
-    CSound_emitter*    _feedback() const { return _p ? _p->feedback : nullptr; }
-    IGameObject*       _g_object()   { VERIFY(_p); return _p->g_object;   }
-    int                _g_type()     { VERIFY(_p); return _p->g_type;     }
-    esound_type        _sound_type() { VERIFY(_p); return _p->s_type;     }
-    CSound_UserDataPtr _g_userdata() { VERIFY(_p); return _p->g_userdata; }
 
     bool create(pcstr name, esound_type sound_type, int game_type, bool replaceWithNoSound = true)
-    { VerSndUnlocked(); return GEnv.Sound->create(*this, name, sound_type, game_type, replaceWithNoSound); }
+    {
+        VerSndUnlocked();
+        _set(GEnv.Sound->create(name, sound_type, game_type, replaceWithNoSound));
+        return _get();
+    }
 
-    void attach_tail(pcstr name)
-    { VerSndUnlocked(); GEnv.Sound->attach_tail(*this, name); }
+    ICF void destroy()
+    {
+        VerSndUnlocked();
+        _set(nullptr);
+    }
 
-    void clone(const ref_sound& from, esound_type sound_type, int game_type)
-    { VerSndUnlocked(); GEnv.Sound->clone(*this, from, sound_type, game_type); }
+    void attach_tail(pcstr name) const
+    {
+        VerSndUnlocked();
+        if (!p_)
+            return;
+        GEnv.Sound->attach_tail(*p_, name);
+    }
 
-    void destroy()
-    { VerSndUnlocked(); GEnv.Sound->destroy(*this); }
+    void clone(const ref_sound& from, esound_type sound_type, int game_type)
+    {
+        if (!from._get())
+            return;
+        _set(xr_new<CSound>());
+        p_->handle = from->handle;
+        p_->dwBytesTotal = from->dwBytesTotal;
+        p_->fTimeTotal = from->fTimeTotal;
+        p_->fn_attached[0] = from->fn_attached[0];
+        p_->fn_attached[1] = from->fn_attached[1];
+        p_->g_type = (game_type == sg_SourceType) ? p_->handle->game_type() : game_type;
+        p_->s_type = sound_type;
+    }
 
     void play(IGameObject* O, u32 flags = 0, float delay = 0.f)
-    { VerSndUnlocked(); GEnv.Sound->play(*this, O, flags, delay); }
+    {
+        VerSndUnlocked();
+        GEnv.Sound->play(static_cast<ref_sound&>(*this), O, flags, delay);
+    }
 
     void play_at_pos(IGameObject* O, const Fvector& pos, u32 flags = 0, float delay = 0.f)
-    { VerSndUnlocked(); GEnv.Sound->play_at_pos(*this, O, pos, flags, delay); }
+    {
+        VerSndUnlocked();
+        GEnv.Sound->play_at_pos(static_cast<ref_sound&>(*this), O, pos, flags, delay);
+    }
 
     void play_no_feedback(IGameObject* O, u32 flags = 0, float delay = 0.f, Fvector* pos = nullptr, float* vol = nullptr, float* freq = nullptr, Fvector2* range = nullptr)
-    { VerSndUnlocked(); GEnv.Sound->play_no_feedback(*this, O, flags, delay, pos, vol, freq, range); }
+    {
+        VerSndUnlocked();
+        GEnv.Sound->play_no_feedback(static_cast<ref_sound&>(*this), O, flags, delay, pos, vol, freq, range);
+    }
 
-    void stop()                           { VerSndUnlocked(); if (_feedback()) _feedback()->stop(false); }
-    void stop_deferred()                  { VerSndUnlocked(); if (_feedback()) _feedback()->stop(true ); }
+    ICF void stop()                           const { VerSndUnlocked(); if (_feedback()) _feedback()->stop(false); }
+    ICF void stop_deferred()                  const { VerSndUnlocked(); if (_feedback()) _feedback()->stop(true ); }
 
-    void set_position(const Fvector& pos) { VerSndUnlocked(); if (_feedback()) _feedback()->set_position(pos); }
-    void set_frequency(float freq)        { VerSndUnlocked(); if (_feedback()) _feedback()->set_frequency(freq); }
-    void set_range(float min, float max)  { VerSndUnlocked(); if (_feedback()) _feedback()->set_range(min, max); }
-    void set_volume(float vol)            { VerSndUnlocked(); if (_feedback()) _feedback()->set_volume(vol); }
-    void set_priority(float p)            { VerSndUnlocked(); if (_feedback()) _feedback()->set_priority(p); }
-    void set_time(float t)                { VerSndUnlocked(); if (_feedback()) _feedback()->set_time(t); }; //--#SM+#--
+    ICF void set_position(const Fvector& pos) const { VerSndUnlocked(); if (_feedback()) _feedback()->set_position(pos); }
+    ICF void set_frequency(float freq)        const { VerSndUnlocked(); if (_feedback()) _feedback()->set_frequency(freq); }
+    ICF void set_range(float min, float max)  const { VerSndUnlocked(); if (_feedback()) _feedback()->set_range(min, max); }
+    ICF void set_volume(float vol)            const { VerSndUnlocked(); if (_feedback()) _feedback()->set_volume(vol); }
+    ICF void set_priority(float p)            const { VerSndUnlocked(); if (_feedback()) _feedback()->set_priority(p); }
+    ICF void set_time(float t)                const { VerSndUnlocked(); if (_feedback()) _feedback()->set_time(t); }; //--#SM+#--
 
-    const CSound_params* get_params()
+    [[nodiscard]]
+    ICF const CSound_params* get_params() const
     {
         VerSndUnlocked();
-        return _feedback() ? _feedback()->get_params() : 0;
+        return _feedback() ? _feedback()->get_params() : nullptr;
     }
 
-    void set_params(CSound_params* p)
+    void set_params(CSound_params* p) const
     {
         VerSndUnlocked();
-        CSound_emitter* const feedback = _feedback();
-        if (feedback)
+        if (CSound_emitter* const feedback = _feedback())
         {
             feedback->set_position(p->position);
             feedback->set_frequency(p->freq);
@@ -386,7 +414,13 @@ class ref_sound
         }
     }
 
-    float get_length_sec() const { return _p ? _p->get_length_sec() : 0.0f; }
+    [[nodiscard]]
+    ICF float get_length_sec() const { return p_ ? p_->get_length_sec() : 0.0f; }
+
+    IC static void VerSndUnlocked()
+    {
+        VERIFY(!GEnv.Sound->i_locked());
+    }
 };
 
 class XRSOUND_API CSound_stats_ext