SceneGraphNode.h

Go to the documentation of this file.

/*
   Copyright (c) 2018 DIVIDE-Studio
   Copyright (c) 2009 Ionut Cava
 
   This file is part of DIVIDE Framework.
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software
   and associated documentation files (the "Software"), to deal in the Software
   without restriction,
   including without limitation the rights to use, copy, modify, merge, publish,
   distribute, sublicense,
   and/or sell copies of the Software, and to permit persons to whom the
   Software is furnished to do so,
   subject to the following conditions:
 
   The above copyright notice and this permission notice shall be included in
   all copies or substantial portions of the Software.
 
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   IMPLIED,
   INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
   PARTICULAR PURPOSE AND NONINFRINGEMENT.
   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
   DAMAGES OR OTHER LIABILITY,
   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
   IN CONNECTION WITH THE SOFTWARE
   OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
   */
 
#pragma once
#ifndef DVD_SCENE_GRAPH_NODE_H_
#define DVD_SCENE_GRAPH_NODE_H_
 
#include "SceneNodeFwd.h"
#include "SGNRelationshipCache.h"
#include "IntersectionRecord.h"
#include "Core/Resources/Headers/Resource.h"
 
#include "ECS/Components/Headers/EditorComponent.h"
#include "ECS/Components/Headers/SGNComponent.h"
 
namespace Divide
{
 
    namespace GFX
    {
        struct MemoryBarrierCommand;
    };
 
    class SceneNode;
    class SceneGraph;
    class SceneState;
    class PropertyWindow;
    class BoundsComponent;
    class TransformSystem;
    class RenderPassManager;
    class RenderPassExecutor;
    class RenderingComponent;
    class TransformComponent;
 
    struct RenderPackage;
    struct NodeCullParams;
    struct CameraSnapshot;
    struct RenderStagePass;
    struct RenderPassCuller;
 
 
    struct SceneNodeHandle
    {
        Handle<SceneNode> _handle = INVALID_HANDLE<SceneNode>;
        SceneNode* _nodePtr = nullptr;
        SceneNodeType _type = SceneNodeType::COUNT;
        DELEGATE<void> _deleter;
    };
 
    template<typename T> requires std::is_base_of_v<SceneNode, T>
    Handle<T> ToHandle( const SceneNodeHandle handle );
 
    template<typename T> requires std::is_base_of_v<SceneNode, T>
    SceneNodeHandle FromHandle( const Handle<T> handle);
 
    struct SceneGraphNodeDescriptor
    {
        Str<64>            _name = "";
        size_t             _instanceCount = 1u;
        SceneNodeHandle    _nodeHandle{};
        U32                _componentMask = 0u;
        U32                _dataFlag = U32_MAX;
        NodeUsageContext   _usageContext = NodeUsageContext::NODE_STATIC;
        bool               _serialize = true;
 
    };
 
    namespace Attorney
    {
        class SceneGraphNodeEditor;
        class SceneGraphNodeComponent;
        class SceneGraphNodeSystem;
        class SceneGraphNodeSceneGraph;
        class SceneGraphNodeRenderPassCuller;
        class SceneGraphNodeRenderPassManager;
        class SceneGraphNodeRelationshipCache;
    };
 
    class SceneGraphNode final : public ECS::Entity<SceneGraphNode>,
        public GUIDWrapper,
        public PlatformContextComponent
    {
        friend class Attorney::SceneGraphNodeEditor;
        friend class Attorney::SceneGraphNodeComponent;
        friend class Attorney::SceneGraphNodeSystem;
        friend class Attorney::SceneGraphNodeSceneGraph;
        friend class Attorney::SceneGraphNodeRenderPassCuller;
        friend class Attorney::SceneGraphNodeRenderPassManager;
        friend class Attorney::SceneGraphNodeRelationshipCache;
 
        public:
 
        enum class Flags : U16
        {
            LOADING = toBit( 1 ),
            HOVERED = toBit( 2 ),
            SELECTED = toBit( 3 ),
            ACTIVE = toBit( 4 ),
            VISIBILITY_LOCKED = toBit( 5 ),
            PARENT_POST_RENDERED = toBit( 6 ),
            SELECTION_LOCKED = toBit( 7 ),
            IS_CONTAINER = toBit( 8 ),
            COUNT = 9
        };
 
        struct ChildContainer
        {
            mutable SharedMutex _lock;
            eastl::fixed_vector<SceneGraphNode*, 32, true> _data;
            std::atomic_uint _count{ 0u };
 
            SceneGraphNode* getChild( const U32 idx )
            {
                assert( idx < _count.load() );
 
                SharedLock<SharedMutex> r_lock( _lock );
                return _data[idx];
            }
        };
 
       public:
        explicit SceneGraphNode( PlatformContext& context, SceneGraph* sceneGraph, const SceneGraphNodeDescriptor& descriptor );
        ~SceneGraphNode() override;
 
        inline SceneGraph* sceneGraph() noexcept
        {
            return _sceneGraph;
        }
 
        SceneGraphNode* addChildNode( const SceneGraphNodeDescriptor& descriptor );
 
        bool removeChildNode( const SceneGraphNode* node, bool recursive = true, bool deleteNode = true );
 
        SceneGraphNode* findChild( U64 nameHash, bool sceneNodeName = false, bool recursive = false ) const;
 
        SceneGraphNode* findChild( I64 GUID, bool sceneNodeGuid = false, bool recursive = false ) const;
 
        bool removeNodesByType( SceneNodeType nodeType );
 
        void setParent( SceneGraphNode* parent, bool defer = false );
 
        bool isChildOfType( U16 typeMask ) const;
 
        bool isRelated( const SceneGraphNode* target ) const;
        bool isRelated( const SceneGraphNode* target, SGNRelationshipCache::RelationshipType relationship ) const;
 
        bool isChild( const SceneGraphNode* target, bool recursive ) const;
 
        ChildContainer& getChildren() noexcept
        {
            return _children;
        }
        const ChildContainer& getChildren() const noexcept
        {
            return _children;
        }
 
        void sceneUpdate( U64 deltaTimeUS, SceneState& sceneState );
 
        void postLoad();
 
        bool intersect( const Ray& intersectionRay, vec2<F32> range, vector<SGNRayResult>& intersections ) const;
 
        void changeUsageContext( const NodeUsageContext& newContext );
 
        void setFlag( Flags flag, bool recursive = true );
        void clearFlag( Flags flag, bool recursive = true );
        [[nodiscard]] bool hasFlag( const Flags flag ) const noexcept;
 
        template <typename T = SceneNode> requires std::is_base_of_v<SceneNode, T>
        T& getNode() noexcept
        {
            return static_cast<T&>(*_node);
        }
 
        FORCE_INLINE SceneNodeHandle handle() const noexcept
        {
            return _descriptor._nodeHandle;
        }
 
        template <typename T = SceneNode>  requires std::is_base_of_v<SceneNode, T>
        const T& getNode() const noexcept
        {
            return static_cast<const T&>(*_node);
        }
 
        template <typename T>
        [[nodiscard]] FORCE_INLINE T* get() const
        {
            return GetComponent<T>();
        }
 
        FORCE_INLINE U32 dataFlag() const noexcept { return _descriptor._dataFlag; }
 
        void SendEvent( ECS::CustomEvent&& event );
 
        template<class E, class... ARGS>
        void SendEvent( ARGS&&... eventArgs ) const
        {
            GetECSEngine().SendEvent<E>( FWD( eventArgs )... );
        }
        template<class E, class... ARGS>
        void SendAndDispatchEvent( ARGS&&... eventArgs ) const
        {
            GetECSEngine().SendEventAndDispatch<E>( FWD( eventArgs )... );
        }
 
        template<class T, class ...P> requires std::is_base_of_v<SGNComponent, T>
        T* AddSGNComponent( P&&... param )
        {
            SGNComponent* comp = static_cast<SGNComponent*>(AddComponent<T>( this, this->context(), FWD( param )... ));
            AddSGNComponentInternal( comp );
            return static_cast<T*>(comp);
        }
 
        template<class T> requires std::is_base_of_v<SGNComponent, T>
        void RemoveSGNComponent()
        {
            RemoveSGNComponentInternal( static_cast<SGNComponent*>(GetComponent<T>()) );
            RemoveComponent<T>();
        }
 
        void AddComponents( U32 componentMask, bool allowDuplicates );
        void RemoveComponents( U32 componentMask );
        [[nodiscard]] bool HasComponents( ComponentType componentType ) const;
        [[nodiscard]] bool HasComponents( U32 componentMask ) const;
        void saveToXML( const ResourcePath& sceneLocation, DELEGATE<void, std::string_view> msgCallback = {} ) const;
        void loadFromXML( const ResourcePath& sceneLocation );
        void loadFromXML( const boost::property_tree::ptree& pt );
 
        protected:
        void updateCollisions( const SceneGraphNode& parentNode, IntersectionContainer& intersections, Mutex& intersectionsLock ) const;
 
      private:
        void processEvents();
        SceneGraphNode* addChildNode( SceneGraphNode* sgn );
 
        FrustumCollision stateCullNode( const NodeCullParams& params, U16 cullFlags, U32 filterMask, const F32 distanceToClosestPointSQ ) const;
        FrustumCollision clippingCullNode( const NodeCullParams& params ) const;
        FrustumCollision frustumCullNode( const NodeCullParams& params, U16 cullFlags, F32& distanceToClosestPointSQ ) const;
        void prepareRender( RenderingComponent& rComp,
                            RenderPackage& pkg,
                            GFX::MemoryBarrierCommand& postDrawMemCmd,
                            const RenderStagePass& renderStagePass,
                            const CameraSnapshot& cameraSnapshot,
                            bool refreshData );
        void onNetworkSend( U32 frameCount ) const;
        void getAllNodes( vector<SceneGraphNode*>& nodeList );
        void processDeleteQueue( vector<size_t>& childList );
        bool saveCache( ByteBuffer& outputBuffer ) const;
        bool loadCache( ByteBuffer& inputBuffer );
        void setTransformDirty( U32 transformMask );
        static void PostLoad( SceneNode* sceneNode, SceneGraphNode* sgn );
        ECS::ECSEngine& GetECSEngine() const noexcept;
        void invalidateRelationshipCache( SceneGraphNode* source = nullptr );
        void setParentInternal();
 
        bool canDraw( const RenderStagePass& stagePass ) const;
 
        void AddSGNComponentInternal( SGNComponent* comp );
        void RemoveSGNComponentInternal( SGNComponent* comp );
 
        template<bool checkInternalNode = false>
        SceneGraphNode* findChildInternal( U64 nameHash, bool recursive = false ) const;
        template<bool checkInternalNode = false>
        SceneGraphNode* findChildInternal( I64 GUID, bool recursive = false ) const;
 
        private:
        SGNRelationshipCache _relationshipCache;
        ChildContainer _children;
 
        // ToDo: Remove this HORRIBLE hack -Ionut
        struct hacks
        {
            vector<EditorComponent*> _editorComponents;
            TransformComponent* _transformComponentCache = nullptr;
            BoundsComponent* _boundsComponentCache = nullptr;
            RenderingComponent* _renderingComponent = nullptr;
        } Hacks;
 
        struct events
        {
            // this should be ample storage PER FRAME for events.
            static constexpr size_t EVENT_QUEUE_SIZE = 128;
            std::array<ECS::CustomEvent, EVENT_QUEUE_SIZE> _events;
            std::array<std::atomic_bool, EVENT_QUEUE_SIZE> _eventsFreeList;
        } Events;
 
        POINTER_R( SceneGraph, sceneGraph, nullptr );
        POINTER_R( SceneNode, node, nullptr );
        POINTER_R( ECS::ComponentManager, compManager, nullptr );
        POINTER_R( SceneGraphNode, parent, nullptr );
        PROPERTY_R( Str<64>, name, "" );
        PROPERTY_R( U64, nameHash, 0u );
        PROPERTY_R( I64, queuedNewParent, -1 );
        PROPERTY_R( U32, componentMask, 0u );
        PROPERTY_R( U32, nodeFlags, 0u );
        PROPERTY_R( U32, instanceCount, 1u );
        PROPERTY_R( bool, serialize, true );
        PROPERTY_R( NodeUsageContext, usageContext, NodeUsageContext::NODE_STATIC );
        //ToDo: make this work in a multi-threaded environment
        mutable I8 _frustPlaneCache = -1;
 
        private:
          const SceneGraphNodeDescriptor _descriptor;
    };
 
