node_instance.h

#pragma once
 
#include "sound_bakery/core/core_include.h"
#include "sound_bakery/system.h"
 
namespace SB::Engine
{
    class Bus;
    class Container;
    class Node;
    class NodeBase;
    class NodeInstance;
    class Sound;
    class SoundContainer;
    class Voice;
 
    struct SB_CLASS NodeGroupInstance
    {
        bool initNodeGroup(const NodeBase& 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 NodeBase& thisNode, Voice* owningVoice);
 
        std::shared_ptr<NodeInstance> parent;
    };
 
    struct SB_CLASS ChildrenNodeOwner
    {
        bool createChildren(const NodeBase& thisNode,
                            Voice* owningVoice,
                            NodeInstance* thisNodeInstance,
                            unsigned int numTimesPlayed);
 
        std::vector<std::shared_ptr<NodeInstance>> childrenNodes;
    };
 
    enum class NodeInstanceType
    {
        CHILD,
        BUS,
        MAIN
    };
 
    enum class NodeInstanceState
    {
        UNINIT,
 
        STOPPED,
        STOPPING,
        PAUSED,
        VIRTUAL,
 
        PLAYING
    };
 
    struct SB_CLASS InitNodeInstance
    {
        SB::Core::DatabasePtr<NodeBase> refNode;
 
        NodeInstanceType type = NodeInstanceType::MAIN;
 
        Voice* owningVoice = nullptr;
 
        NodeInstance* parentForChildren = nullptr;
    };
 
    class SB_CLASS NodeInstance : public SB::Core::Object
    {
    public:
        ~NodeInstance();
 
        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; }
        NodeInstance* getParent() 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(NodeInstance, SB::Core::Object)
    };
}  // namespace SB::Engine