source/materials/light.cpp

   1 #include <stdexcept>
   2 #include <msp/strings/format.h>
   3 #include "light.h"
   4 #include "matrix.h"
   5 #include "misc.h"
   6 #include "programdata.h"
   7
   8 using namespace std;
   9
  10 namespace Msp {
  11 namespace GL {
  12
  13 Light::Light():
  14         color(1),
  15         position(0, 0, 1, 0),
  16         spot_dir(0, 0, -1),
  17         spot_exp(0),
  18         spot_cutoff(Geometry::Angle<float>::straight())
  19 {
  20         attenuation[0] = 1;
  21         attenuation[1] = 0;
  22         attenuation[2] = 0;
  23 }
  24
  25 void Light::update_matrix()
  26 {
  27         Vector3 up_dir;
  28         if(20*abs(direction.z)>abs(direction.x)+abs(direction.y))
  29                 up_dir.y = 1;
  30         else
  31                 up_dir.z = 1;
  32         Vector3 right_dir = normalize(cross(direction, up_dir));
  33
  34         Vector4 columns[4];
  35         columns[0] = compose(right_dir, 0.0f);
  36         columns[1] = compose(cross(right_dir, direction), 0.0f);
  37         columns[2] = compose(-direction, 0.0f);
  38         columns[3] = position;
  39         matrix = Matrix::from_columns(columns);
  40 }
  41
  42 void Light::set_color(const Color &c)
  43 {
  44         color = c;
  45 }
  46
  47 void Light::set_matrix(const Matrix &m)
  48 {
  49         Placeable::set_matrix(m);
  50         position = matrix.column(3);
  51         spot_dir = normalize(-matrix.column(2).slice<3>(0));
  52         direction = (position.w ? spot_dir : normalize(-position.slice<3>(0)));
  53         update_matrix();
  54 }
  55
  56 void Light::set_position(const Vector4 &p)
  57 {
  58         position = p;
  59         if(!position.w)
  60                 direction = normalize(-position.slice<3>(0));
  61         update_matrix();
  62 }
  63
  64 void Light::set_spot_direction(const Vector3 &d)
  65 {
  66         spot_dir = normalize(d);
  67         if(position.w)
  68                 direction = spot_dir;
  69         update_matrix();
  70 }
  71
  72 void Light::set_spot_exponent(float e)
  73 {
  74         if(e<0)
  75                 throw invalid_argument("Light::set_spot_exponent");
  76
  77         spot_exp = e;
  78 }
  79
  80 void Light::set_spot_cutoff(const Geometry::Angle<float> &c)
  81 {
  82         if(c<Geometry::Angle<float>::zero() || (c>Geometry::Angle<float>::right() && c!=Geometry::Angle<float>::straight()))
  83                 throw invalid_argument("Light::set_spot_cutoff");
  84
  85         spot_cutoff = c;
  86 }
  87
  88 void Light::disable_spot_cutoff()
  89 {
  90         set_spot_cutoff(Geometry::Angle<float>::straight());
  91 }
  92
  93 void Light::set_attenuation(float c, float l, float q)
  94 {
  95         attenuation[0] = c;
  96         attenuation[1] = l;
  97         attenuation[2] = q;
  98 }
  99
 100 void Light::update_shader_data(ProgramData &shdata, const Matrix &view_matrix, unsigned i) const
 101 {
 102         string base = format("light_sources[%d]", i);
 103         shdata.uniform(base+".position", view_matrix*position);
 104         shdata.uniform(base+".color", color.r, color.g, color.b);
 105 }
 106
 107
 108 Light::Loader::Loader(Light &l):
 109         DataFile::ObjectLoader<Light>(l)
 110 {
 111         add("attenuation", &Loader::attenuation);
 112         add("color", &Loader::color);
 113         add("position", &Loader::position);
 114         add("spot_direction", &Loader::spot_direction);
 115         add("spot_exponent", &Loader::spot_exponent);
 116         add("spot_cutoff", &Loader::spot_cutoff);
 117
 118         // Deprecated
 119         add("diffuse", &Loader::color);
 120         add("specular");
 121 }
 122
 123 void Light::Loader::attenuation(float c, float l, float q)
 124 {
 125         obj.set_attenuation(c, l, q);
 126 }
 127
 128 void Light::Loader::color(float r, float g, float b)
 129 {
 130         obj.set_color(Color(r, g, b));
 131 }
 132
 133 void Light::Loader::position(float x, float y, float z, float w)
 134 {
 135         obj.set_position(Vector4(x, y, z, w));
 136 }
 137
 138 void Light::Loader::spot_direction(float x, float y, float z)
 139 {
 140         obj.set_spot_direction(Vector3(x, y, z));
 141 }
 142
 143 void Light::Loader::spot_exponent(float e)
 144 {
 145         obj.set_spot_exponent(e);
 146 }
 147
 148 void Light::Loader::spot_cutoff(float c)
 149 {
 150         obj.set_spot_cutoff(Geometry::Angle<float>::from_degrees(c));
 151 }
 152
 153 } // namespace GL
 154 } // namespace Msp