OgreLight.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program 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 GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef _LIGHT_H__
#define _LIGHT_H__

#include "OgrePrerequisites.h"

#include "OgreColourValue.h"
#include "OgreVector3.h"
#include "OgreVector4.h"
#include "OgreString.h"
#include "OgreMovableObject.h"
#include "OgrePlaneBoundedVolume.h"

namespace Ogre {


    class _OgreExport Light : public MovableObject
    {
    public:
        Real tempSquareDist;

        enum LightTypes
        {
            LT_POINT,
            LT_DIRECTIONAL,
            LT_SPOTLIGHT
        };

        Light();

        Light(const String& name);

        ~Light();

        void setType(LightTypes type);

        LightTypes getType(void) const;

        void setDiffuseColour(Real red, Real green, Real blue);

        void setDiffuseColour(const ColourValue& colour);

        const ColourValue& getDiffuseColour(void) const;

        void setSpecularColour(Real red, Real green, Real blue);

        void setSpecularColour(const ColourValue& colour);

        const ColourValue& getSpecularColour(void) const;

        void setAttenuation(Real range, Real constant, Real linear, Real quadratic);

        Real getAttenuationRange(void) const;

        Real getAttenuationConstant(void) const;

        Real getAttenuationLinear(void) const;

        Real getAttenuationQuadric(void) const;

        void setPosition(Real x, Real y, Real z);

        void setPosition(const Vector3& vec);

        const Vector3& getPosition(void) const;

        void setDirection(Real x, Real y, Real z);

        void setDirection(const Vector3& vec);

        const Vector3& getDirection(void) const;

        void setSpotlightRange(const Radian& innerAngle, const Radian& outerAngle, Real falloff = 1.0);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void setSpotlightRange(Real innerAngle, Real outerAngle, Real falloff = 1.0) {
            setSpotlightRange ( Angle(innerAngle), Angle(outerAngle), falloff );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        const Radian& getSpotlightInnerAngle(void) const;

        const Radian& getSpotlightOuterAngle(void) const;

        Real getSpotlightFalloff(void) const;

        void setSpotlightInnerAngle(const Radian& val);

        void setSpotlightOuterAngle(const Radian& val);

        void setSpotlightFalloff(Real val);

        void setPowerScale(Real power);

        Real getPowerScale(void) const;

        const AxisAlignedBox& getBoundingBox(void) const;

        void _updateRenderQueue(RenderQueue* queue);

        const String& getMovableType(void) const;

        const Vector3& getDerivedPosition(void) const;

        const Vector3& getDerivedDirection(void) const;

        void setVisible(bool visible);

        Real getBoundingRadius(void) const { return 0; /* not visible */ }

        Vector4 getAs4DVector(void) const;

        virtual const PlaneBoundedVolume& _getNearClipVolume(const Camera* const cam) const;

        virtual const PlaneBoundedVolumeList& _getFrustumClipVolumes(const Camera* const cam) const;

        uint32 getTypeFlags(void) const;

        AnimableValuePtr createAnimableValue(const String& valueName);

    protected:
        virtual void update(void) const;

        const String& getAnimableDictionaryName(void) const;
        void initialiseAnimableDictionary(StringVector& vec) const;

        LightTypes mLightType;
        Vector3 mPosition;
        ColourValue mDiffuse;
        ColourValue mSpecular;

        Vector3 mDirection;

        Radian mSpotOuter;
        Radian mSpotInner;
        Real mSpotFalloff;
        Real mRange;
        Real mAttenuationConst;
        Real mAttenuationLinear;
        Real mAttenuationQuad;
        Real mPowerScale;

        mutable Vector3 mDerivedPosition;
        mutable Vector3 mDerivedDirection;
        mutable Quaternion mLastParentOrientation;
        mutable Vector3 mLastParentPosition;

        static String msMovableType;

        mutable PlaneBoundedVolume mNearClipVolume;
        mutable PlaneBoundedVolumeList mFrustumClipVolumes;
        mutable bool mLocalTransformDirty;



    };

    class _OgreExport LightFactory : public MovableObjectFactory
    {
    protected:
        MovableObject* createInstanceImpl( const String& name, const NameValuePairList* params);
    public:
        LightFactory() {}
        ~LightFactory() {}

        static String FACTORY_TYPE_NAME;

        const String& getType(void) const;
        void destroyInstance( MovableObject* obj);  

    };

} // Namespace
#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:43 2006