shattered_ogrerb 0.5.0.1

data/vendor/ogrerb/src_headers/OGRE/OgreScriptLoader.h

@@ -0,0 +1,89 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __ScriptLoader_H__
+#define __ScriptLoader_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreDataStream.h"
+#include "OgreStringVector.h"
+
+namespace Ogre {
+
+	/** Abstract class defining the interface used by classes which wish 
+		to perform script loading to define instances of whatever they manage.
+	@remarks
+		Typically classes of this type wish to either parse individual script files
+		on demand, or be called with a group of files matching a certain pattern
+		at the appropriate time. Normally this will coincide with resource loading,
+		although the script use does not necessarily have to be a ResourceManager
+		(which subclasses from this class), it may be simply a script loader which 
+		manages non-resources but needs to be synchronised at the same loading points.
+	@par
+		Subclasses should add themselves to the ResourceGroupManager as a script loader
+		if they wish to be called at the point a resource group is loaded, at which 
+		point the parseScript method will be called with each file which matches a 
+		the pattern returned from getScriptPatterns.
+	*/
+	class _OgreExport ScriptLoader
+	{
+	public:
+		virtual ~ScriptLoader();
+		/** Gets the file patterns which should be used to find scripts for this
+			class.
+		@remarks
+			This method is called when a resource group is loaded if you use 
+			ResourceGroupManager::_registerScriptLoader.
+		@returns
+			A list of file patterns, in the order they should be searched in.
+		*/
+		virtual const StringVector& getScriptPatterns(void) const = 0;
+
+		/** Parse a script file.
+		@param stream Weak reference to a data stream which is the source of the script
+		@param groupName The name of a resource group which should be used if any resources
+			are created during the parse of this script.
+		*/
+		virtual void parseScript(DataStreamPtr& stream, const String& groupName) = 0;
+
+		/** Gets the relative loading order of scripts of this type.
+		@remarks
+			There are dependencies between some kinds of scripts, and to enforce
+			this all implementors of this interface must define a loading order. 
+		@returns A value representing the relative loading order of these scripts
+			compared to other script users, where higher values load later.
+		*/
+		virtual Real getLoadingOrder(void) const  = 0;
+
+	};
+
+
+}
+
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgreSearchOps.h

@@ -0,0 +1,65 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+
+// Emulate _findfirst, _findnext on non-Windows platforms
+
+
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include "OgrePlatform.h"
+
+#if OGRE_PLATFORM != OGRE_PLATFORM_WIN32
+
+#include <dirent.h>
+#include <unistd.h>
+#include <fnmatch.h>
+
+/* Our simplified data entry structure */
+struct _finddata_t
+{
+    char *name;
+    int attrib;
+    unsigned long size;
+};
+
+#define _A_NORMAL 0x00  /* Normalfile-Noread/writerestrictions */
+#define _A_RDONLY 0x01  /* Read only file */
+#define _A_HIDDEN 0x02  /* Hidden file */
+#define _A_SYSTEM 0x04  /* System file */
+#define _A_SUBDIR 0x10  /* Subdirectory */
+#define _A_ARCH   0x20  /* Archive file */
+
+long _findfirst(const char *pattern, struct _finddata_t *data);
+int _findnext(long id, struct _finddata_t *data);
+int _findclose(long id);
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgreSerializer.h

