ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreQuaternion.h

@@ -0,0 +1,330 @@
+/*
+-----------------------------------------------------------------------------
+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.
+-----------------------------------------------------------------------------
+*/
+// This file is based on material originally from:
+// Geometric Tools, LLC
+// Copyright (c) 1998-2010
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
+
+
+#ifndef __Quaternion_H__
+#define __Quaternion_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreMath.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Math
+	*  @{
+	*/
+	/** Implementation of a Quaternion, i.e. a rotation around an axis.
+		For more information about Quaternions and the theory behind it, we recommend reading:
+		http://www.ogre3d.org/tikiwiki/Quaternion+and+Rotation+Primer
+		http://www.cprogramming.com/tutorial/3d/quaternions.html
+		http://www.gamedev.net/page/resources/_/reference/programming/math-and-physics/
+		quaternions/quaternion-powers-r1095
+    */
+    class _OgreExport Quaternion
+    {
+    public:
+		/// Default constructor, initializes to identity rotation (aka 0°)
+		inline Quaternion ()
+			: w(1), x(0), y(0), z(0)
+		{
+		}
+		/// Construct from an explicit list of values
+		inline Quaternion (
+			Real fW,
+			Real fX, Real fY, Real fZ)
+			: w(fW), x(fX), y(fY), z(fZ)
+		{
+		}
+        /// Construct a quaternion from a rotation matrix
+        inline Quaternion(const Matrix3& rot)
+        {
+            this->FromRotationMatrix(rot);
+        }
+        /// Construct a quaternion from an angle/axis
+        inline Quaternion(const Radian& rfAngle, const Vector3& rkAxis)
+        {
+            this->FromAngleAxis(rfAngle, rkAxis);
+        }
+        /// Construct a quaternion from 3 orthonormal local axes
+        inline Quaternion(const Vector3& xaxis, const Vector3& yaxis, const Vector3& zaxis)
+        {
+            this->FromAxes(xaxis, yaxis, zaxis);
+        }
+        /// Construct a quaternion from 3 orthonormal local axes
+        inline Quaternion(const Vector3* akAxis)
+        {
+            this->FromAxes(akAxis);
+        }
+		/// Construct a quaternion from 4 manual w/x/y/z values
+		inline Quaternion(Real* valptr)
+		{
+			memcpy(&w, valptr, sizeof(Real)*4);
+		}
+
+		/** Exchange the contents of this quaternion with another. 
+		*/
+		inline void swap(Quaternion& other)
+		{
+			std::swap(w, other.w);
+			std::swap(x, other.x);
+			std::swap(y, other.y);
+			std::swap(z, other.z);
+		}
+
+		/// Array accessor operator
+		inline Real operator [] ( const size_t i ) const
+		{
+			assert( i < 4 );
+
+			return *(&w+i);
+		}
+
+		/// Array accessor operator
+		inline Real& operator [] ( const size_t i )
+		{
+			assert( i < 4 );
+
+			return *(&w+i);
+		}
+
+		/// Pointer accessor for direct copying
+		inline Real* ptr()
+		{
+			return &w;
+		}
+
+		/// Pointer accessor for direct copying
+		inline const Real* ptr() const
+		{
+			return &w;
+		}
+
+		void FromRotationMatrix (const Matrix3& kRot);
+        void ToRotationMatrix (Matrix3& kRot) const;
+		/** Setups the quaternion using the supplied vector, and "roll" around
+			that vector by the specified radians.
+		*/
+        void FromAngleAxis (const Radian& rfAngle, const Vector3& rkAxis);
+        void ToAngleAxis (Radian& rfAngle, Vector3& rkAxis) const;
+        inline void ToAngleAxis (Degree& dAngle, Vector3& rkAxis) const {
+            Radian rAngle;
+            ToAngleAxis ( rAngle, rkAxis );
+            dAngle = rAngle;
+        }
+		/** Constructs the quaternion using 3 axes, the axes are assumed to be orthonormal
+			@see FromAxes
+		*/
+        void FromAxes (const Vector3* akAxis);
+        void FromAxes (const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis);
+		/** Gets the 3 orthonormal axes defining the quaternion. @see FromAxes */
+        void ToAxes (Vector3* akAxis) const;
+        void ToAxes (Vector3& xAxis, Vector3& yAxis, Vector3& zAxis) const;
+
+		/** Returns the X orthonormal axis defining the quaternion. Same as doing
+			xAxis = Vector3::UNIT_X * this. Also called the local X-axis
+		*/
+        Vector3 xAxis(void) const;
+
+        /** Returns the Y orthonormal axis defining the quaternion. Same as doing
+			yAxis = Vector3::UNIT_Y * this. Also called the local Y-axis
+		*/
+        Vector3 yAxis(void) const;
+
+		/** Returns the Z orthonormal axis defining the quaternion. Same as doing
+			zAxis = Vector3::UNIT_Z * this. Also called the local Z-axis
+		*/
+        Vector3 zAxis(void) const;
+
+        inline Quaternion& operator= (const Quaternion& rkQ)
+		{
+			w = rkQ.w;
+			x = rkQ.x;
+			y = rkQ.y;
+			z = rkQ.z;
+			return *this;
+		}
+        Quaternion operator+ (const Quaternion& rkQ) const;
+        Quaternion operator- (const Quaternion& rkQ) const;
+        Quaternion operator* (const Quaternion& rkQ) const;
+        Quaternion operator* (Real fScalar) const;
+        _OgreExport friend Quaternion operator* (Real fScalar,
+            const Quaternion& rkQ);
+        Quaternion operator- () const;
+        inline bool operator== (const Quaternion& rhs) const
+		{
+			return (rhs.x == x) && (rhs.y == y) &&
+				(rhs.z == z) && (rhs.w == w);
+		}
+        inline bool operator!= (const Quaternion& rhs) const
+		{
+			return !operator==(rhs);
+		}
+        // functions of a quaternion
+        /// Returns the dot product of the quaternion
+        Real Dot (const Quaternion& rkQ) const;
+        /* Returns the normal length of this quaternion.
+            @note This does <b>not</b> alter any values.
+        */
+        Real Norm () const;
+        /// Normalises this quaternion, and returns the previous length
+        Real normalise(void); 
+        Quaternion Inverse () const;  // apply to non-zero quaternion
+        Quaternion UnitInverse () const;  // apply to unit-length quaternion
+        Quaternion Exp () const;
+        Quaternion Log () const;
+
+        /// Rotation of a vector by a quaternion
+        Vector3 operator* (const Vector3& rkVector) const;
+
+   		/** Calculate the local roll element of this quaternion.
+		@param reprojectAxis By default the method returns the 'intuitive' result
+			that is, if you projected the local Y of the quaternion onto the X and
+			Y axes, the angle between them is returned. If set to false though, the
+			result is the actual yaw that will be used to implement the quaternion,
+			which is the shortest possible path to get to the same orientation and 
+             may involve less axial rotation.  The co-domain of the returned value is 
+             from -180 to 180 degrees.
+		*/
+		Radian getRoll(bool reprojectAxis = true) const;
+   		/** Calculate the local pitch element of this quaternion
+		@param reprojectAxis By default the method returns the 'intuitive' result
+			that is, if you projected the local Z of the quaternion onto the X and
+			Y axes, the angle between them is returned. If set to true though, the
+			result is the actual yaw that will be used to implement the quaternion,
+			which is the shortest possible path to get to the same orientation and 
+            may involve less axial rotation.  The co-domain of the returned value is 
+            from -180 to 180 degrees.
+		*/
+		Radian getPitch(bool reprojectAxis = true) const;
+   		/** Calculate the local yaw element of this quaternion
+		@param reprojectAxis By default the method returns the 'intuitive' result
+			that is, if you projected the local Y of the quaternion onto the X and
+			Z axes, the angle between them is returned. If set to true though, the
+			result is the actual yaw that will be used to implement the quaternion,
+			which is the shortest possible path to get to the same orientation and 
+			may involve less axial rotation. The co-domain of the returned value is 
+            from -180 to 180 degrees.
+		*/
+		Radian getYaw(bool reprojectAxis = true) const;		
+		/// Equality with tolerance (tolerance is max angle difference)
+		bool equals(const Quaternion& rhs, const Radian& tolerance) const;
+		
+	    /** Performs Spherical linear interpolation between two quaternions, and returns the result.
+			Slerp ( 0.0f, A, B ) = A
+			Slerp ( 1.0f, A, B ) = B
+			@return Interpolated quaternion
+			@remarks
+			Slerp has the proprieties of performing the interpolation at constant
+			velocity, and being torque-minimal (unless shortestPath=false).
+			However, it's NOT commutative, which means
+			Slerp ( 0.75f, A, B ) != Slerp ( 0.25f, B, A );
+			therefore be careful if your code relies in the order of the operands.
+			This is specially important in IK animation.
+		*/
+        static Quaternion Slerp (Real fT, const Quaternion& rkP,
+            const Quaternion& rkQ, bool shortestPath = false);
+
+		/** @see Slerp. It adds extra "spins" (i.e. rotates several times) specified
+			by parameter 'iExtraSpins' while interpolating before arriving to the
+			final values
+		*/
+        static Quaternion SlerpExtraSpins (Real fT,
+            const Quaternion& rkP, const Quaternion& rkQ,
+            int iExtraSpins);
+
+        // setup for spherical quadratic interpolation
+        static void Intermediate (const Quaternion& rkQ0,
+            const Quaternion& rkQ1, const Quaternion& rkQ2,
+            Quaternion& rka, Quaternion& rkB);
+
+        // spherical quadratic interpolation
+        static Quaternion Squad (Real fT, const Quaternion& rkP,
+            const Quaternion& rkA, const Quaternion& rkB,
+            const Quaternion& rkQ, bool shortestPath = false);
+
+        /** Performs Normalised linear interpolation between two quaternions, and returns the result.
+			nlerp ( 0.0f, A, B ) = A
+			nlerp ( 1.0f, A, B ) = B
+			@remarks
+			Nlerp is faster than Slerp.
+			Nlerp has the proprieties of being commutative (@see Slerp;
+			commutativity is desired in certain places, like IK animation), and
+			being torque-minimal (unless shortestPath=false). However, it's performing
+			the interpolation at non-constant velocity; sometimes this is desired,
+			sometimes it is not. Having a non-constant velocity can produce a more
+			natural rotation feeling without the need of tweaking the weights; however
+			if your scene relies on the timing of the rotation or assumes it will point
+			at a specific angle at a specific weight value, Slerp is a better choice.
+		*/
+        static Quaternion nlerp(Real fT, const Quaternion& rkP, 
+            const Quaternion& rkQ, bool shortestPath = false);
+
+        /// Cutoff for sine near zero
+        static const Real msEpsilon;
+
+        // special values
+        static const Quaternion ZERO;
+        static const Quaternion IDENTITY;
+
+		Real w, x, y, z;
+
+		/// Check whether this quaternion contains valid values
+		inline bool isNaN() const
+		{
+			return Math::isNaN(x) || Math::isNaN(y) || Math::isNaN(z) || Math::isNaN(w);
+		}
+
+        /** Function for writing to a stream. Outputs "Quaternion(w, x, y, z)" with w,x,y,z
+            being the member values of the quaternion.
+        */
+        inline _OgreExport friend std::ostream& operator <<
+            ( std::ostream& o, const Quaternion& q )
+        {
+            o << "Quaternion(" << q.w << ", " << q.x << ", " << q.y << ", " << q.z << ")";
+            return o;
+        }
+
+    };
+	/** @} */
+	/** @} */
+
+}
+
+
+
+
+#endif 

