ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreShadowCameraSetupLiSPSM.h

@@ -1,254 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-Copyright (c) 2006 Matthias Fink, netAllied GmbH <matthias.fink@web.de>								
-
-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 __ShadowCameraSetupLiSPSM_H__
-#define __ShadowCameraSetupLiSPSM_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreShadowCameraSetupFocused.h"
-
-
-namespace Ogre 
-{
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Scene
-	*  @{
-	*/
-	/** 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;
-		/// Extra calculated warp factor
-		mutable Real mOptAdjustFactorTweak;
-		/// Threshold (cos angle) within which to start increasing the opt adjust as camera direction approaches light direction
-		Real mCosCamLightDirThreshold;
-
-		/** 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 foreshortening effect.
-		In this	way the texel distribution 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 transformed (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, size_t iteration) 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; }
-
-		/** Sets the threshold between the camera and the light direction below
-			which the LiSPSM projection is 'flattened', since coincident light
-			and camera projections cause problems with the perspective skew.
-			@remarks
-			For example, setting this to 20 degrees will mean that as the difference 
-			between the light and camera direction reduces from 20 degrees to 0
-			degrees, the perspective skew will be proportionately removed.
-		*/
-		virtual void setCameraLightDirectionThreshold(Degree angle);
-
-		/** Sets the threshold between the camera and the light direction below
-		which the LiSPSM projection is 'flattened', since coincident light
-		and camera projections cause problems with the perspective skew.
-		*/
-		virtual Degree getCameraLightDirectionThreshold() const;
-
-
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif
-

data/deps/include/OGRE/OgreShadowCameraSetupPSSM.h

@@ -1,126 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-Copyright (c) 2006 Matthias Fink, netAllied GmbH <matthias.fink@web.de>								
-
-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 __ShadowCameraSetupPSSM_H__
-#define __ShadowCameraSetupPSSM_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreShadowCameraSetupLiSPSM.h"
-
-namespace Ogre
-{
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Scene
-	*  @{
-	*/
-	/** Parallel Split Shadow Map (PSSM) shadow camera setup. 
-	@remarks
-		A PSSM shadow system uses multiple shadow maps per light and maps each
-		texture into a region of space, progressing away from the camera. As such
-		it is most appropriate for directional light setups. This particular version
-		also uses LiSPSM projection for each split to maximise the quality. 
-	@note
-		Because PSSM uses multiple shadow maps per light, you will need to increase
-		the number of shadow textures available (via SceneManager) to match the 
-		number of shadow maps required (default is 3 per light). 
-	*/
-	class _OgreExport PSSMShadowCameraSetup : public Ogre::LiSPSMShadowCameraSetup
-	{
-	public:
-		typedef vector<Real>::type SplitPointList;
-		typedef vector<Real>::type OptimalAdjustFactorList;
-
-	protected:
-		size_t mSplitCount;
-		SplitPointList mSplitPoints;
-		OptimalAdjustFactorList mOptimalAdjustFactors;
-		Real mSplitPadding;
-
-		mutable size_t mCurrentIteration;
-
-	public:
-		/// Constructor, defaults to 3 splits
-		PSSMShadowCameraSetup();
-		~PSSMShadowCameraSetup();
-
-		/** Calculate a new splitting scheme.
-		@param splitCount The number of splits to use
-		@param nearDist The near plane to use for the first split
-		@param farDist The far plane to use for the last split
-		@param lambda Factor to use to reduce the split size 
-		*/
-		void calculateSplitPoints(size_t splitCount, Real nearDist, Real farDist, Real lambda = 0.95);
-
-		/** Manually configure a new splitting scheme.
-		@param newSplitPoints A list which is splitCount + 1 entries long, containing the
-			split points. The first value is the near point, the last value is the
-			far point, and each value in between is both a far point of the previous
-			split, and a near point for the next one.
-		*/
-		void setSplitPoints(const SplitPointList& newSplitPoints);
-
-		/** Set the LiSPSM optimal adjust factor for a given split (call after
-			configuring splits).
-		*/
-		void setOptimalAdjustFactor(size_t splitIndex, Real factor);
-
-		/** Set the padding factor to apply to the near & far distances when matching up
-			splits to one another, to avoid 'cracks'.
-		*/
-		void setSplitPadding(Real pad) { mSplitPadding = pad; }
-
-		/** Get the padding factor to apply to the near & far distances when matching up
-			splits to one another, to avoid 'cracks'.
-		*/
-		Real getSplitPadding() const { return mSplitPadding; }
-		/// Get the number of splits. 
-		size_t getSplitCount() const { return mSplitCount; }
-
-		/// Returns a LiSPSM shadow camera with PSSM splits base on iteration.
-		virtual void getShadowCamera(const Ogre::SceneManager *sm, const Ogre::Camera *cam,
-			const Ogre::Viewport *vp, const Ogre::Light *light, Ogre::Camera *texCam, size_t iteration) const;
-
-		/// Returns the calculated split points.
-		inline const SplitPointList& getSplitPoints() const
-		{ return mSplitPoints; }
-
-		/// Returns the optimal adjust factor for a given split.
-		inline Real getOptimalAdjustFactor(size_t splitIndex) const
-		{ return mOptimalAdjustFactors[splitIndex]; }
-
-		/// Overridden, recommended internal use only since depends on current iteration
-		Real getOptimalAdjustFactor() const;
-
-	};
-	/** @} */
-	/** @} */
-}
-#endif

data/deps/include/OGRE/OgreShadowCameraSetupPlaneOptimal.h

@@ -1,88 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 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 __ShadowCameraSetupPlaneOptimal_H__
-#define __ShadowCameraSetupPlaneOptimal_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreShadowCameraSetup.h"
-
-namespace Ogre {
-
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Scene
-	*  @{
-	*/
-	/** 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* mPlane;	///< pointer to plane of interest
-	private:
-		PlaneOptimalShadowCameraSetup() {}	///< Default constructor is private
-
-		/// helper function computing projection matrix given constraints
-		Matrix4 computeConstrainedProjection( const Vector4& pinhole, 
-											  const vector<Vector4>::type& fpoint, 
-											  const vector<Vector2>::type& 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, size_t iteration) const;
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif