ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreSerializer.h

@@ -0,0 +1,120 @@
+/*
+-----------------------------------------------------------------------------
+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 __Serializer_H__
+#define __Serializer_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreString.h"
+#include "OgreDataStream.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+	/** 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 SerializerAlloc
+    {
+    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;
+        DataStreamPtr mStream;
+        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/deps/include/OGRE/OgreShadowCameraSetup.h

@@ -0,0 +1,107 @@
+/*
+-----------------------------------------------------------------------------
+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 __ShadowCameraSetup_H__
+#define __ShadowCameraSetup_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreMovablePlane.h"
+#include "OgreSharedPtr.h"
+
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	/** 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 ShadowDataAlloc
+	{
+	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, size_t iteration) 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, size_t iteration) const;
+	};
+
+
+
+	typedef SharedPtr<ShadowCameraSetup> ShadowCameraSetupPtr;
+	/** @} */
+	/** @} */
+
+}
+
+#endif

data/deps/include/OGRE/OgreShadowCameraSetupFocused.h

@@ -0,0 +1,289 @@
+/*
+-----------------------------------------------------------------------------
+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 __ShadowCameraSetupFocused_H__
+#define __ShadowCameraSetupFocused_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreShadowCameraSetup.h"
+#include "OgrePolygon.h"
+#include "OgreConvexBody.h"
+
+
+namespace Ogre {
+
+	class ConvexBody;
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	/** 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, 
+				Real extrudeDist, 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 receiverAABB: bounding information for just the receivers
+		@param out_bodyB: final intersection bodyB point list
+		*/
+		void calculateB(const SceneManager& sm, const Camera& cam, const Light& light, 
+			const AxisAlignedBox& sceneBB, const AxisAlignedBox& receiverBB, 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, size_t iteration) const;
+
+		/** Sets whether or not to use the more aggressive 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 aggressive version.
+		@param aggressive True to use the more aggressive approach, false otherwise.
+		*/
+		void setUseAggressiveFocusRegion(bool aggressive) { mUseAggressiveRegion = aggressive; }
+
+		bool getUseAggressiveFocusRegion() const { return mUseAggressiveRegion; }
+
+	};
+
+	/** @} */
+	/** @} */
+
+}
+
+#endif