RenderingNode.hpp

#pragma once
#include <Dataflow/RaDataflow.hpp>
 
#include <Dataflow/Core/Node.hpp>
 
#include <Core/Utils/Color.hpp>
#include <Engine/Data/Texture.hpp>
#include <Engine/Data/ViewingParameters.hpp>
#include <Engine/Rendering/RenderObject.hpp>
#include <Engine/Scene/Light.hpp>
 
namespace Ra::Engine::Data {
class ShaderProgramManager;
}
 
namespace Ra {
namespace Dataflow {
namespace Rendering {
namespace Nodes {
 
using RenderObjectType = std::shared_ptr<Ra::Engine::Rendering::RenderObject>;
using LightType        = const Ra::Engine::Scene::Light*;
using CameraType       = Ra::Engine::Data::ViewingParameters;
using ColorType        = Ra::Core::Utils::Color;
using TextureType      = Ra::Engine::Data::Texture;
 
class RA_DATAFLOW_API RenderingNode : public Dataflow::Core::Node,
                                      public Ra::Core::Utils::IndexedObject
{
  public:
    using Dataflow::Core::Node::Node;
 
    virtual void resize( uint32_t width, uint32_t height ) = 0;
 
    virtual void buildRenderTechnique( const Ra::Engine::Rendering::RenderObject*,
                                       Ra::Engine::Rendering::RenderTechnique& ) const {};
 
    virtual bool hasRenderTechnique() { return false; }
 
    void setShaderProgramManager( Ra::Engine::Data::ShaderProgramManager* shaderMngr ) {
        m_shaderMngr = shaderMngr;
    }
 
    static const std::string node_typename() { return "RenderingNode"; }
 
  protected:
    void toJsonInternal( nlohmann::json& ) const override {}
    void fromJsonInternal( const nlohmann::json& ) override {}
 
    Ra::Engine::Data::ShaderProgramManager* m_shaderMngr;
};
 
} // namespace Nodes
} // namespace Rendering
} // namespace Dataflow
} // namespace Ra