light_source.hh

#pragma once
 
#include <cgv/math/fvec.h>
#include <cgv/media/color.h> //@<
 
#include "lib_begin.h" //@<
 
namespace cgv { //@<
        namespace media { //@<
                namespace illum { //@<
 
enum LightType { LT_DIRECTIONAL, LT_POINT, LT_SPOT };
 
class CGV_API light_source
{
public: //@<
        typedef color<float,RGB> rgb;
        typedef cgv::math::fvec<float,3> vec3;
protected: //@<
        LightType type;
        bool local_to_eye_coordinates;
        vec3 position;
        rgb emission;
        float ambient_scale;
        float constant_attenuation;
        float linear_attenuation;
        float quadratic_attenuation;
        vec3 spot_direction;
        float spot_exponent;
        float spot_cutoff;
public: //@<
        light_source(LightType _t = LT_DIRECTIONAL);
 
        void set_type(LightType t) { type = t; }
        LightType get_type() const { return type; }
        LightType& ref_type()      { return type; }
 
        void set_local_to_eye(bool l) { local_to_eye_coordinates = l; }
        bool is_local_to_eye() const  { return local_to_eye_coordinates; }
        bool& ref_local_to_eye()      { return local_to_eye_coordinates; }
 
        void set_position(const vec3& loc) { position = loc; }
        const vec3& get_position() const   { return position; }
        vec3& ref_position()   { return position; }
 
        void set_emission(const rgb& c) { emission = c; }
        const rgb& get_emission() const { return emission; }
        rgb& ref_emission() { return emission; }
 
        void set_ambient_scale(float c) { ambient_scale = c; }
        float get_ambient_scale() const { return ambient_scale; }
        float& ref_ambient_scale() { return ambient_scale; }
 
        void set_constant_attenuation(float c) { constant_attenuation = c; }
        float get_constant_attenuation() const { return constant_attenuation; }
        float& ref_constant_attenuation() { return constant_attenuation; }
 
        void set_linear_attenuation(float c) { linear_attenuation = c; }
        float get_linear_attenuation() const { return linear_attenuation; }
        float& ref_linear_attenuation() { return linear_attenuation; }
 
        void set_quadratic_attenuation(float c) { quadratic_attenuation = c; }
        float get_quadratic_attenuation() const { return quadratic_attenuation; }
        float& ref_quadratic_attenuation() { return quadratic_attenuation; }
 
        void set_spot_direction(const vec3& d) { spot_direction = d; }
        const vec3& get_spot_direction() const { return spot_direction; }
        vec3& ref_spot_direction() { return spot_direction; }
 
        void set_spot_exponent(float e) { spot_exponent = e; }
        float get_spot_exponent() const { return spot_exponent; }
        float& ref_spot_exponent() { return spot_exponent; }
 
        void set_spot_cutoff(float c) { spot_cutoff = c; }
        float get_spot_cutoff() const { return spot_cutoff; }
        float& ref_spot_cutoff() { return spot_cutoff; }
 
}; //@<
 
                } //@<
        } //@<
} //@<
 
#include <cgv/type/info/type_name.h>
 
namespace cgv {
        namespace type {
                namespace info {
 
template <>
struct type_name<cgv::media::illum::light_source>
{
        static const char* get_name() { return "light_source"; }
};
                }
        }
}
 
 
#include <cgv/config/lib_end.h>