shattered_ogrerb 0.5.0.1

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

@@ -0,0 +1,226 @@
+/*
+-----------------------------------------------------------------------------
+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 __ShadowCameraSetupLiSPSM_H__
+#define __ShadowCameraSetupLiSPSM_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreShadowCameraSetupFocused.h"
+
+
+namespace Ogre 
+{
+
+	/** Implements the Light Space Perspective Shadow Mapping Algorithm.
+	@remarks
+	Implements the LiSPSM algorithm for an advanced shadow map generation. LiSPSM was
+	developed by Michael Wimmer, Daniel Scherzer and Werner Purgathofer of the TU Wien.
+	The algorithm was presented on the Eurographics Symposium on Rendering 2004.
+	@note
+	Shadow mapping was introduced by Williams in 1978. First a depth image is rendered
+	from the light's view and compared in a second pass with depth values of the normal 
+	camera view. In case the depth camera's depth value is greater than the depth seen
+	by the light the fragment lies in the shadow.
+	The concept has a major draw back named perspective aliasing. The shadow map distri-
+	butes the samples uniformly meaning the position of the viewer is ignored. For the 
+	viewer however the perspective projection affects near objects to be displayed 
+	bigger than further away objects. The same thing happens with the shadow map texels:
+	Near shadows appear very coarse and far away shadows are perfectly sampled.
+	In 2002 Stamminger et al. presented an algorithm called Perspective Shadow Maps 
+	(PSM). PSM battles the perspective aliasing by distributing 50% of the shadow map 
+	texels for objects in the range of <near clipping plane> to <near clipping plane * 2>
+	which inverts the problem: The shadows near the viewer are perfectly sampled, 
+	however far away shadow may contain aliasing artefacts. A near clipping plane may be
+	a problem. But this is not the only one. In the post-perspective space the light 
+	sources are non-intuitively mapped: Directional lights may become point light and 
+	point lights may become directional lights. Also light sinks (opposite of a light 
+	source) may appear.	Another problem are shadow casters located behind the viewer. 
+	In post-projective space objects behind the viewer are mapped in front of him with 
+	a flipped up-vector.
+	LiSPSM battles the light source problem of the post-projective space by rearranging
+	the light space before transformation in such a way that no special cases appear. 
+	This is done by converting point/spot lights into directional lights. The light 
+	space is arranged in such a way that the light direction equals the inverse UNIT_Y.
+	In this combination	the directional light will neither change its type nor its 
+	direction. Furthermore all visible objects and shadow casters affecting the user's 
+	visible area lie in front of the shadow camera: After building the intersection body
+	that contains all these objects (body intersection building was introduced with PSM; 
+	have a look at the description for the method "calculateB" for further info) a 
+	frustum around the body's light space bounding box is created. A parameter (called 
+	'n') automatically adjusts the shadow map sample distribution by specifying the 
+	frustum's view point - near plane which affects the perspective warp. In case the 
+	distance is small the perspecive warp will be strong. As a consequence near objects 
+	will gain quality.
+	However there are still problems. PSM as well as LiSPSM only devote to minimize
+	perspective aliasing. Projection aliasing is still a problem, also 'swimming 
+	artefacts' still occur. The LiSPSM quality distribution is very good but not the 
+	best available: Some sources say logarithmic shadow mapping is the non plus ultra, 
+	however others reject this thought. There is a research project on logarithmic shadow 
+	maps. The web page url is http://gamma.cs.unc.edu/logsm/. However there is no techical 
+	report available yet (Oct 23rd, 2006).
+	@note
+	More information can be found on the webpage of the TU Wien: 
+	http://www.cg.tuwien.ac.at/research/vr/lispsm/
+	@note
+	Original implementation by Matthias Fink <matthias.fink@web.de>, 2006.
+	*/
+	class _OgreExport LiSPSMShadowCameraSetup : public FocusedShadowCameraSetup
+	{
+	protected:
+		/// Warp factor adjustment
+		Real mOptAdjustFactor;
+		/// Use simple nopt derivation?
+		bool mUseSimpleNOpt;
+
+		/** Calculates the LiSPSM projection matrix P.
+		@remarks
+		The LiSPSM projection matrix will be built around the axis aligned bounding box 
+		of the intersection body B in light space. The distance between the near plane 
+		and the projection center is chosen in such a way (distance is set by the para-
+		meter n) that the perspective error is the same on the near and far	plane. In 
+		case P equals the identity matrix the algorithm falls back to a uniform shadow
+		mapping matrix.
+		@param lightSpace: matrix of the light space transformation
+		@param bodyB: intersection body B
+		@param bodyLVS: intersection body LVS (relevant space in front of the camera)
+		@param sm: scene manager
+		@param cam: currently active camera
+		@param light: currently active light
+		*/
+		Matrix4 calculateLiSPSM(const Matrix4& lightSpace, const PointListBody& bodyB, 
+			const PointListBody& bodyLVS, const SceneManager& sm, 
+			const Camera& cam, const Light& light) const;
+
+		/** Calculates the distance between camera position and near clipping plane.
+		@remarks
+		n_opt determines the distance between light space origin (shadow camera position)
+		and	the near clipping plane to achieve an optimal perspective forshortening effect.
+		In this	way the texel distibution over the shadow map is controlled.
+
+		Formula:
+		               d
+		n_opt = ---------------
+		        sqrt(z1/z0) - 1
+
+		Parameters:
+		d: distance between the near and the far clipping plane
+		z0: located on the near clipping plane of the intersection body b
+		z1: located on the far clipping plane with the same x/y values as z0		
+		@note
+		A positive value is applied as the distance between viewer and near clipping plane.
+		In case null is returned uniform shadow mapping will be applied.
+		@param lightSpace: matrix of the light space transformation
+		@param bodyBABB_ls: bounding box of the tranformed (light space) bodyB
+		@param bodyLVS: point list of the bodyLVS which describes the scene space which is in 
+		front of the light and the camera
+		@param cam: currently active camera
+		*/
+		Real calculateNOpt(const Matrix4& lightSpace, const AxisAlignedBox& bodyBABB_ls, 
+			const PointListBody& bodyLVS, const Camera& cam) const;
+
+		/** Calculates a simpler version than the one above.
+		*/
+		Real calculateNOptSimple(const PointListBody& bodyLVS, 
+			const Camera& cam) const;
+
+		/** Calculates the visible point on the near plane for the n_opt calculation
+		@remarks
+		z0 lies on the parallel plane to the near plane through e and on the near plane of 
+		the frustum C (plane z = bodyB_zMax_ls) and on the line x = e.x.
+		@param lightSpace: matrix of the light space transformation
+		@param e: the LiSPSM parameter e is located near or on the near clipping plane of the 
+		LiSPSM frustum C
+		@param bodyB_zMax_ls: maximum z-value of the light space bodyB bounding box
+		@param cam: currently active camera
+		*/
+		Vector3 calculateZ0_ls(const Matrix4& lightSpace, const Vector3& e, Real bodyB_zMax_ls, 
+			const Camera& cam) const;
+
+		/** Builds a frustum matrix.
+		@remarks
+		Builds a standard frustum matrix out of the distance infos of the six frustum 
+		clipping planes.
+		*/
+		Matrix4 buildFrustumProjection(Real left, Real right, Real bottom, 
+			Real top, Real near, Real far) const;
+
+	public:
+		/** Default constructor.
+		@remarks
+		Nothing done here.
+		*/
+		LiSPSMShadowCameraSetup(void);
+
+		/** Default destructor.
+		@remarks
+		Nothing done here.
+		*/
+		virtual ~LiSPSMShadowCameraSetup(void);
+
+		/** Returns a LiSPSM shadow camera.
+		@remarks
+		Builds and returns a LiSPSM shadow camera. 
+		More information can be found on the webpage of the TU Wien: 
+		http://www.cg.tuwien.ac.at/research/vr/lispsm/
+		*/
+		virtual void getShadowCamera(const SceneManager *sm, const Camera *cam, 
+			const Viewport *vp, const Light *light, Camera *texCam) const;
+
+		/** Adjusts the parameter n to produce optimal shadows.
+		@remarks
+		The smaller the parameter n, the stronger the perspective warping effect.
+		The consequence of a stronger warping is that the near shadows will gain 
+		quality while the far ones will lose it. Depending on your scene and light
+		types you may want to tweak this value - for example directional lights
+		tend to benefit from higher values of n than other types of light, 
+		especially if you expect to see more distant shadows (say if the viewpoint is
+		higher above the ground plane). Remember that you can supply separate
+		ShadowCameraSetup instances configured differently per light if you wish.
+		@param n The adjustment factor - default is 0.1f. 
+		*/
+		virtual void setOptimalAdjustFactor(Real n) { mOptAdjustFactor = n; }
+		/** Get the parameter n used to produce optimal shadows. 
+		@see setOptimalAdjustFactor
+		*/
+		virtual Real getOptimalAdjustFactor() const { return mOptAdjustFactor; }
+		/** Sets whether or not to use a slightly simpler version of the 
+			camera near point derivation (default is true)
+		*/
+		virtual void setUseSimpleOptimalAdjust(bool s) { mUseSimpleNOpt = s; }
+		/** Gets whether or not to use a slightly simpler version of the 
+		camera near point derivation (default is true)
+		*/
+		virtual bool getUseSimpleOptimalAdjust() const { return mUseSimpleNOpt; }
+
+	};
+
+}
+
+#endif
+

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