    namespace Attorney
    {
        class SceneGraphNodeEditor
        {
            static vector<EditorComponent*>& editorComponents( SceneGraphNode* node ) noexcept
            {
                return node->Hacks._editorComponents;
            }
 
            static const vector<EditorComponent*>& editorComponents( const SceneGraphNode* node ) noexcept
            {
                return node->Hacks._editorComponents;
            }
 
            friend class Divide::PropertyWindow;
        };
 
        class SceneGraphNodeSceneGraph
        {
            static void processEvents( SceneGraphNode* node )
            {
                node->processEvents();
            }
            static void changeParent( SceneGraphNode* node )
            {
                node->setParentInternal();
            }
            static void onNetworkSend( const SceneGraphNode* node, const U32 frameCount )
            {
                node->onNetworkSend( frameCount );
            }
 
            static void getAllNodes( SceneGraphNode* node, vector<SceneGraphNode*>& nodeList )
            {
                node->getAllNodes( nodeList );
            }
 
            static void processDeleteQueue( SceneGraphNode* node, vector<size_t>& childList )
            {
                node->processDeleteQueue( childList );
            }
 
            static bool saveCache( const SceneGraphNode* node, ByteBuffer& outputBuffer )
            {
                return node->saveCache( outputBuffer );
            }
 