data/deps/include/OGRE/OgreRadixSort.h

@@ -0,0 +1,330 @@
+/*
+-----------------------------------------------------------------------------
+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 __RadixSort_H__
+#define __RadixSort_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+	/** Class for performing a radix sort (fast comparison-less sort based on 
+		byte value) on various standard STL containers. 
+	@remarks
+		A radix sort is a very fast sort algorithm. It doesn't use comparisons
+		and thus is able to break the theoretical minimum O(N*logN) complexity. 
+		Radix sort is complexity O(k*N), where k is a constant. Note that radix
+		sorting is not in-place, it requires additional storage, so it trades
+		memory for speed. The overhead of copying means that it is only faster
+		for fairly large datasets, so you are advised to only use it for collections
+		of at least a few hundred items.
+	@par
+		This is a template class to allow it to deal with a variety of containers, 
+		and a variety of value types to sort on. In addition to providing the
+		container and value type on construction, you also need to supply a 
+		functor object which will retrieve the value to compare on for each item
+		in the list. For example, if you had an std::vector of by-value instances
+		of an object of class 'Bibble', and you wanted to sort on 
+		Bibble::getDoobrie(), you'd have to firstly create a functor
+		like this:
+	@code
+		struct BibbleSortFunctor
+		{
+			float operator()(const Bibble& val) const
+			{
+				return val.getDoobrie();
+			}
+		}
+	@endcode
+		Then, you need to declare a RadixSort class which names the container type, 
+		the value type in the container, and the type of the value you want to 
+		sort by. You can then call the sort function. E.g.
+	@code
+		RadixSort<BibbleList, Bibble, float> radixSorter;
+		BibbleSortFunctor functor;
+
+		radixSorter.sort(myBibbleList, functor);
+	@endcode
+		You should try to reuse RadixSort instances, since repeated allocation of the 
+		internal storage is then avoided.
+	@note
+		Radix sorting is often associated with just unsigned integer values. Our
+		implementation can handle both unsigned and signed integers, as well as
+		floats (which are often not supported by other radix sorters). doubles
+		are not supported; you will need to implement your functor object to convert
+		to float if you wish to use this sort routine.
+	*/
+	template <class TContainer, class TContainerValueType, typename TCompValueType>
+	class RadixSort
+	{
+	public:
+		typedef typename TContainer::iterator ContainerIter;
+	protected:
+		/// Alpha-pass counters of values (histogram)
+		/// 4 of them so we can radix sort a maximum of a 32bit value
+		int mCounters[4][256];
+		/// Beta-pass offsets 
+		int mOffsets[256];
+		/// Sort area size
+		int mSortSize;
+		/// Number of passes for this type
+		int mNumPasses;
+
+		struct SortEntry
+		{
+			TCompValueType key;
+			ContainerIter iter;
+			SortEntry() {}
+			SortEntry(TCompValueType k, ContainerIter it)
+				: key(k), iter(it) {}
+
+		};
+		/// Temp sort storage
+		typedef std::vector<SortEntry, STLAllocator<SortEntry, GeneralAllocPolicy> > SortVector; 
+		SortVector mSortArea1;
+		SortVector mSortArea2;
+		SortVector* mSrc;
+		SortVector* mDest;
+		TContainer mTmpContainer; // initial copy
+
+
+		void sortPass(int byteIndex)
+		{
+			// Calculate offsets
+			// Basically this just leaves gaps for duplicate entries to fill
+			mOffsets[0] = 0;
+			for (int i = 1; i < 256; ++i)
+			{
+				mOffsets[i] = mOffsets[i-1] + mCounters[byteIndex][i-1];
+			}
+
+			// Sort pass
+			for (int i = 0; i < mSortSize; ++i)
+			{
+				unsigned char byteVal = getByte(byteIndex, (*mSrc)[i].key);
+				(*mDest)[mOffsets[byteVal]++] = (*mSrc)[i];
+			}
+
+		}
+		template <typename T>
+		void finalPass(int byteIndex, T val)
+		{
+			// default is to do normal pass
+			sortPass(byteIndex);
+		}
+		
+		// special case signed int
+		void finalPass(int byteIndex, int val)
+		{
+			int numNeg = 0;
+			// all negative values are in entries 128+ in most significant byte
+			for (int i = 128; i < 256; ++i)
+			{
+				numNeg += mCounters[byteIndex][i];
+			}
+			// Calculate offsets - positive ones start at the number of negatives
+			// do positive numbers
+			mOffsets[0] = numNeg;
+			for (int i = 1; i < 128; ++i)
+			{
+				mOffsets[i] = mOffsets[i-1] + mCounters[byteIndex][i-1];
+			}
+			// Do negative numbers (must start at zero)
+			// No need to invert ordering, already correct (-1 is highest number)
+			mOffsets[128] = 0;
+			for (int i = 129; i < 256; ++i)
+			{
+				mOffsets[i] = mOffsets[i-1] + mCounters[byteIndex][i-1];
+			}
+
+			// Sort pass
+			for (int i = 0; i < mSortSize; ++i)
+			{
+				unsigned char byteVal = getByte(byteIndex, (*mSrc)[i].key);
+				(*mDest)[mOffsets[byteVal]++] = (*mSrc)[i];
+			}
+		}
+		
+
+		// special case float
+		void finalPass(int byteIndex, float val)
+		{
+			// floats need to be special cased since negative numbers will come
+			// after positives (high bit = sign) and will be in reverse order
+			// (no ones-complement of the +ve value)
+			int numNeg = 0;
+			// all negative values are in entries 128+ in most significant byte
+			for (int i = 128; i < 256; ++i)
+			{
+				numNeg += mCounters[byteIndex][i];
+			}
+			// Calculate offsets - positive ones start at the number of negatives
+			// do positive numbers normally
+			mOffsets[0] = numNeg;
+			for (int i = 1; i < 128; ++i)
+			{
+				mOffsets[i] = mOffsets[i-1] + mCounters[byteIndex][i-1];
+			}
+			// Do negative numbers (must start at zero)
+			// Also need to invert ordering
+			// In order to preserve the stability of the sort (essential since
+			// we rely on previous bytes already being sorted) we have to count
+			// backwards in our offsets from 
+			mOffsets[255] = mCounters[byteIndex][255];
+			for (int i = 254; i > 127; --i)
+			{
+				mOffsets[i] = mOffsets[i+1] + mCounters[byteIndex][i];
+			}
+
+			// Sort pass
+			for (int i = 0; i < mSortSize; ++i)
+			{
+				unsigned char byteVal = getByte(byteIndex, (*mSrc)[i].key);
+				if (byteVal > 127)
+				{
+					// -ve; pre-decrement since offsets set to count
+					(*mDest)[--mOffsets[byteVal]] = (*mSrc)[i];
+				}
+				else
+				{
+					// +ve
+					(*mDest)[mOffsets[byteVal]++] = (*mSrc)[i];
+				}
+			}
+		}
+
+		inline unsigned char getByte(int byteIndex, TCompValueType val)
+		{
+#if OGRE_ENDIAN == OGRE_ENDIAN_LITTLE
+			return ((unsigned char*)(&val))[byteIndex];
+#else
+			return ((unsigned char*)(&val))[mNumPasses - byteIndex - 1];
+#endif
+		}
+
+	public:
+
+		RadixSort() {}
+		~RadixSort() {}
+
+		/** Main sort function
+		@param container A container of the type you declared when declaring
+		@param func A functor which returns the value for comparison when given
+			a container value
+		*/
+		template <class TFunction>
+		void sort(TContainer& container, TFunction func)
+		{
+			if (container.empty())
+				return;
+
+			// Set up the sort areas
+			mSortSize = static_cast<int>(container.size());
+			mSortArea1.resize(container.size());
+			mSortArea2.resize(container.size());
+
+			// Copy data now (we need constant iterators for sorting)
+			mTmpContainer = container;
+
+			mNumPasses = sizeof(TCompValueType);
+
+			// Counter pass
+			// Initialise the counts
+			int p;
+			for (p = 0; p < mNumPasses; ++p)
+				memset(mCounters[p], 0, sizeof(int) * 256);
+
+			// Perform alpha pass to count
+			ContainerIter i = mTmpContainer.begin();
+			TCompValueType prevValue = func.operator()(*i); 
+			bool needsSorting = false;
+			for (int u = 0; i != mTmpContainer.end(); ++i, ++u)
+			{
+				// get sort value
+				TCompValueType val = func.operator()(*i);
+				// cheap check to see if needs sorting (temporal coherence)
+				if (!needsSorting && val < prevValue)
+					needsSorting = true;
+
+				// Create a sort entry
+				mSortArea1[u].key = val;
+				mSortArea1[u].iter = i;
+
+				// increase counters
+				for (p = 0; p < mNumPasses; ++p)
+				{
+					unsigned char byteVal = getByte(p, val);
+					mCounters[p][byteVal]++;
+				}
+
+				prevValue = val;
+
+			}
+
+			// early exit if already sorted
+			if (!needsSorting)
+				return;
+
+
+			// Sort passes
+			mSrc = &mSortArea1;
+			mDest = &mSortArea2;
+
+			for (p = 0; p < mNumPasses - 1; ++p)
+			{
+				sortPass(p);
+				// flip src/dst
+				SortVector* tmp = mSrc;
+				mSrc = mDest;
+				mDest = tmp;
+			}
+			// Final pass may differ, make polymorphic
+			finalPass(p, prevValue);
+
+			// Copy everything back
+			int c = 0;
+			for (i = container.begin(); 
+				i != container.end(); ++i, ++c)
+			{
+				*i = *((*mDest)[c].iter);
+			}
+		}
+
+	};
+
+	/** @} */
+	/** @} */
+
+}
+#endif
+