CLight.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "opengl-precomp.h"  // Precompiled header
 
#include <mrpt/opengl/CLight.h>
#include <mrpt/serialization/CArchive.h>
 
#include "opengl_internals.h"
 
using namespace mrpt;
using namespace mrpt::opengl;
using namespace std;
 
// Ctor:
CLight::CLight()
        : light_ID(0),
          constant_attenuation(1.f),
          linear_attenuation(0.f),
          quadratic_attenuation(0.f),
          spot_exponent(0.f),
          spot_cutoff(180.f)
{
        color_ambient[0] = 0.05f;
        color_ambient[1] = 0.05f;
        color_ambient[2] = 0.05f;
        color_ambient[3] = 1.f;
 
        color_diffuse[0] = 0.7f;
        color_diffuse[1] = 0.7f;
        color_diffuse[2] = 0.7f;
        color_diffuse[3] = 1.f;
 
        color_specular[0] = 0.05f;
        color_specular[1] = 0.05f;
        color_specular[2] = 0.05f;
        color_specular[3] = 1.f;
 
        setPosition(0, 0, 1, 0);
        setDirection(0, 0, -1);
}
 
void CLight::writeToStream(mrpt::serialization::CArchive& out) const
{
        const uint8_t version = 0;
        out << version;
 
        out << light_ID << color_ambient[0] << color_ambient[1] << color_ambient[2]
                << color_ambient[3] << color_diffuse[0] << color_diffuse[1]
                << color_diffuse[2] << color_diffuse[3] << color_specular[0]
                << color_specular[1] << color_specular[2] << color_specular[3]
                << position[0] << position[1] << position[2] << position[3]
                << direction[0] << direction[1] << direction[2] << constant_attenuation
                << linear_attenuation << quadratic_attenuation << spot_exponent
                << spot_cutoff;
}
 
void CLight::readFromStream(mrpt::serialization::CArchive& in)
{
        uint8_t version;
        in >> version;
 
        switch (version)
        {
                case 0:
                        in >> light_ID >> color_ambient[0] >> color_ambient[1] >>
                                color_ambient[2] >> color_ambient[3] >> color_diffuse[0] >>
                                color_diffuse[1] >> color_diffuse[2] >> color_diffuse[3] >>
                                color_specular[0] >> color_specular[1] >> color_specular[2] >>
                                color_specular[3] >> position[0] >> position[1] >>
                                position[2] >> position[3] >> direction[0] >> direction[1] >>
                                direction[2] >> constant_attenuation >> linear_attenuation >>
                                quadratic_attenuation >> spot_exponent >> spot_cutoff;
                        break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
void CLight::sendToOpenGL() const
{
#if MRPT_HAS_OPENGL_GLUT
        const GLenum id = (GLenum)((int)GL_LIGHT0 + light_ID);
 
        glEnable(id);
 
        glLightfv(id, GL_AMBIENT, color_ambient);
        glLightfv(id, GL_DIFFUSE, color_diffuse);
        glLightfv(id, GL_SPECULAR, color_specular);
        glLightfv(id, GL_POSITION, position);
        glLightfv(id, GL_SPOT_DIRECTION, direction);
        glLightf(id, GL_SPOT_EXPONENT, spot_exponent);
        glLightf(id, GL_SPOT_CUTOFF, spot_cutoff);
        glLightf(id, GL_CONSTANT_ATTENUATION, constant_attenuation);
        glLightf(id, GL_LINEAR_ATTENUATION, linear_attenuation);
        glLightf(id, GL_QUADRATIC_ATTENUATION, quadratic_attenuation);
#endif
}
 
void CLight::setPosition(float x, float y, float z, float w)
{
        position[0] = x;
        position[1] = y;
        position[2] = z;
        position[3] = w;
}
void CLight::setDirection(float dx, float dy, float dz)
{
        direction[0] = dx;
        direction[1] = dy;
        direction[2] = dz;
}
 
namespace mrpt
{
namespace opengl
{
mrpt::serialization::CArchive& operator>>(
        mrpt::serialization::CArchive& in, mrpt::opengl::CLight& o)
{
        o.readFromStream(in);
        return in;
}
mrpt::serialization::CArchive& operator<<(
        mrpt::serialization::CArchive& out, const mrpt::opengl::CLight& o)
{
        o.writeToStream(out);
        return out;
}
}  // namespace opengl
}  // namespace mrpt