OgreShadowCaster.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 __ShadowCaster_H__
#define __ShadowCaster_H__

#include "OgrePrerequisites.h"
#include "OgreRenderable.h"


namespace Ogre {


    class _OgreExport ShadowRenderable : public Renderable
    {
    protected:
        MaterialPtr mMaterial;
        RenderOperation mRenderOp;
        ShadowRenderable* mLightCap; // used only if isLightCapSeparate == true
    public:
        ShadowRenderable() : mMaterial(0), mLightCap(0) {}
        virtual ~ShadowRenderable() { delete mLightCap; }
        void setMaterial(MaterialPtr& mat) { mMaterial = mat; }
        const MaterialPtr& getMaterial(void) const { return mMaterial; }
        void getRenderOperation(RenderOperation& op) { op = mRenderOp; }
        RenderOperation* getRenderOperationForUpdate(void) {return &mRenderOp;}
        void getWorldTransforms(Matrix4* xform) const = 0;
        const Quaternion& getWorldOrientation(void) const = 0;
        const Vector3& getWorldPosition(void) const = 0;
        Real getSquaredViewDepth(const Camera* cam) const{ return 0; /* not used */}
        const LightList& getLights(void) const;
        bool isLightCapSeparate(void) const { return mLightCap != 0; }

        ShadowRenderable* getLightCapRenderable(void) { return mLightCap; }
        virtual bool isVisible(void) const { return true; }

    };

    enum ShadowRenderableFlags
    {
        SRF_INCLUDE_LIGHT_CAP = 0x00000001,
        SRF_INCLUDE_DARK_CAP  = 0x00000002,
        SRF_EXTRUDE_TO_INFINITY  = 0x00000004
    };

    class _OgreExport ShadowCaster
    {
    public:
        virtual ~ShadowCaster() { }
        virtual bool getCastShadows(void) const = 0;

        virtual EdgeData* getEdgeList(void) = 0;

        virtual const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const = 0;
        virtual const AxisAlignedBox& getLightCapBounds(void) const = 0;
        virtual const AxisAlignedBox& getDarkCapBounds(const Light& light, Real dirLightExtrusionDist) const = 0;

        typedef std::vector<ShadowRenderable*> ShadowRenderableList;
        typedef VectorIterator<ShadowRenderableList> ShadowRenderableListIterator;

        virtual ShadowRenderableListIterator getShadowVolumeRenderableIterator(
            ShadowTechnique shadowTechnique, const Light* light, 
            HardwareIndexBufferSharedPtr* indexBuffer, 
            bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 ) = 0;

        static void extrudeVertices(HardwareVertexBufferSharedPtr vertexBuffer, 
            size_t originalVertexCount, const Vector4& lightPos, Real extrudeDist);
        virtual Real getPointExtrusionDistance(const Light* l) const = 0;
    protected:
        Real getExtrusionDistance(const Vector3& objectPos, const Light* light) const;
        virtual void updateEdgeListLightFacing(EdgeData* edgeData, 
            const Vector4& lightPos);

        virtual void generateShadowVolume(EdgeData* edgeData, 
            HardwareIndexBufferSharedPtr indexBuffer, const Light* light,
            ShadowRenderableList& shadowRenderables, unsigned long flags);
        virtual void extrudeBounds(AxisAlignedBox& box, const Vector4& lightPos, 
            Real extrudeDist) const;


    };
}

#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:49 2006