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-2013 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#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"
#include "OgreShadowCameraSetup.h"
#include "OgreHeaderPrefix.h"

namespace Ogre {


    class _OgreExport Light : public MovableObject
    {
    public:
        Real tempSquareDist;
        void _calcTempSquareDist(const Vector3& worldPos);

        enum LightTypes
        {
            LT_POINT = 0,
            LT_DIRECTIONAL = 1,
            LT_SPOTLIGHT = 2
        };

        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);

        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 setSpotlightNearClipDistance(Real nearClip) { mSpotNearClip = nearClip; }
        
        Real getSpotlightNearClipDistance() const { return mSpotNearClip; }
        
        void setPowerScale(Real power);

        Real getPowerScale(void) const;

        void _notifyAttached(Node* parent, bool isTagPoint = false);

        void _notifyMoved(void);

        const AxisAlignedBox& getBoundingBox(void) const;

        void _updateRenderQueue(RenderQueue* queue);

        const String& getMovableType(void) const;

        const Vector3& getDerivedPosition(bool cameraRelativeIfSet = false) const;

        const Vector3& getDerivedDirection(void) const;

        void setVisible(bool visible);

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

        Vector4 getAs4DVector(bool cameraRelativeIfSet = false) 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);

        void setCustomShadowCameraSetup(const ShadowCameraSetupPtr& customShadowSetup);

        void resetCustomShadowCameraSetup(void);

        const ShadowCameraSetupPtr& getCustomShadowCameraSetup(void) const;

        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);

        size_t _getIndexInFrame() const { return mIndexInFrame; }
        void _notifyIndexInFrame(size_t i) { mIndexInFrame = i; }
        
        void setShadowFarDistance(Real distance);
        void resetShadowFarDistance(void);
        Real getShadowFarDistance(void) const;
        Real getShadowFarDistanceSquared(void) const;

        void setShadowNearClipDistance(Real nearClip) { mShadowNearClipDist = nearClip; }

        Real getShadowNearClipDistance() const { return mShadowNearClipDist; }

        Real _deriveShadowNearClipDistance(const Camera* maincam) const;

        void setShadowFarClipDistance(Real farClip) { mShadowFarClipDist = farClip; }

        Real getShadowFarClipDistance() const { return mShadowFarClipDist; }

        Real _deriveShadowFarClipDistance(const Camera* maincam) const;

        void _setCameraRelative(Camera* cam);

        void setCustomParameter(uint16 index, const Vector4& value);

        const Vector4& getCustomParameter(uint16 index) const;

        virtual void _updateCustomGpuParameter(uint16 paramIndex, 
            const GpuProgramParameters::AutoConstantEntry& constantEntry, 
            GpuProgramParameters* params) const;
                
        bool isInLightRange(const Ogre::Sphere& sphere) const;
        
        bool isInLightRange(const Ogre::AxisAlignedBox& container) const;
    
    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 mSpotNearClip;
        Real mRange;
        Real mAttenuationConst;
        Real mAttenuationLinear;
        Real mAttenuationQuad;
        Real mPowerScale;
        size_t mIndexInFrame;
        bool mOwnShadowFarDist;
        Real mShadowFarDist;
        Real mShadowFarDistSquared;
        
        Real mShadowNearClipDist;
        Real mShadowFarClipDist;


        mutable Vector3 mDerivedPosition;
        mutable Vector3 mDerivedDirection;
        // Slightly hacky but unless we separate observed light render state from main Light...
        mutable Vector3 mDerivedCamRelativePosition;
        mutable bool mDerivedCamRelativeDirty;
        Camera* mCameraToBeRelativeTo;

        static String msMovableType;

        mutable PlaneBoundedVolume mNearClipVolume;
        mutable PlaneBoundedVolumeList mFrustumClipVolumes;
        mutable bool mDerivedTransformDirty;

        mutable ShadowCameraSetupPtr mCustomShadowCameraSetup;

        typedef map<uint16, Vector4>::type CustomParameterMap;
        CustomParameterMap mCustomParameters;
    };

    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);  

    };
#include "OgreHeaderPrefix.h"

} // namespace Ogre
#endif // _LIGHT_H__