GLTF_SceneData.h

Go to the documentation of this file.

#ifndef __GLTF_SceneData_h__
#define __GLTF_SceneData_h__

#include "GLTFZ_API.h"
#include "GLTF_Types.h"

#include <GA/GA_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_Map.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Quaternion.h>
#include <UT/UT_RingBuffer.h>
#include <UT/UT_Vector3.h>

class GLTFZ_API GLTF_SceneData
{
public:
    struct Node
    {
        GLTF_Index                  myId;
        bool                        myIsRoot;
        GLTF_Index                  myParent;

        UT_Array<GLTF_Index>        myChildren;

        GA_Offset                   myOffset;

        bool                        myHasMatrix;
        UT_Matrix4F                 myMatrix;

        bool                        myHasTranslate;
        UT_Vector3F                 myTranslate;

        bool                        myHasRotation;
        UT_Quaternion               myRotation;

        bool                        myHasScale;
        UT_Vector3F                 myScale;

        // Expects a pointer to 16 floats (4x4 matrix)
        void setMatrix(const float* mat);

        // Expects a pointer to 3 floats
        void setTranslate(const float* trans);

        // Expects a pointer to 4 floats (quaternion)
        void setRotation(const float* rot);

        // Expects a pointer to 3 floats
        void setScale(const float* scale);
    };

public:
    void setScene(const GLTF_Index id) { mySceneId = id; }
    void addRoot(const GLTF_Index id);
    void addChildNode(const GLTF_Index parent_id, const GLTF_Index id);
    Node& getNode(GLTF_Index id) { return myNodes[id]; }
    const Node& getNode(GLTF_Index id) const { return myNodes.at(id); }

    void clear()
    { 
        myRootNodes.clear();
        myNodes.clear();
    }

private:
    GLTF_Index                      mySceneId;
    UT_Array<GLTF_Index>            myRootNodes;
    UT_Map<GLTF_Index, Node>        myNodes;

public:

    class ConstIterator
    {
    public:
       ConstIterator(const GLTF_SceneData* scene)
            : myScene(scene)
            , myCurrentVisitingNode(0)
        {
            if (!myScene)
                return;

            if (myScene->myRootNodes.entries() == 0)
            {
                myScene = nullptr;
                return;
            }

            myCurrentVisitingNode = myScene->myRootNodes[0];
            initQueue();
        }

        const Node&     operator*() const
        {
            return myScene->myNodes.at(myCurrentVisitingNode);
        }

        const Node*     operator->() const
        {
            return &(**this);
        }

        ConstIterator&  operator++()
        {
            advance();
            return *this;
        }

        bool            operator==(const ConstIterator& other) const
        {
            return myScene == other.myScene &&
                   myCurrentVisitingNode == other.myCurrentVisitingNode;
        }

        bool            operator!=(const ConstIterator& other) const
        {
            return !(*this == other);
        }

    private:
        void            initQueue()
        {
            const GLTF_SceneData::Node& root =
                    myScene->myNodes.at(myCurrentVisitingNode);
            for (exint i = 0; i < root.myChildren.entries(); ++i)
                prepareSceneGraphDFS(root.myChildren[i]);

            for (exint i = 1; i < myScene->myRootNodes.entries(); ++i)
                prepareSceneGraphDFS(myScene->myRootNodes[i]);
        }

        void            prepareSceneGraphDFS(const GLTF_Index node_id)
        {
            myVisitOrder.push(node_id);
            const GLTF_SceneData::Node& node =
                    myScene->myNodes.at(node_id);
            for (exint i = 0; i < node.myChildren.entries(); ++i)
                prepareSceneGraphDFS(node.myChildren[i]);
        }

        void            advance()
        {
            // If no scene, that means that we are the end() iterator
            if (!myScene)
                return;

            if (myVisitOrder.size() > 0)
            {
                myCurrentVisitingNode = myVisitOrder.popFirst();
            }
            else
            {
                myScene = nullptr;
                myCurrentVisitingNode = 0;
                myVisitOrder.clear();
            }
        }

        const GLTF_SceneData*       myScene;
        GLTF_Index                  myCurrentVisitingNode;
        UT_RingBuffer<GLTF_Index>   myVisitOrder;
    };

    friend class ConstIterator;

    ConstIterator begin() const { return ConstIterator(this); }
    ConstIterator end() const { return ConstIterator(nullptr); }
};

#endif // __GLTF_SceneData_h__