@@ -0,0 +1,81 @@
+/*
+-----------------------------------------------------------------------------
+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 __ShadowCameraSetupPlaneOptimal_H__
+#define __ShadowCameraSetupPlaneOptimal_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreShadowCameraSetup.h"
+
+namespace Ogre {
+
+
+	/** Implements the plane optimal shadow camera algorithm.
+        @remarks
+            Given a plane of interest, it is possible to set up the shadow camera
+			matrix such that the mapping between screen and shadow map is the identity
+			(when restricted to pixels that view the plane of interest).  Therefore,
+			if the shadow map resolution matches the screen space resolution (of the 
+			seen planar receiver), we can get pixel perfect shadowing on the plane. 
+			Off the plane, the shadowing is not guaranteed to be perfect and will 
+			likely exhibit the usual sampling artifacts associated with shadow mapping.
+		@note Important: this routine requires double-precision calculations. When you
+			are running under Direct3D, you must ensure that you set the floating
+			point mode to 'Consistent' rather than 'Fastest' to ensure this precision.
+			This does allegedly come with some performance cost but when measuring 
+			it appears to be negligible in modern systems for normal usage.
+		@note Second important note: this projection also only works for lights with
+			a finite position. Therefore you cannot use it for directional lights
+			at this time.
+    */
+	class _OgreExport PlaneOptimalShadowCameraSetup : public ShadowCameraSetup
+	{
+	private:
+		MovablePlane* m_plane;	///< pointer to plane of interest
+	private:
+		PlaneOptimalShadowCameraSetup() {}	///< Default constructor is private
+
+		/// helper function computing projection matrix given constraints
+		Matrix4 computeConstrainedProjection( const Vector4& pinhole, 
+											  const std::vector<Vector4>& fpoint, 
+											  const std::vector<Vector2>& constraint) const;
+
+	public:
+		/// Constructor -- requires a plane of interest
+		PlaneOptimalShadowCameraSetup(MovablePlane *plane);
+		/// Destructor
+		virtual ~PlaneOptimalShadowCameraSetup();
+
+		/// Returns shadow camera configured to get 1-1 homography between screen and shadow map when restricted to plane
+		virtual void getShadowCamera (const SceneManager *sm, const Camera *cam, 
+									  const Viewport *vp, const Light *light, Camera *texCam) const;
+	};
+
+}
+
+#endif

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

