object.h

#pragma once
 
#include "sound_bakery/pch.h"
#include "sound_bakery/util/macros.h"
 
namespace SB::Engine
{
    class System;
}
 
namespace SB::Core
{
    class SB_CLASS ObjectUtilities
    {
    public:
        SB::Engine::System* getSystem() const;
        sc_system* getChef() const;
        ma_engine* getMini() const;
 
        std::string m_debugName;
 
        REGISTER_REFLECTION(ObjectUtilities)
    };
 
    class SB_CLASS Object : public ObjectUtilities
    {
        REGISTER_REFLECTION(Object, ObjectUtilities)
 
    public:
        Object() = default;
        virtual ~Object();
 
        NOT_COPYABLE(Object)
 
        
        template <typename T>
        T* tryConvertObject() noexcept
        {
            if (getType().is_derived_from(T::type()) || getType() == T::type())
            {
                return SB::Reflection::cast<T*, Object*>(this);
            }
            return nullptr;
        }
 
        template <typename T>
        const T* tryConvertObject() const noexcept
        {
            if (getType().is_derived_from(T::type()) || getType() == T::type())
            {
                return SB::Reflection::cast<const T*, const Object*>(this);
            }
            return nullptr;
        }
 
        rttr::type getType() const
        {
            if (this == nullptr)
            {
                return rttr::type::get<void>();
            }
 
            if (!m_type.has_value())
            {
                m_type = get_type();
            }
 
            assert(m_type.has_value());
            assert(m_type.value().is_valid());
 
            return m_type.value();
        }
 
    private:
        mutable std::optional<rttr::type> m_type = std::nullopt;
    };
}  // namespace SB::Core