@@ -0,0 +1,113 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef __Serializer_H__
+#define __Serializer_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreString.h"
+#include "OgreDataStream.h"
+
+namespace Ogre {
+
+    /** Generic class for serialising data to / from binary stream-based files.
+    @remarks
+        This class provides a number of useful methods for exporting / importing data
+        from stream-oriented binary files (e.g. .mesh and .skeleton).
+    */
+    class _OgreExport Serializer
+    {
+    public:
+        Serializer();
+        virtual ~Serializer();
+
+		/// The endianness of written files
+		enum Endian
+		{
+			/// Use the platform native endian
+			ENDIAN_NATIVE,
+			/// Use big endian (0x1000 is serialised as 0x10 0x00)
+			ENDIAN_BIG,
+			/// Use little endian (0x1000 is serialised as 0x00 0x10)
+			ENDIAN_LITTLE
+		};
+
+
+    protected:
+
+        uint32 mCurrentstreamLen;
+        FILE* mpfFile;
+        String mVersion;
+		bool mFlipEndian; // default to native endian, derive from header
+
+        // Internal methods
+        virtual void writeFileHeader(void);
+        virtual void writeChunkHeader(uint16 id, size_t size);
+        
+        void writeFloats(const float* const pfloat, size_t count);
+        void writeFloats(const double* const pfloat, size_t count);
+        void writeShorts(const uint16* const pShort, size_t count);
+        void writeInts(const uint32* const pInt, size_t count); 
+        void writeBools(const bool* const pLong, size_t count);
+        void writeObject(const Vector3& vec);
+        void writeObject(const Quaternion& q);
+        
+        void writeString(const String& string);
+        void writeData(const void* const buf, size_t size, size_t count);
+        
+        virtual void readFileHeader(DataStreamPtr& stream);
+        virtual unsigned short readChunk(DataStreamPtr& stream);
+        
+        void readBools(DataStreamPtr& stream, bool* pDest, size_t count);
+        void readFloats(DataStreamPtr& stream, float* pDest, size_t count);
+        void readFloats(DataStreamPtr& stream, double* pDest, size_t count);
+        void readShorts(DataStreamPtr& stream, uint16* pDest, size_t count);
+        void readInts(DataStreamPtr& stream, uint32* pDest, size_t count);
+        void readObject(DataStreamPtr& stream, Vector3& pDest);
+        void readObject(DataStreamPtr& stream, Quaternion& pDest);
+
+        String readString(DataStreamPtr& stream);
+        String readString(DataStreamPtr& stream, size_t numChars);
+        
+        virtual void flipToLittleEndian(void* pData, size_t size, size_t count = 1);
+        virtual void flipFromLittleEndian(void* pData, size_t size, size_t count = 1);
+        
+        virtual void flipEndian(void * pData, size_t size, size_t count);
+        virtual void flipEndian(void * pData, size_t size);
+
+		/// Determine the endianness of the incoming stream compared to native
+		virtual void determineEndianness(DataStreamPtr& stream);
+		/// Determine the endianness to write with based on option
+		virtual void determineEndianness(Endian requestedEndian);
+    };
+
+}
+
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgreShadowCameraSetup.h