@@ -0,0 +1,215 @@
+/*
+-----------------------------------------------------------------------------
+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 __ShadowCaster_H__
+#define __ShadowCaster_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreRenderable.h"
+
+
+namespace Ogre {
+
+
+    /** Class which represents the renderable aspects of a set of shadow volume faces. 
+    @remarks
+        Note that for casters comprised of more than one set of vertex buffers (e.g. SubMeshes each
+        using their own geometry), it will take more than one ShadowRenderable to render the 
+        shadow volume. Therefore for shadow caster geometry, it is best to stick to one set of
+        vertex buffers (not necessarily one buffer, but the positions for the entire geometry 
+        should come from one buffer if possible)
+    */
+    class _OgreExport ShadowRenderable : public Renderable
+    {
+    protected:
+        MaterialPtr mMaterial;
+        RenderOperation mRenderOp;
+        ShadowRenderable* mLightCap; // used only if isLightCapSeparate == true
+    public:
+        ShadowRenderable() : mMaterial(), mLightCap(0) {}
+        virtual ~ShadowRenderable() { delete mLightCap; }
+        /** Set the material to be used by the shadow, should be set by the caller 
+          before adding to a render queue
+        */
+        void setMaterial(const MaterialPtr& mat) { mMaterial = mat; }
+        /// Overridden from Renderable
+        const MaterialPtr& getMaterial(void) const { return mMaterial; }
+        /// Overridden from Renderable
+        void getRenderOperation(RenderOperation& op) { op = mRenderOp; }
+        /// Get the internal render operation for set up
+        RenderOperation* getRenderOperationForUpdate(void) {return &mRenderOp;}
+        /// Overridden from Renderable
+        void getWorldTransforms(Matrix4* xform) const = 0;
+        /// Overridden from Renderable
+        const Quaternion& getWorldOrientation(void) const = 0;
+        /// Overridden from Renderable
+        const Vector3& getWorldPosition(void) const = 0;
+        /// Overridden from Renderable
+        Real getSquaredViewDepth(const Camera*) const{ return 0; /* not used */}
+        /// Overridden from Renderable
+        const LightList& getLights(void) const;
+        /** Does this renderable require a separate light cap?
+        @remarks
+            If possible, the light cap (when required) should be contained in the
+            usual geometry of the shadow renderable. However, if for some reason
+            the normal depth function (less than) could cause artefacts, then a
+            separate light cap with a depth function of 'always fail' can be used 
+            instead. The primary example of this is when there are floating point
+            inaccuracies caused by calculating the shadow geometry separately from
+            the real geometry. 
+        */
+        bool isLightCapSeparate(void) const { return mLightCap != 0; }
+
+        /// Get the light cap version of this renderable
+        ShadowRenderable* getLightCapRenderable(void) { return mLightCap; }
+        /// Should this ShadowRenderable be treated as visible?
+        virtual bool isVisible(void) const { return true; }
+
+    };
+
+    /** A set of flags that can be used to influence ShadowRenderable creation. */
+    enum ShadowRenderableFlags
+    {
+        /// For shadow volume techniques only, generate a light cap on the volume
+        SRF_INCLUDE_LIGHT_CAP = 0x00000001,
+        /// For shadow volume techniques only, generate a dark cap on the volume
+        SRF_INCLUDE_DARK_CAP  = 0x00000002,
+        /// For shadow volume techniques only, indicates volume is extruded to infinity
+        SRF_EXTRUDE_TO_INFINITY  = 0x00000004
+    };
+
+    /** This class defines the interface that must be implemented by shadow casters.
+    */
+    class _OgreExport ShadowCaster
+    {
+    public:
+        virtual ~ShadowCaster() { }
+        /** Returns whether or not this object currently casts a shadow. */
+        virtual bool getCastShadows(void) const = 0;
+
+        /** Returns details of the edges which might be used to determine a silhouette. */
+        virtual EdgeData* getEdgeList(void) = 0;
+		/** Returns whether the object has a valid edge list. */
+		virtual bool hasEdgeList(void) = 0;
+
+        /** Get the world bounding box of the caster. */
+        virtual const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const = 0;
+        /** Gets the world space bounding box of the light cap */
+        virtual const AxisAlignedBox& getLightCapBounds(void) const = 0;
+        /** Gets the world space bounding box of the dark cap, as extruded using the light provided */
+        virtual const AxisAlignedBox& getDarkCapBounds(const Light& light, Real dirLightExtrusionDist) const = 0;
+
+        typedef std::vector<ShadowRenderable*> ShadowRenderableList;
+        typedef VectorIterator<ShadowRenderableList> ShadowRenderableListIterator;
+
+        /** Gets an iterator over the renderables required to render the shadow volume. 
+        @remarks
+            Shadowable geometry should ideally be designed such that there is only one
+            ShadowRenderable required to render the the shadow; however this is not a necessary
+            limitation and it can be exceeded if required.
+        @param shadowTechnique The technique being used to generate the shadow
+        @param light The light to generate the shadow from
+        @param indexBuffer The index buffer to build the renderables into, 
+            the current contents are assumed to be disposable.
+        @param extrudeVertices If true, this means this class should extrude
+            the vertices of the back of the volume in software. If false, it
+            will not be done (a vertex program is assumed).
+        @param extrusionDistance The distance to extrude the shadow volume
+        @param flags Technique-specific flags, see ShadowRenderableFlags
+        */
+        virtual ShadowRenderableListIterator getShadowVolumeRenderableIterator(
+            ShadowTechnique shadowTechnique, const Light* light, 
+            HardwareIndexBufferSharedPtr* indexBuffer, 
+            bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 ) = 0;
+
+        /** Utility method for extruding vertices based on a light. 
+        @remarks
+            Unfortunately, because D3D cannot handle homogenous (4D) position
+            coordinates in the fixed-function pipeline (GL can, but we have to
+            be cross-API), when we extrude in software we cannot extrude to 
+            infinity the way we do in the vertex program (by setting w to
+            0.0f). Therefore we extrude by a fixed distance, which may cause 
+            some problems with larger scenes. Luckily better hardware (ie
+            vertex programs) can fix this.
+        @param vertexBuffer The vertex buffer containing ONLY xyz position
+        values, which must be originalVertexCount * 2 * 3 floats long.
+        @param originalVertexCount The count of the original number of
+        vertices, ie the number in the mesh, not counting the doubling
+        which has already been done (by VertexData::prepareForShadowVolume)
+        to provide the extruded area of the buffer.
+        @param lightPos 4D light position in object space, when w=0.0f this
+        represents a directional light
+        @param extrudeDist The distance to extrude
+        */
+        static void extrudeVertices(const HardwareVertexBufferSharedPtr& vertexBuffer, 
+            size_t originalVertexCount, const Vector4& lightPos, Real extrudeDist);
+        /** Get the distance to extrude for a point/spot light */
+        virtual Real getPointExtrusionDistance(const Light* l) const = 0;
+    protected:
+        /// Helper moethod for calculating extrusion distance
+        Real getExtrusionDistance(const Vector3& objectPos, const Light* light) const;
+        /** Tells the caster to perform the tasks necessary to update the 
+            edge data's light listing. Can be overridden if the subclass needs 
+            to do additional things. 
+        @param edgeData The edge information to update
+        @param lightPos 4D vector representing the light, a directional light
+            has w=0.0
+       */
+        virtual void updateEdgeListLightFacing(EdgeData* edgeData, 
+            const Vector4& lightPos);
+
+        /** Generates the indexes required to render a shadow volume into the 
+            index buffer which is passed in, and updates shadow renderables
+            to use it.
+        @param edgeData The edge information to use
+        @param indexBuffer The buffer into which to write data into; current 
+            contents are assumed to be discardable.
+        @param light The light, mainly for type info as silhouette calculations
+            should already have been done in updateEdgeListLightFacing
+        @param shadowRenderables A list of shadow renderables which has 
+            already been constructed but will need populating with details of
+            the index ranges to be used.
+        @param flags Additional controller flags, see ShadowRenderableFlags
+        */
+        virtual void generateShadowVolume(EdgeData* edgeData, 
+            const HardwareIndexBufferSharedPtr& indexBuffer, const Light* light,
+            ShadowRenderableList& shadowRenderables, unsigned long flags);
+        /** Utility method for extruding a bounding box. 
+        @param box Original bounding box, will be updated in-place
+        @param lightPos 4D light position in object space, when w=0.0f this
+        represents a directional light
+        @param extrudeDist The distance to extrude
+        */
+        virtual void extrudeBounds(AxisAlignedBox& box, const Vector4& lightPos, 
+            Real extrudeDist) const;
+
+
+    };
+}
+
+#endif