LightData.hpp

#pragma once
 
#include <Core/Asset/AssetData.hpp>
#include <Core/RaCore.hpp>
#include <Core/Utils/Color.hpp>
#include <Core/Utils/Log.hpp>
 
#include <memory>
#include <string>
#include <vector>
 
namespace Ra {
namespace Core {
namespace Asset {
 
class RA_CORE_API LightData : public AssetData
{
 
  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    enum LightType {
        UNKNOWN           = 1 << 0,
        POINT_LIGHT       = 1 << 1,
        SPOT_LIGHT        = 1 << 2,
        DIRECTIONAL_LIGHT = 1 << 3,
        AREA_LIGHT        = 1 << 4
    };
 
    struct LightAttenuation {
        Scalar constant;
        Scalar linear;
        Scalar quadratic;
        explicit LightAttenuation( Scalar c = 1, Scalar l = 0, Scalar q = 0 ) :
            constant( c ), linear( l ), quadratic( q ) {}
    };
    // TODO : allow to define other attenuation function such
    // \max\left(0,1-\frac{\left|x\right|^2}{r^2}\right)^2
 
    explicit LightData( const std::string& name = "", const LightType& type = UNKNOWN );
 
    LightData( const LightData& data );
 
    ~LightData();
 
    inline void setName( const std::string& name );
 
    inline const Eigen::Matrix<Scalar, 4, 4>& getFrame() const;
 
    inline void setFrame( const Eigen::Matrix<Scalar, 4, 4>& frame );
 
    inline void setLight( const Core::Utils::Color& color,
                          const Eigen::Matrix<Scalar, 3, 1>& direction );
 
    inline void setLight( const Core::Utils::Color& color,
                          const Eigen::Matrix<Scalar, 3, 1>& position,
                          LightAttenuation attenuation );
 
    inline void setLight( const Core::Utils::Color& color,
                          const Eigen::Matrix<Scalar, 3, 1>& position,
                          const Eigen::Matrix<Scalar, 3, 1>& direction,
                          Scalar inAngle,
                          Scalar outAngle,
                          LightAttenuation attenuation );
 
    inline void setLight( const Core::Utils::Color& color,
                          const Eigen::Matrix<Scalar, 3, 1>& cog,
                          const Eigen::Matrix<Scalar, 3, 3>& spatialCov,
                          const Eigen::Matrix<Scalar, 3, 3>& normalCov,
                          LightAttenuation attenuation );
 
    inline LightType getType() const;
 
    inline bool isPointLight() const;
 
    inline bool isSpotLight() const;
 
    inline bool isDirectionalLight() const;
 
    inline bool isAreaLight() const;
 
    inline void displayInfo() const;
 
  protected:
 
    Eigen::Matrix<Scalar, 4, 4> m_frame;
    LightType m_type;
 
    // This part is public so that systems handling lights could access to the data.
    // TODO : make these protected with getters ? Define independant types ?
  public:
    Core::Utils::Color m_color;
 
    struct DirLight {
        Eigen::Matrix<Scalar, 3, 1> direction;
    };
    struct PointLight {
        Eigen::Matrix<Scalar, 3, 1> position;
        LightAttenuation attenuation;
    };
    struct SpotLight {
        Eigen::Matrix<Scalar, 3, 1> position;
        Eigen::Matrix<Scalar, 3, 1> direction;
        Scalar innerAngle;
        Scalar outerAngle;
        LightAttenuation attenuation;
    };
    struct AreaLight {
        // TODO : this representation is usefull but might be improved
        Eigen::Matrix<Scalar, 3, 1> position;
        Eigen::Matrix<Scalar, 3, 3> spatialCovariance;
        Eigen::Matrix<Scalar, 3, 3> normalCovariance;
        LightAttenuation attenuation;
    };
 
    union {
        DirLight m_dirlight;
        PointLight m_pointlight;
        SpotLight m_spotlight;
        AreaLight m_arealight;
    };
};
 
 
inline void LightData::setName( const std::string& name ) {
    m_name = name;
}
 
inline LightData::LightType LightData::getType() const {
    return m_type;
}
 
inline const Eigen::Matrix<Scalar, 4, 4>& LightData::getFrame() const {
    return m_frame;
}
 
inline void LightData::setFrame( const Eigen::Matrix<Scalar, 4, 4>& frame ) {
    m_frame = frame;
}
 
inline void LightData::setLight( const Core::Utils::Color& color,
                                 const Eigen::Matrix<Scalar, 3, 1>& direction ) {
    m_type               = DIRECTIONAL_LIGHT;
    m_color              = color;
    m_dirlight.direction = direction;
}
 
inline void LightData::setLight( const Core::Utils::Color& color,
                                 const Eigen::Matrix<Scalar, 3, 1>& position,
                                 LightAttenuation attenuation ) {
    m_type                   = POINT_LIGHT;
    m_color                  = color;
    m_pointlight.position    = position;
    m_pointlight.attenuation = attenuation;
}
 
inline void LightData::setLight( const Core::Utils::Color& color,
                                 const Eigen::Matrix<Scalar, 3, 1>& position,
                                 const Eigen::Matrix<Scalar, 3, 1>& direction,
                                 Scalar inAngle,
                                 Scalar outAngle,
                                 LightAttenuation attenuation ) {
    m_type                  = SPOT_LIGHT;
    m_color                 = color;
    m_spotlight.position    = position;
    m_spotlight.direction   = direction;
    m_spotlight.innerAngle  = inAngle;
    m_spotlight.outerAngle  = outAngle;
    m_spotlight.attenuation = attenuation;
}
 
inline void LightData::setLight( const Core::Utils::Color& color,
                                 const Eigen::Matrix<Scalar, 3, 1>& cog,
                                 const Eigen::Matrix<Scalar, 3, 3>& spatialCov,
                                 const Eigen::Matrix<Scalar, 3, 3>& normalCov,
                                 LightAttenuation attenuation ) {
    m_type                        = AREA_LIGHT;
    m_color                       = color;
    m_arealight.position          = cog;
    m_arealight.spatialCovariance = spatialCov;
    m_arealight.normalCovariance  = normalCov;
    m_arealight.attenuation       = attenuation;
}
 
inline bool LightData::isPointLight() const {
    return ( m_type == POINT_LIGHT );
}
 
inline bool LightData::isSpotLight() const {
    return ( m_type == SPOT_LIGHT );
}
 
inline bool LightData::isDirectionalLight() const {
    return ( m_type == DIRECTIONAL_LIGHT );
}
 
inline bool LightData::isAreaLight() const {
    return ( m_type == AREA_LIGHT );
}
 
inline void LightData::displayInfo() const {
    using namespace Core::Utils; // log
    std::string type;
    switch ( m_type ) {
    case POINT_LIGHT:
        type = "POINT LIGHT";
        break;
    case SPOT_LIGHT:
        type = "SPOT LIGHT";
        break;
    case DIRECTIONAL_LIGHT:
        type = "DIRECTIONAL LIGHT";
        break;
    case AREA_LIGHT:
        type = "AREA LIGHT";
        break;
    case UNKNOWN:
    default:
        type = "UNKNOWN";
        break;
    }
    LOG( logINFO ) << "======== LIGHT INFO ========";
    LOG( logINFO ) << " Name           : " << m_name;
    LOG( logINFO ) << " Type           : " << type;
}
 
} // namespace Asset
} // namespace Core
} // namespace Ra