foray_scene.hpp

Go to the documentation of this file.

#pragma once
#include "../as/foray_tlas.hpp"
#include "../osi/foray_osi_declares.hpp"
#include "foray_callbackdispatcher.hpp"
#include "foray_node.hpp"
#include "foray_registry.hpp"
#include "foray_scene_declares.hpp"
#include "foray_scenedrawing.hpp"
 
namespace foray::scene {
 
    class Scene : public Registry, public CallbackDispatcher
    {
      public:
        friend Node;
 
        explicit Scene(core::Context* context);
 
        Node* MakeNode(Node* parent = nullptr);
 
        void Update(const base::FrameRenderInfo& renderInfo, base::CmdBufferIndex index);
        void Update(const base::FrameRenderInfo& renderInfo, VkCommandBuffer cmdBuffer);
        void Draw(const base::FrameRenderInfo& renderInfo, VkPipelineLayout pipelineLayout, base::CmdBufferIndex index = base::PRIMARY_COMMAND_BUFFER);
        void Draw(const base::FrameRenderInfo& renderInfo, VkPipelineLayout pipelineLayout, VkCommandBuffer cmdBuffer);
        void HandleEvent(const osi::Event* event);
 
        virtual void Destroy() override;
 
        inline virtual ~Scene() { Destroy(); }
 
        FORAY_PROPERTY_R(NodeBuffer)
        FORAY_PROPERTY_R(RootNodes)
        FORAY_PROPERTY_V(Context)
 
        template <typename TComponent>
        int32_t FindComponents(std::vector<TComponent*>& outcomponents);
 
        template <typename TComponent>
        int32_t FindNodesWithComponent(std::vector<Node*>& outnodes);
 
        void UseDefaultCamera(bool invertAll = false);
        void UpdateTlasManager();        
        void UpdateLightManager();
 
      protected:
        core::Context* mContext;
        std::vector<std::unique_ptr<Node>> mNodeBuffer;
 
        std::vector<Node*> mRootNodes;
 
        void InitDefaultGlobals();
    };
 
    template <typename TComponent>
    int32_t Scene::FindComponents(std::vector<TComponent*>& outnodes)
    {
        int32_t found = 0;
        for(Node* rootnode : mRootNodes)
        {
            found += rootnode->FindComponentsRecursive<TComponent>(outnodes);
        }
        return found;
    }
 
    template <typename TComponent>
    int32_t Scene::FindNodesWithComponent(std::vector<Node*>& outnodes)
    {
        int32_t found = 0;
        for(Node* rootnode : mRootNodes)
        {
            if(rootnode->HasComponent<TComponent>())
            {
                found++;
                outnodes.push_back(rootnode);
            }
            found += rootnode->FindChildrenWithComponent<TComponent>(outnodes);
        }
        return found;
    }
}  // namespace foray::scene