SceneGraph.h

Go to the documentation of this file.

#pragma once
#include "OBase.h"
#include "Node.h"
#include "NodeIterator.h"
 
#include "Module/InputModule.h"
 
#include <mutex>
 
namespace dyno
{
    typedef std::list<Node*> NodeList;
 
    typedef std::map<ObjectId, std::shared_ptr<Node>> NodeMap;
 
    class SceneGraph : public OBase
    {
    public:
        typedef NodeIterator Iterator;
 
        ~SceneGraph();
 
        enum EWorkMode
        {
            EDIT_MODE,
            RUNNING_MODE
        };
 
        virtual void advance(float dt);
        virtual void advanceInAsync();        //Take the simulation asynchronously
        virtual void takeOneFrame();
        virtual void updateGraphicsContext();
        virtual void run();
 
        NBoundingBox boundingBox();
 
        void reset();
 
        void reset(std::shared_ptr<Node> node);
 
        void printNodeInfo(bool enabled);
        void printSimulationInfo(bool enabled);
        void printRenderingInfo(bool enabled);
        void printValidationInfo(bool enabled);
 
        bool isNodeInfoPrintable() { return mNodeTiming; }
        bool isSimulationInfoPrintable() { return mSimulationTiming; }
        bool isRenderingInfoPrintable() { return mRenderingTiming; }
        bool isValidationInfoPrintable() { return mValidationInfo; }
 
        virtual bool load(std::string name);
 
        virtual void invoke(unsigned char type, unsigned char key, int x, int y) {};
 
        template<class TNode, class ...Args>
        std::shared_ptr<TNode> createNewScene(Args&& ... args)
        {
            std::shared_ptr<TNode> root = TypeInfo::New<TNode>(std::forward<Args>(args)...);
            //mRoot = root;
 
            addNode(root);
 
            return root;
        }
 
        template<class TNode, class ...Args>
        std::shared_ptr<TNode> addNode(Args&& ... args)
        {
            std::shared_ptr<TNode> node = TypeInfo::New<TNode>(std::forward<Args>(args)...);
 
            return addNode(node);
        }
 
        template<class TNode>
        std::shared_ptr<TNode> addNode(std::shared_ptr<TNode> tNode)
        {
            if (tNode == nullptr ||
                mNodeMap.find(tNode->objectId()) != mNodeMap.end())
                return nullptr;
 
            mNodeMap[tNode->objectId()] = tNode;
            mQueueUpdateRequired = true;
 
            tNode->setSceneGraph(this);
 
            return tNode;
        }
 
        void deleteNode(std::shared_ptr<Node> node);
 
        void propagateNode(std::shared_ptr<Node> node);
 
        bool isEmpty() {
            return mNodeMap.size() == 0;
        }
 
        EWorkMode getWorkMode() { return mWorkMode; }
 
    public:
        static SceneGraph& getInstance();
 
        inline void setTotalTime(float t) { mMaxTime = t; }
        inline float getTotalTime() { return mMaxTime; }
 
        inline void setFrameRate(float frameRate) { mFrameRate = frameRate; }
        inline float getFrameRate() { return mFrameRate; }
        inline float getTimeCostPerFrame() { return mFrameCost; }
        inline float getFrameInterval() { return 1.0f / mFrameRate; }
 
        inline int getFrameNumber() { return mFrameNumber; }
        inline void setFrameNumber(int n) { mFrameNumber = n; }
 
        bool isIntervalAdaptive();
        void setAdaptiveInterval(bool adaptive);
 
        void setAsynchronousSimulation(bool b);
 
        void setGravity(Vec3f g);
        Vec3f getGravity();
 
        Vec3f getLowerBound();
        Vec3f getUpperBound();
 
        void setLowerBound(Vec3f lowerBound);
        void setUpperBound(Vec3f upperBound);
 
        inline Iterator begin() {
 
            updateExecutionQueue();
 
            return NodeIterator(mNodeQueue, mNodeMap);
        }
 
        inline Iterator end() { return NodeIterator(); }

        void markQueueUpdateRequired();
 
    public:
        void onMouseEvent(PMouseEvent event);
 
        void onMouseEvent(PMouseEvent event, std::shared_ptr<Node> node);
 
        void onKeyboardEvent(PKeyboardEvent event);

        void traverseBackward(Action* act);
 
        template<class Act, class ... Args>
        void traverseBackward(Args&& ... args) {
            Act action(std::forward<Args>(args)...);
            traverseBackward(&action);
        }

        void traverseForward(Action* act);
 
        template<class Act, class ... Args>
        void traverseForward(Args&& ... args) {
            Act action(std::forward<Args>(args)...);
            traverseForward(&action);
        }

        void traverseForward(std::shared_ptr<Node> node, Action* act);
 
        template<class Act, class ... Args>
        void traverseForward(std::shared_ptr<Node> node, Args&& ... args) {
            Act action(std::forward<Args>(args)...);
            traverseForward(node, &action);
        }

        void traverseForwardWithAutoSync(std::shared_ptr<Node> node, Action* act);
 
        template<class Act, class ... Args>
        void traverseForwardWithAutoSync(std::shared_ptr<Node> node, Args&& ... args) {
            Act action(std::forward<Args>(args)...);
            traverseForwardWithAutoSync(node, &action);
        }
 
    protected:
        //void retriveExecutionQueue(std::list<Node*>& nQueue);
 
        void updateExecutionQueue();
 
    public:
        SceneGraph()
            : mElapsedTime(0)
            , mMaxTime(0)
            , mFrameRate(25)
            , mFrameNumber(0)
            , mFrameCost(0)
            , mLowerBound(-10, 0, -10)
            , mUpperBound(10, 10, 10)
        {
            //mRoot = std::make_shared<Node>();
            mGravity = Vec3f(0.0f, -9.8f, 0.0f);
        };

        SceneGraph(const SceneGraph&) = delete;
        SceneGraph& operator=(const SceneGraph&) = delete;
 
    private:
        bool mAdvativeInterval = true;
 
        float mElapsedTime;
        float mMaxTime;
        float mFrameRate;
        float mFrameCost;
 
        int mFrameNumber;
 
        Vec3f mGravity;
 
        Vec3f mLowerBound;
        Vec3f mUpperBound;
 
    private:
        //std::shared_ptr<Node> mRoot = nullptr;
 
        bool mQueueUpdateRequired = false;
        bool mAsynchronousSimulation = false;
 
        NodeMap mNodeMap;
 
        NodeList mNodeQueue;
 
        bool mNodeTiming = false;
        bool mSimulationTiming = false;
        bool mRenderingTiming = false;
 
        bool mValidationInfo = false;
 
        EWorkMode mWorkMode = EDIT_MODE;
    };
 
}