Pipeline.h

Go to the documentation of this file.

#pragma once
#include "Module.h"
 
namespace dyno
{
    class Node;
 
    class Pipeline : public Module
    {
    public:
        Pipeline(Node* node);
        virtual ~Pipeline();
 
        uint sizeOfDynamicModules();
        uint sizeOfPersistentModules();
 
        void pushModule(std::shared_ptr<Module> m);
 
        void popModule(std::shared_ptr<Module> m);
 
        template<class TModule>
        std::shared_ptr<TModule> createModule()
        {
            std::shared_ptr<TModule> m = std::make_shared<TModule>();
            this->pushModule(m);
 
            return m;
        }

        template<class TModule>
        std::shared_ptr<TModule> findFirstModule()
        {
            auto& modules = this->activeModules();
            for (auto m : modules)
            {
                auto child = TypeInfo::cast<TModule>(m);
                if (child != nullptr)
                    return child;
            }
            return nullptr;
        }
        
        // clear pipeline and module
        void clear();
 
        void pushPersistentModule(std::shared_ptr<Module> m);
 
        std::list<std::shared_ptr<Module>>& activeModules() {
            if (mModuleUpdated) {
                reconstructPipeline();
            }
 
            return mModuleList;
        }
 
        std::map<ObjectId, std::shared_ptr<Module>>& allModules()
        {
            return mModuleMap;
        }
 
        void enable();
        void disable();
 
        void updateExecutionQueue();
 
        void forceUpdate();

        FBase* promoteOutputToNode(FBase* base);

        void demoteOutputFromNode(FBase* base);
 
    protected:
        void preprocess() final;
        void updateImpl() override;
 
        bool requireUpdate() final;
 
        virtual bool printDebugInfo();
 
    private:
        void reconstructPipeline();
 
    private:
        bool mModuleUpdated = false;
        bool mUpdateEnabled = true;
 
        std::map<ObjectId, std::shared_ptr<Module>> mModuleMap;
        std::list<std::shared_ptr<Module>>  mModuleList;
 
        std::list<std::shared_ptr<Module>> mPersistentModule;
 
        bool mTiming = false;
    };
}