PipelineSharedPtr.h

#pragma once
 
// Standard.
#include <memory>
 
namespace ne {
    class Pipeline;
    class Material;
    class ComputeShaderInterface;
 
    class PipelineSharedPtr {
    public:
        explicit PipelineSharedPtr(std::shared_ptr<Pipeline> pPipeline, Material* pMaterialThatUsesPipeline);
 
        explicit PipelineSharedPtr(
            std::shared_ptr<Pipeline> pPipeline, ComputeShaderInterface* pComputeShaderThatUsesPipeline);
 
        PipelineSharedPtr() = default;
 
        ~PipelineSharedPtr();
 
        PipelineSharedPtr(const PipelineSharedPtr&) = delete;
        PipelineSharedPtr& operator=(const PipelineSharedPtr&) = delete;
 
        PipelineSharedPtr(PipelineSharedPtr&& other) noexcept;
 
        PipelineSharedPtr& operator=(PipelineSharedPtr&& other) noexcept;
 
        bool isInitialized() const;
 
        void clear();
 
        void set(std::shared_ptr<Pipeline> pPipeline, Material* pMaterialThatUsesPipeline);
 
        inline Pipeline* getPipeline() const { return pPipeline.get(); }
 
        Pipeline* operator->() const;
 
    private:
        void clearPointerAndNotifyPipeline();
 
        void initialize(std::shared_ptr<Pipeline> pPipeline, Material* pMaterialThatUsesPipeline);
 
        void initialize(
            std::shared_ptr<Pipeline> pPipeline, ComputeShaderInterface* pComputeShaderThatUsesPipeline);
 
        std::shared_ptr<Pipeline> pPipeline = nullptr;
 
        Material* pMaterialThatUsesPipeline = nullptr;
 
        ComputeShaderInterface* pComputeShaderThatUsesPipeline = nullptr;
    };
}