node_instance.h

#pragma once
 
#include "sound_bakery/core/core_include.h"
#include "sound_bakery/system.h"
 
namespace sbk::engine
{
    class bus;
    class container;
    class node;
    class node_base;
    class node_instance;
    class sound;
    class sound_container;
    class voice;
 
    struct SB_CLASS NodeGroupInstance
    {
        bool initNodeGroup(const node_base& node);
 
        sc_dsp* lowpass  = nullptr;
        sc_dsp* highpass = nullptr;
        std::unique_ptr<sc_node_group, SC_NODE_GROUP_DELETER> nodeGroup;
    };
 
    struct SB_CLASS ParentNodeOwner
    {
        bool createParent(const node_base& thisNode, voice* owningVoice);
 
        std::shared_ptr<node_instance> parent;
    };
 
    struct SB_CLASS ChildrenNodeOwner
    {
        bool createChildren(const node_base& thisNode,
                            voice* owningVoice,
                            node_instance* thisNodeInstance,
                            unsigned int numTimesPlayed);
 
        std::vector<std::shared_ptr<node_instance>> childrenNodes;
    };
 
    enum class NodeInstanceType
    {
        CHILD,
        BUS,
        MAIN
    };
 
    enum class NodeInstanceState
    {
        UNINIT,
 
        STOPPED,
        STOPPING,
        PAUSED,
        VIRTUAL,
 
        PLAYING
    };
 
    struct SB_CLASS InitNodeInstance
    {
        sbk::core::database_ptr<node_base> refNode;
 
        NodeInstanceType type = NodeInstanceType::MAIN;
 
        voice* owningVoice = nullptr;
 
        node_instance* parentForChildren = nullptr;
    };
 
    class SB_CLASS node_instance : public sbk::core::object
    {
    public:
        ~node_instance();
 
        bool init(const InitNodeInstance& initData);
        bool play();
 
        void update();
 
        bool isPlaying() const
        {
            return m_state == NodeInstanceState::PLAYING || m_state == NodeInstanceState::STOPPING;
        }
 
        std::shared_ptr<node> getReferencingNode() const noexcept { return m_referencingNode; }
        node_instance* get_parent() const noexcept { return m_parent.parent.get(); }
        sc_node_group* getBus() const noexcept { return m_nodeGroup.nodeGroup.get(); }
 
    private:
        void setVolume(float oldVolume, float newVolume);
        void setPitch(float oldPitch, float newPitch);
        void setLowpass(float oldLowpass, float newLowpass);
        void setHighpass(float oldHighpass, float newHighpass);
 
        std::shared_ptr<node> m_referencingNode = nullptr;
        voice* m_owningVoice                    = nullptr;
        NodeInstanceState m_state               = NodeInstanceState::UNINIT;
        NodeGroupInstance m_nodeGroup;
        ParentNodeOwner m_parent;
        ChildrenNodeOwner m_children;
        std::unique_ptr<sc_sound_instance, SC_SOUND_INSTANCE_DELETER> m_soundInstance;
        unsigned int m_numTimesPlayed = 0;
 
        REGISTER_REFLECTION(node_instance, sbk::core::object)
    };
}  // namespace sbk::engine