RubyGems - ruby-ogre - Versions diffs - 0.0.5-x86-linux → 0.1.0-x86-linux - Mend

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

Files changed (1620) hide show

data/deps/include/OGRE/OgreSearchOps.h DELETED

@@ -1,69 +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 __SearchOps_H_
-#define __SearchOps_H_
-// 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_ARCH   0x20  /* Archive file */
-#endif
-#define _A_SUBDIR 0x10  /* Subdirectory */
-intptr_t _findfirst(const char *pattern, struct _finddata_t *data);
-int _findnext(intptr_t id, struct _finddata_t *data);
-int _findclose(intptr_t id);
-#endif

data/deps/include/OGRE/OgreSerializer.h DELETED

@@ -1,120 +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 __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 DELETED

@@ -1,107 +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 __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 DELETED

@@ -1,289 +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 __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