Light.hpp

#pragma once
 
#include <Core/Utils/Color.hpp>
#include <Engine/RaEngine.hpp>
#include <Engine/Scene/Component.hpp>
 
#include <Engine/Data/RenderParameters.hpp>
 
namespace Ra {
namespace Engine {
namespace Scene {
 
class Entity;
 
// Radium-V2 : this class could totally be renamed LightComponent and get a Light struct embedded.
// Thoughts are welcome !
class RA_ENGINE_API Light : public Component
{
  public:
    enum LightType : int { DIRECTIONAL = 0, POINT, SPOT, POLYGONAL };
 
    struct Attenuation {
        Scalar constant { 1 };
        Scalar linear { 0 };
        Scalar quadratic { 0 };
        Attenuation() = default;
    };
 
  public:
    Light( Entity* entity, const LightType& type, const std::string& name = "light" );
    ~Light() override = default;
 
    inline const Core::Utils::Color& getColor() const { return m_color; }
    inline void setColor( const Core::Utils::Color& color );
 
    virtual void setDirection( const Eigen::Matrix<Scalar, 3, 1>& /*dir*/ ) {}
    virtual void setPosition( const Eigen::Matrix<Scalar, 3, 1>& /*pos*/ ) {}
    // ...
 
    inline const LightType& getType() const { return m_type; }
 
    void getRenderParameters( Data::RenderParameters& params ) const;
 
    const Data::RenderParameters& getRenderParameters() const { return m_params; }
 
    Data::RenderParameters& getRenderParameters() { return m_params; }
    virtual std::string getShaderInclude() const;
 
    void initialize() override;
 
  private:
    Data::RenderParameters m_params;
    Core::Utils::Color m_color = Core::Utils::Color::White();
    LightType m_type { LightType::DIRECTIONAL };
};
 
// ---------------------------------------------------------------------------------------------
// ---- inline methods implementation
 
inline void Light::setColor( const Core::Utils::Color& color ) {
    m_color = color;
    m_params.setVariable( "light.color", m_color );
}
 
} // namespace Scene
} // namespace Engine
} // namespace Ra