@@ -0,0 +1,100 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2006 Torus Knot Software Ltd
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __ShadowCameraSetup_H__
+#define __ShadowCameraSetup_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreMovablePlane.h"
+#include "OgreSharedPtr.h"
+
+
+namespace Ogre {
+
+    /** This class allows you to plug in new ways to define the camera setup when
+		rendering and projecting shadow textures.
+	@remarks
+		The default projection used when rendering shadow textures is a uniform
+		frustum. This is pretty straight forward but doesn't make the best use of 
+		the space in the shadow map since texels closer to the camera will be larger, 
+		resulting in 'jaggies'. There are several ways to distribute the texels
+		in the shadow texture differently, and this class allows you to override
+		that. 
+	@par
+		Ogre is provided with several alternative shadow camera setups, including
+		LiSPSM (LiSPSMShadowCameraSetup) and Plane Optimal (PlaneOptimalShadowCameraSetup).
+		Others can of course be written to incorporate other algorithms. All you 
+		have to do is instantiate one of these classes and enable it using 
+		SceneManager::setShadowCameraSetup (global) or Light::setCustomShadowCameraSetup
+		(per light). In both cases the instance is wrapped in a SharedPtr which means
+		it will  be deleted automatically when no more references to it exist.
+	@note
+        Shadow map matrices, being projective matrices, have 15 degrees of freedom.
+		3 of these degrees of freedom are fixed by the light's position.  4 are used to
+		affinely affect z values.  6 affinely affect u,v sampling.  2 are projective
+		degrees of freedom.  This class is meant to allow custom methods for 
+		handling optimization.
+    */
+	class _OgreExport ShadowCameraSetup
+	{
+	public:
+		/// Function to implement -- must set the shadow camera properties
+		virtual void getShadowCamera (const SceneManager *sm, const Camera *cam, 
+									  const Viewport *vp, const Light *light, Camera *texCam) const = 0;
+		/// Need virtual destructor in case subclasses use it
+		virtual ~ShadowCameraSetup() {}
+
+	};
+
+
+
+	/** Implements default shadow camera setup
+        @remarks
+            This implements the default shadow camera setup algorithm.  This is what might
+			be referred to as "normal" shadow mapping.  
+    */
+	class _OgreExport DefaultShadowCameraSetup : public ShadowCameraSetup
+	{
+	public:
+		/// Default constructor
+		DefaultShadowCameraSetup();
+		/// Destructor
+		virtual ~DefaultShadowCameraSetup();
+
+		/// Default shadow camera setup
+		virtual void getShadowCamera (const SceneManager *sm, const Camera *cam, 
+									  const Viewport *vp, const Light *light, Camera *texCam) const;
+	};
+
+
+
+	typedef SharedPtr<ShadowCameraSetup> ShadowCameraSetupPtr;
+
+}
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgreShadowCameraSetupFocused.h

@@ -0,0 +1,281 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2006 Torus Knot Software Ltd
+Copyright (c) 2006 Matthias Fink, netAllied GmbH <matthias.fink@web.de>								
+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.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __ShadowCameraSetupFocused_H__
+#define __ShadowCameraSetupFocused_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreShadowCameraSetup.h"
+#include "OgrePolygon.h"
+#include "OgreConvexBody.h"
+
+
+namespace Ogre {
+
+	class ConvexBody;
+
+	/** Implements the uniform shadow mapping algorithm in focused mode.
+	@remarks
+		Differs from the default shadow mapping projection in that it focuses the
+		shadow map on the visible areas of the scene. This results in better
+		shadow map texel usage, at the expense of some 'swimming' of the shadow
+		texture on receivers as the basis is constantly being reevaluated.
+	@note
+		Original implementation by Matthias Fink <matthias.fink@web.de>, 2006.
+	*/
+	class _OgreExport FocusedShadowCameraSetup : public ShadowCameraSetup
+	{
+	protected:
+		/** Transform to or from light space as defined by Wimmer et al.
+		@remarks
+		Point and spot lights need to be converted to directional lights to enable a 1:1 
+		light mapping. Otherwise a directional light may become a point light or a point 
+		sink (opposite of a light source) or point/spot lights may become directional lights
+		or light sinks. The light direction is always -y.
+		*/
+		static const Matrix4 msNormalToLightSpace;
+		static const Matrix4 msLightSpaceToNormal;
+
+		/** Temporary preallocated frustum to set up a projection matrix in 
+		::calculateShadowMappingMatrix()
+		*/
+		Frustum* mTempFrustum;
+
+		/** Temporary preallocated camera to set up a light frustum for clipping in ::calculateB.
+		*/
+		Camera* mLightFrustumCamera;
+		mutable bool mLightFrustumCameraCalculated;
+
+		/// Use tighter focus region?
+		bool mUseAggressiveRegion;
+
+		/** Internal class holding a point list representation of a convex body.
+		*/
+		class _OgreExport PointListBody
+		{
+			Polygon::VertexList mBodyPoints;
+			AxisAlignedBox		mAAB;
+
+		public:
+			PointListBody();
+			PointListBody(const ConvexBody& body);
+			~PointListBody();
+
+			/** Merges a second PointListBody into this one.
+			*/
+			void merge(const PointListBody& plb);
+
+			/** Builds a point list body from a 'real' body.
+			@remarks
+			Inserts all vertices from a body into the point list with or without adding duplicate vertices.
+			*/
+			void build(const ConvexBody& body, bool filterDuplicates = true);
+
+			/** Builds a PointListBody from a Body and includes all the space in a given direction.
+			@remarks
+			Intersects the bounding box with a ray from each available point of the body with the given
+			direction. Base and intersection points are stored in a PointListBody structure.
+			@note
+			Duplicate vertices are not filtered.
+			@note
+			Body is not checked for correctness.
+			*/
+			void buildAndIncludeDirection(const ConvexBody& body, 
+				const AxisAlignedBox& aabMax, const Vector3& dir);
+
+			/** Returns the bounding box representation.
+			*/
+			const AxisAlignedBox& getAAB(void) const;	
+
+			/** Adds a specific point to the body list.
+			*/
+			void addPoint(const Vector3& point);
+
+			/** Adds all points of an AAB.
+			*/
+			void addAAB(const AxisAlignedBox& aab);
+
+			/** Returns a point.
+			*/
+			const Vector3& getPoint(size_t cnt) const;
+
+			/** Returns the point count.
+			*/
+			size_t getPointCount(void) const;
+
+			/** Resets the body.
+			*/
+			void reset(void);
+
+		};
+
+		// Persistent calculations to prevent reallocation
+		mutable ConvexBody mBodyB;
+		mutable PointListBody mPointListBodyB;
+		mutable PointListBody mPointListBodyLVS;
+
+	protected:
+		/** Calculates the standard shadow mapping matrix.
+		@remarks
+		Provides the view and projection matrix for standard shadow mapping.
+		@note
+		You can choose which things you want to have: view matrix and/or projection 
+		matrix and/or shadow camera. Passing a NULL value as parameter ignores the
+		generation of this specific value.
+		@param sm: scene manager
+		@param cam: currently active camera
+		@param light: currently active light
+		@param out_view: calculated uniform view shadow mapping matrix (may be NULL)
+		@param out_proj: calculated uniform projection shadow mapping matrix (may be NULL)
+		@param out_cam: calculated uniform shadow camera (may be NULL)
+		*/
+		void calculateShadowMappingMatrix(const SceneManager& sm, const Camera& cam, 
+			const Light& light, Matrix4 *out_view, 
+			Matrix4 *out_proj, Camera *out_cam) const;
+
+		/** Calculates the intersection bodyB.
+		@remarks
+		The intersection bodyB consists of the concatenation the cam frustum clipped 
+		by the scene bounding box followed by a convex hullification with the light's 
+		position and the clipping with the scene bounding box and the light frustum:
+		((V \cap S) + l) \cap S \cap L (\cap: convex intersection, +: convex hull 
+		operation).
+		For directional lights the bodyB is assembled out of the camera frustum 
+		clipped by the scene bounding box followed by the extrusion of all available 
+		bodyB points towards the negative light direction. The rays are intersected 
+		by a maximum bounding box and added to the bodyB points to form the final 
+		intersection bodyB point list.
+		@param sm: scene manager
+		@param cam: currently active camera
+		@param light: currently active light
+		@param sceneBB: scene bounding box for clipping operations
+		@param out_bodyB: final intersection bodyB point list
+		*/
+		void calculateB(const SceneManager& sm, const Camera& cam, const Light& light, 
+			const AxisAlignedBox& sceneBB, PointListBody *out_bodyB) const;
+
+		/** Calculates the bodyLVS.
+		@remarks
+		Calculates the bodyLVS which consists of the convex intersection operation 
+		affecting the light frustum, the view frustum, and the current scene bounding
+		box is used to find suitable positions in the viewer's frustum to build the 
+		rotation matrix L_r. This matrix is applied after the projection matrix L_p to 
+		avoid an accidental flip of the frustum orientation for views tilted with 
+		respect to the shadow map.
+		@param scene: holds all potential occluders / receivers as one single bounding box
+		of the currently active scene node
+		@param cam: current viewer camera
+		@param light: current light
+		@param out_LVS: intersection body LVS (world coordinates)
+		*/
+		void calculateLVS(const SceneManager& sm, const Camera& cam, const Light& light,
+			const AxisAlignedBox& sceneBB, PointListBody *out_LVS) const;
+
+		/**	Returns the projection view direction.
+		@remarks
+		After the matrix L_p is applied the orientation of the light space may tilt for
+		non-identity projections. To prevent a false shadow cast the real view direction
+		is evaluated and applied to the light matrix L.
+		@param lightSpace: matrix of the light space transformation
+		@param cam: current viewer camera
+		@param bodyLVS: intersection body LVS (relevant space in front of the camera)
+		*/
+		Vector3 getLSProjViewDir(const Matrix4& lightSpace, const Camera& cam, 
+			const PointListBody& bodyLVS) const;
+
+		/** Returns a valid near-point seen by the camera.
+		@remarks
+		Returns a point that is situated near the camera by analyzing the bodyLVS that
+		contains all the relevant scene space in front of the light and the camera in
+		a point list array. The view matrix is relevant because the nearest point in
+		front of the camera should be determined.
+		@param viewMatrix: view matrix of the current camera
+		@param bodyLVS: intersection body LVS (relevant space in front of the camera) 
+		*/
+		Vector3 getNearCameraPoint_ws(const Matrix4& viewMatrix, 
+			const PointListBody& bodyLVS) const;
+
+		/** Transforms a given body to the unit cube (-1,-1,-1) / (+1,+1,+1) with a specific 
+		shadow matrix enabled.
+		@remarks
+		Transforms a given point list body object with the matrix m and then maps its
+		extends to a (-1,-1,-1) / (+1,+1,+1) unit cube
+		@param m: transformation matrix applied on the point list body
+		@param body: contains the points of the extends of all valid scene elements which 
+		are mapped to the unit cube
+		*/
+		Matrix4 transformToUnitCube(const Matrix4& m, const PointListBody& body) const;
+
+		/** Builds a view matrix.
+		@remarks
+		Builds a standard view matrix out of a given position, direction and up vector.
+		*/
+		Matrix4 buildViewMatrix(const Vector3& pos, const Vector3& dir, const Vector3& up) const;
+
+	public:
+		/** Default constructor.
+		@remarks
+		Temporary frustum and camera set up here.
+		*/
+		FocusedShadowCameraSetup(void);
+
+		/** Default destructor.
+		@remarks
+		Temporary frustum and camera destroyed here.
+		*/
+		virtual ~FocusedShadowCameraSetup(void);
+
+		/** Returns a uniform shadow camera with a focused view.
+		*/
+		virtual void getShadowCamera(const SceneManager *sm, const Camera *cam, 
+			const Viewport *vp, const Light *light, Camera *texCam) const;
+
+		/** Sets whether or not to use the more agressive approach to deciding on
+			the focus region or not.
+		@note
+			There are 2 approaches that can  be used to define the focus region,
+			the more aggressive way introduced by Wimmer et al, or the original
+			way as described in Stamminger et al. Wimmer et al's way tends to 
+			come up with a tighter focus region but in rare cases (mostly highly
+			glancing angles) can cause some shadow casters to be clipped 
+			incorrectly. By default the more aggressive approach is used since it
+			leads to significantly better results in most cases, but if you experience
+			clipping issues, you can use the less agressive version.
+		@param aggressive True to use the more agressive approach, false otherwise.
+		*/
+		void setUseAggressiveFocusRegion(bool aggressive) { mUseAggressiveRegion = aggressive; }
+
+		bool getUseAggressiveFocusRegion() const { return mUseAggressiveRegion; }
+
+	};
+
+
+}
+
+#endif