Light.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */


#ifndef ANA_COLOR_LIGHT_H
#define ANA_COLOR_LIGHT_H

#include <anatomist/window/glcaps.h>
#include <cartobase/object/object.h>


namespace anatomist
{

  class Light
  {
  public:
    Light();
    virtual ~Light();

    GLfloat *Ambient() { return(_ambient); }
    GLfloat Ambient(int i) { return(_ambient[i]); }

    GLfloat *Diffuse() { return(_diffuse); }
    GLfloat Diffuse(int i) { return(_diffuse[i]); }

    GLfloat *Specular() { return(_specular); }
    GLfloat Specular(int i) { return(_specular[i]); }

    GLfloat *Background() { return(_background); }
    GLfloat Background(int i) { return(_background[i]); }

    GLfloat *ModelAmbient() { return(_modelAmbient); }
    GLfloat ModelAmbient(int i) { return(_modelAmbient[i]); }

    GLfloat *Position() { return(_position); }
    GLfloat Position(int i) { return(_position[i]); }

    GLfloat *SpotDirection() { return(_spotDirection); }
    GLfloat SpotDirection(int i) { return(_spotDirection[i]); }

    GLfloat SpotExponent() { return(_spotExponent); }
    GLfloat SpotCutoff() { return(_spotCutoff); }
    GLfloat ConstantAttenuation() { return(_constantAttenuation); }
    GLfloat LinearAttenuation() { return(_linearAttenuation); }
    GLfloat QuadraticAttenuation() { return(_quadraticAttenuation); }
    GLfloat ModelLocalViewer() { return(_modelLocalViewer); }
    GLfloat ModelTwoSide() { return(_modelTwoSide); }

    void SetSpotExponent(float val);
    void SetSpotCutoff(float val);
    void SetConstantAttenuation(float val);
    void SetLinearAttenuation(float val);
    void SetQuadraticAttenuation(float val);
    void SetModelLocalViewer(float val);
    void SetModelTwoSide(float val);

    void SetPosition(float, float, float, float);
    void SetPositionX(float val);
    void SetPositionY(float val);
    void SetPositionZ(float val);
    void SetPositionW(float val);

    void SetSpotDirection(float, float, float);
    void SetSpotDirectionX(float val);
    void SetSpotDirectionY(float val);
    void SetSpotDirectionZ(float val);

    void SetModelAmbient(float, float, float, float);
    void SetModelAmbientR(float val);
    void SetModelAmbientG(float val);
    void SetModelAmbientB(float val);
    void SetModelAmbientA(float val);

    void SetAmbient(float, float, float, float);
    void SetAmbientR(float val);
    void SetAmbientG(float val);
    void SetAmbientB(float val);
    void SetAmbientA(float val);

    void SetDiffuse(float, float, float, float);
    void SetDiffuseR(float val);
    void SetDiffuseG(float val);
    void SetDiffuseB(float val);
    void SetDiffuseA(float val);

    void SetSpecular(float, float, float, float);
    void SetSpecularR(float val);
    void SetSpecularG(float val);
    void SetSpecularB(float val);
    void SetSpecularA(float val);

    void SetBackground(float, float, float, float);
    void SetBackgroundR(float val);
    void SetBackgroundG(float val);
    void SetBackgroundB(float val);
    void SetBackgroundA(float val);

    GLuint getGLList();
    void refreshGLList();
    void setChanged( bool=true );

    void set( const carto::GenericObject & );
    void set( const carto::Object & );
    carto::Object genericDescription() const;

  protected:
    GLfloat _ambient[4];
    GLfloat _diffuse[4];
    GLfloat _specular[4];
    GLfloat _background[4];
    GLfloat _position[4];
    GLfloat _spotDirection[3];
    GLfloat _spotExponent;
    GLfloat _spotCutoff;
    GLfloat _constantAttenuation;
    GLfloat _linearAttenuation;
    GLfloat _quadraticAttenuation;
    GLfloat _modelAmbient[4];
    GLfloat _modelLocalViewer;
    GLfloat _modelTwoSide;
    GLuint  _GLList;
    bool    _GLLRefreshFlag;
  };

}


#endif