            static bool loadCache( SceneGraphNode* node, ByteBuffer& inputBuffer )
            {
                return node->loadCache( inputBuffer );
            }
            static void updateCollisions( const SceneGraphNode& node, const SceneGraphNode& parentNode, IntersectionContainer& intersections, Mutex& intersectionsLock )
            {
                node.updateCollisions( parentNode, intersections, intersectionsLock );
            }
            friend class Divide::SceneGraph;
        };
 
        class SceneGraphNodeSystem
        {
            static void setTransformDirty( SceneGraphNode* node, const U32 transformMask )
            {
                node->setTransformDirty( transformMask );
            }
 
            friend class Divide::TransformSystem;
        };
 
        class SceneGraphNodeComponent
        {
            static void prepareRender( SceneGraphNode* node, RenderingComponent& rComp, RenderPackage& pkg, GFX::MemoryBarrierCommand& postDrawMemCmd, const CameraSnapshot& cameraSnapshot, const RenderStagePass& renderStagePass, const bool refreshData )
            {
                node->prepareRender( rComp, pkg, postDrawMemCmd, renderStagePass, cameraSnapshot, refreshData );
            }
 
            friend class Divide::BoundsComponent;
            friend class Divide::RenderingComponent;
            friend class Divide::TransformComponent;
        };
 
        class SceneGraphNodeRenderPassCuller
        {
            // Returns true if the node should be culled (is not visible for the current stage)
            static FrustumCollision frustumCullNode( const SceneGraphNode* node, const NodeCullParams& params, const U16 cullFlags, F32& distanceToClosestPointSQ )
            {
                return node->frustumCullNode( params, cullFlags, distanceToClosestPointSQ );
            }
            static FrustumCollision stateCullNode( const SceneGraphNode* node, const NodeCullParams& params, const U16 cullFlags, const U32 filterMask, F32 distanceToClosestPointSQ )
            {
                return node->stateCullNode( params, cullFlags, filterMask, distanceToClosestPointSQ );
            }
            static FrustumCollision clippingCullNode( const SceneGraphNode* node, const NodeCullParams& params )
            {
                return node->clippingCullNode( params );
            }
 
            static FrustumCollision frustumCullNode( const SceneGraphNode* node, const NodeCullParams& params, const U16 cullFlags )
            {
                F32 distanceToClosestPointSQ = F32_MAX;
                return frustumCullNode( node, params, cullFlags, distanceToClosestPointSQ );
            }
 
            friend struct Divide::RenderPassCuller;
        };
 
        class SceneGraphNodeRenderPassManager
        {
            static bool canDraw( const SceneGraphNode* node, const RenderStagePass& stagePass )
            {
                return node->canDraw( stagePass );
            }
 
            friend class Divide::RenderPassExecutor;
            friend class Divide::RenderPassManager;
        };
 
 
        class SceneGraphNodeRelationshipCache
        {
            static const SGNRelationshipCache& relationshipCache( const SceneGraphNode* node ) noexcept
            {
                return node->_relationshipCache;
            }
 
            friend class Divide::SGNRelationshipCache;
        };
 
    };  // namespace Attorney
 
 
};  // namespace Divide
#endif //DVD_SCENE_GRAPH_NODE_H_
 
#include "SceneGraphNode.inl"