Light

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/
 
#ifndef OSG_LIGHT
#define OSG_LIGHT 1
 
#include <osg/StateAttribute>
#include <osg/Vec3>
#include <osg/Vec4>
 
#ifndef GL_LIGHT0
    #define GL_LIGHT0 0x4000
    #define GL_LIGHT1 0x4001
    #define GL_LIGHT2 0x4002
    #define GL_LIGHT3 0x4003
    #define GL_LIGHT4 0x4004
    #define GL_LIGHT5 0x4005
    #define GL_LIGHT6 0x4006
    #define GL_LIGHT7 0x4007
#endif
 
#ifndef GL_LIGHTING
    #define GL_LIGHTING 0x0B50
#endif
 
namespace osg {

class OSG_EXPORT Light : public StateAttribute
{
    public :
 
        Light();
 
        Light(unsigned int lightnum);

        Light(const Light& light,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
            StateAttribute(light,copyop),
            _lightnum(light._lightnum),
            _ambient(light._ambient),
            _diffuse(light._diffuse),
            _specular(light._specular),
            _position(light._position),
            _direction(light._direction),
            _constant_attenuation(light._constant_attenuation),
            _linear_attenuation(light._linear_attenuation),
            _quadratic_attenuation(light._quadratic_attenuation),
            _spot_exponent(light._spot_exponent),
            _spot_cutoff(light._spot_cutoff) {}
 
        virtual osg::Object* cloneType() const { return new Light(_lightnum); }
        virtual osg::Object* clone(const osg::CopyOp& copyop) const { return new Light(*this,copyop); }
        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Light *>(obj)!=NULL; }
        virtual const char* libraryName() const { return "osg"; }
        virtual const char* className() const { return "Light"; }
        virtual Type getType() const { return LIGHT; }

        virtual int compare(const StateAttribute& sa) const
        {
            // check the types are equal and then create the rhs variable
            // used by the COMPARE_StateAttribute_Parameter macros below.
            COMPARE_StateAttribute_Types(Light,sa)
 
            // compare each parameter in turn against the rhs.
            COMPARE_StateAttribute_Parameter(_lightnum)
            COMPARE_StateAttribute_Parameter(_ambient)
            COMPARE_StateAttribute_Parameter(_diffuse)
            COMPARE_StateAttribute_Parameter(_specular)
            COMPARE_StateAttribute_Parameter(_position)
            COMPARE_StateAttribute_Parameter(_direction)
            COMPARE_StateAttribute_Parameter(_constant_attenuation)
            COMPARE_StateAttribute_Parameter(_linear_attenuation)
            COMPARE_StateAttribute_Parameter(_quadratic_attenuation)
            COMPARE_StateAttribute_Parameter(_spot_exponent)
            COMPARE_StateAttribute_Parameter(_spot_cutoff)
 
            return 0; // passed all the above comparison macros, must be equal.
        }
 
        virtual unsigned int getMember() const { return _lightnum; }
 
        virtual bool getModeUsage(StateAttribute::ModeUsage& usage) const
        {
            usage.usesMode(GL_LIGHT0+_lightnum);
            return true;
        }
 
 

        void setLightNum(int num);

        int getLightNum() const { return _lightnum; }

        inline void setAmbient( const Vec4& ambient ) { _ambient = ambient; }

        inline const Vec4& getAmbient() const { return _ambient; }

        inline void setDiffuse( const Vec4& diffuse ) { _diffuse = diffuse; }

        inline const Vec4& getDiffuse() const { return _diffuse; }

        inline void setSpecular( const Vec4& specular ) { _specular = specular; }

        inline const Vec4& getSpecular() const { return _specular; }

        inline void setPosition( const Vec4& position ) { _position = position; }

        inline const Vec4& getPosition() const { return _position; }

        inline void setDirection( const Vec3& direction ) { _direction = direction; }

        inline const Vec3& getDirection() const { return _direction; }

        inline void setConstantAttenuation( float constant_attenuation )     { _constant_attenuation = constant_attenuation; }

        inline float getConstantAttenuation() const { return _constant_attenuation; }

        inline void setLinearAttenuation ( float linear_attenuation )        { _linear_attenuation = linear_attenuation; }

        inline float getLinearAttenuation () const { return _linear_attenuation; }

        inline void setQuadraticAttenuation ( float quadratic_attenuation )  { _quadratic_attenuation = quadratic_attenuation; }

        inline float getQuadraticAttenuation()  const { return _quadratic_attenuation; }

        inline void setSpotExponent( float spot_exponent )                   { _spot_exponent = spot_exponent; }

        inline float getSpotExponent() const { return _spot_exponent; }

        inline void setSpotCutoff( float spot_cutoff )                       { _spot_cutoff = spot_cutoff; }

        inline float getSpotCutoff() const                                   { return _spot_cutoff; }

        void captureLightState();

        virtual void apply(State& state) const;
 
    protected :
 
        virtual ~Light();

        void init();
 
        int _lightnum;                           // OpenGL light number
 
        Vec4 _ambient;                           // r, g, b, w
        Vec4 _diffuse;                           // r, g, b, w
        Vec4 _specular;                          // r, g, b, w
        Vec4 _position;                          // x, y, z, w
        Vec3 _direction;                         // x, y, z
        float _constant_attenuation;             // constant
        float _linear_attenuation;               // linear
        float _quadratic_attenuation;            // quadratic
        float _spot_exponent;                    // exponent
        float _spot_cutoff;                      // spread
};
 
}
 
#endif