Node.h

Go to the documentation of this file.

#pragma once
#include "OBase.h"
#include "Field.h"
#include "Platform.h"
#include "DeclarePort.h"
#include "NodePort.h"
 
#include "Module/TopologyModule.h"
#include "Module/TopologyMapping.h"
#include "Module/AnimationPipeline.h"
#include "Module/GraphicsPipeline.h"
 
namespace dyno
{
    class Action;
    class SceneGraph;
 
    struct NBoundingBox
    {
        NBoundingBox() {
            lower = Vec3f(-1);
            upper = Vec3f(1);
        }
 
        NBoundingBox(Vec3f lo, Vec3f hi) {
            lower = lo;
            upper = hi;
        }
 
        Vec3f lower = Vec3f(-1);
        Vec3f upper = Vec3f(1);
 
        NBoundingBox& join(const NBoundingBox box) {
            lower = lower.minimum(box.lower);
            upper = upper.maximum(box.upper);
 
            return *this;
        }
 
        NBoundingBox& intersect(const NBoundingBox box) {
            lower = lower.maximum(box.lower);
            upper = upper.minimum(box.upper);
 
            return *this;
        }
 
        float maxLength() {
            return std::max(upper[0] - lower[0], std::max(upper[1] - lower[1], upper[2] - lower[2]));
        }
    };
 
    class Node : public OBase
    {
    public:
 
        template<class T>
        using SPtr = std::shared_ptr<T>;
 
        Node();
        ~Node() override;
 
        void setName(std::string name);
        std::string getName() override;
 
        virtual std::string getNodeType();
 
        bool isAutoSync();
        
        bool isAutoHidden();

        void setAutoSync(bool con);
 
        void setAutoHidden(bool con);

        virtual bool isActive();

        virtual void setActive(bool active);

        virtual bool isVisible();

        virtual void setVisible(bool visible);

        virtual Real getDt();
 
        void setDt(Real dt);
 
        void setSceneGraph(SceneGraph* scn);
        SceneGraph* getSceneGraph();
 
        std::vector<NodePort*>& getImportNodes() { return mImportNodes; }
        std::vector<NodePort*>& getExportNodes() { return mExportNodes; }

        bool addModule(std::shared_ptr<Module> module);
        bool deleteModule(std::shared_ptr<Module> module);

        template<class TModule>
        bool addModule(std::shared_ptr<TModule> tModule)
        {
            std::shared_ptr<Module> module = std::dynamic_pointer_cast<Module>(tModule);
            return addModule(module);
        }
        template<class TModule>
        bool deleteModule(std::shared_ptr<TModule> tModule)
        {
            std::shared_ptr<Module> module = std::dynamic_pointer_cast<Module>(tModule);
            return deleteModule(module);
        }
 
        std::list<std::shared_ptr<Module>>& getModuleList() { return mModuleList; }
 
        bool hasModule(std::string name);

        std::shared_ptr<Module> getModule(std::string name);

        template<class TModule>
        std::shared_ptr<TModule> getModule()
        {
            TModule* tmp = new TModule;
            std::shared_ptr<Module> base;
            std::list<std::shared_ptr<Module>>::iterator iter;
            for (iter = mModuleList.begin(); iter != mModuleList.end(); iter++)
            {
                if ((*iter)->getClassInfo() == tmp->getClassInfo())
                {
                    base = *iter;
                    break;
                }
            }
            delete tmp;
            return TypeInfo::cast<TModule>(base);
        }
 
        template<class TModule>
        std::shared_ptr<TModule> getModule(std::string name)
        {
            std::shared_ptr<Module> base = getModule(name);
 
            return TypeInfo::cast<TModule>(base);
        }
 
        std::shared_ptr<Pipeline>               resetPipeline();
        std::shared_ptr<AnimationPipeline>      animationPipeline();
        std::shared_ptr<GraphicsPipeline>       graphicsPipeline();
 
        template<class TModule>
        std::shared_ptr<TModule> addModule(std::string name)
        {
            if (hasModule(name))
            {
                Log::sendMessage(Log::Error, std::string("Module ") + name + std::string(" already exists!"));
                return nullptr;
            }
            std::shared_ptr<TModule> module = std::make_shared<TModule>();
            module->setName(name);
            this->addModule(module);
 
            return module;
        }
        
        void update();
 
        void updateGraphicsContext();
 
        void reset();
 
        virtual NBoundingBox boundingBox();
//      /**
//       * @brief Depth-first tree traversal
//       *
//       * @param act   Operation on the node
//       */
//      void traverseBottomUp(Action* act);
//      template<class Act, class ... Args>
//      void traverseBottomUp(Args&& ... args) {
//          Act action(std::forward<Args>(args)...);
//          doTraverseBottomUp(&action);
//      }
// 
//      /**
//       * @brief Breadth-first tree traversal
//       *
//       * @param act   Operation on the node
//       */
//      void traverseTopDown(Action* act);
//      template<class Act, class ... Args>
//      void traverseTopDown(Args&& ... args) {
//          Act action(std::forward<Args>(args)...);
//          doTraverseTopDown(&action);
//      }
        
        bool connect(NodePort* nPort);
        bool disconnect(NodePort* nPort);

        bool attachField(FBase* field, std::string name, std::string desc, bool autoDestroy = true) override;
 
        std::vector<NodePort*>& getAllNodePorts() { return mImportNodes; }
 
        uint sizeOfNodePorts() { return (uint)mImportNodes.size(); }
 
        uint sizeOfImportNodes() const;
        uint sizeOfExportNodes() const { return (uint)mExportNodes.size(); }
 
        void setForceUpdate(bool b);
 
    protected:
//      virtual void doTraverseBottomUp(Action* act);
//      virtual void doTraverseTopDown(Action* act);
 
        bool appendExportNode(NodePort* nodePort);
        bool removeExportNode(NodePort* nodePort);
 
        virtual void preUpdateStates();
        virtual void updateStates();
        virtual void postUpdateStates();
 
        virtual void updateTopology();
 
        virtual void resetStates();
 
        virtual bool validateInputs();
 
        virtual bool requireUpdate();

        void tick();
 
    private:
        bool addNodePort(NodePort* port);
 
        bool addToModuleList(std::shared_ptr<Module> module);
        bool deleteFromModuleList(std::shared_ptr<Module> module);
 
    public:
        std::string m_node_name;
 
        DEF_VAR_STATE(Real, ElapsedTime, 0, "Elapsed Time");
        DEF_VAR_STATE(Real, TimeStep, Real(0.033), "Time step size");
 
        DEF_VAR_STATE(uint, FrameNumber, 0, "Frame number");
 
    private:
        bool mAutoSync = false;
 
        bool mPhysicsEnabled = true;
 
        bool mRenderingEnabled = true;
 
        bool mExported = true;
 
        bool mForceUpdate = true;
 
        bool mAutoHidden = false;

        Real mDt;

        std::list<std::shared_ptr<Module>> mModuleList;

        std::shared_ptr<Pipeline>   mResetPipeline;
        std::shared_ptr<AnimationPipeline> mAnimationPipeline;
        std::shared_ptr<GraphicsPipeline> mGraphicsPipeline;
 
//      //std::shared_ptr<DeviceContext> m_context;
// 
        std::vector<NodePort*> mImportNodes;
 
        std::vector<NodePort*> mExportNodes;
 
        SceneGraph* mSceneGraph = nullptr;
 
        friend class NodePort;
    };
}