Module.h

Go to the documentation of this file.

#pragma once
#include "Platform.h"
#include <memory>
#include <vector>
#include <cassert>
#include <iostream>
#include "OBase.h"
#include "Log.h"
#include "DataTypes.h"
#include "DeclareEnum.h"
#include "DeclareField.h"
#include "ModulePort.h"
#include "FCallbackFunc.h"
#include "FieldTypes.h"
 
namespace dyno
{
    class SceneGraph;
    class Node;
 
    class Module : public OBase
    {
    public:
        Module(std::string name = "default");
 
        ~Module(void) override;
 
        bool initialize();
 
        void update();
 
        void setName(std::string name);
 
        std::string getName() override;

        virtual void setParentNode(Node* node);

        Node* getParentNode();

        SceneGraph* getSceneGraph();
 
        bool isInitialized();
 
        virtual std::string getModuleType() { return "Default"; }
 
        bool attachField(FBase* field, std::string name, std::string desc, bool autoDestroy = true) override;

        bool isInputComplete();
        bool isOutputCompete();
 
        bool connect(ModulePort* nPort);
        bool disconnect(ModulePort* nPort);
 
        virtual bool allowImported() { return this->captionVisible(); }
        virtual bool allowExported() { return this->captionVisible(); }
        
        std::vector<ModulePort*>& getImportModules() { return mImportModules; }
        std::vector<ModulePort*>& getExportModules() { return mExportModules; }
 
    public:
        DEF_VAR(bool, ForceUpdate, false, "");

        void setUpdateAlways(bool b);
 
        //protected:
            //TODO: remove this step
        virtual bool initializeImpl();
        virtual void updateImpl();
 
    protected:
        virtual void preprocess() {};
 
        virtual void postprocess() {};
 
        virtual bool validateInputs();
        virtual bool validateOutputs();
 
        virtual bool requireUpdate();

        virtual void updateStarted();
        virtual void updateEnded();
 
        bool appendExportModule(ModulePort* nodePort);
        bool removeExportModule(ModulePort* nodePort);
 
    private:
        bool addModulePort(ModulePort* port);
 
    private:
        Node* m_node;
        std::string m_module_name;
        bool m_initialized;
 
        std::vector<ModulePort*> mImportModules;
 
        std::vector<ModulePort*> mExportModules;

    public:
        inline MultipleModulePort<Module>* importModules() { return &mAncestors; }
    private:
        MultipleModulePort<Module> mAncestors = MultipleModulePort<Module>(
            std::string("Ancestor") + std::string("(s)"),
            "Ancestors",
            this);
 
        friend class ModulePort;
    };
}