@reactvision/react-viro 2.41.3

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/glm/gtx/quaternion.hpp

@@ -0,0 +1,185 @@
+/// @ref gtx_quaternion
+/// @file glm/gtx/quaternion.hpp
+///
+/// @see core (dependence)
+/// @see gtx_extented_min_max (dependence)
+///
+/// @defgroup gtx_quaternion GLM_GTX_quaternion
+/// @ingroup gtx
+///
+/// @brief Extented quaternion types and functions
+///
+/// <glm/gtx/quaternion.hpp> need to be included to use these functionalities.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/constants.hpp"
+#include "../gtc/quaternion.hpp"
+#include "../gtx/norm.hpp"
+
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_quaternion extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_quaternion
+	/// @{
+
+	/// Compute a cross product between a quaternion and a vector.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tvec3<T, P> cross(
+		tquat<T, P> const & q,
+		tvec3<T, P> const & v);
+
+	//! Compute a cross product between a vector and a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tvec3<T, P> cross(
+		tvec3<T, P> const & v,
+		tquat<T, P> const & q);
+
+	//! Compute a point on a path according squad equation. 
+	//! q1 and q2 are control points; s1 and s2 are intermediate control points.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> squad(
+		tquat<T, P> const & q1,
+		tquat<T, P> const & q2,
+		tquat<T, P> const & s1,
+		tquat<T, P> const & s2,
+		T const & h);
+
+	//! Returns an intermediate control point for squad interpolation.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> intermediate(
+		tquat<T, P> const & prev,
+		tquat<T, P> const & curr,
+		tquat<T, P> const & next);
+
+	//! Returns a exp of a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> exp(
+		tquat<T, P> const & q);
+
+	//! Returns a log of a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> log(
+		tquat<T, P> const & q);
+
+	/// Returns x raised to the y power.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> pow(
+		tquat<T, P> const & x,
+		T const & y);
+
+	//! Returns quarternion square root.
+	///
+	/// @see gtx_quaternion
+	//template<typename T, precision P>
+	//tquat<T, P> sqrt(
+	//	tquat<T, P> const & q);
+
+	//! Rotates a 3 components vector by a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tvec3<T, P> rotate(
+		tquat<T, P> const & q,
+		tvec3<T, P> const & v);
+
+	/// Rotates a 4 components vector by a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tvec4<T, P> rotate(
+		tquat<T, P> const & q,
+		tvec4<T, P> const & v);
+
+	/// Extract the real component of a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL T extractRealComponent(
+		tquat<T, P> const & q);
+
+	/// Converts a quaternion to a 3 * 3 matrix.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tmat3x3<T, P> toMat3(
+		tquat<T, P> const & x){return mat3_cast(x);}
+
+	/// Converts a quaternion to a 4 * 4 matrix.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tmat4x4<T, P> toMat4(
+		tquat<T, P> const & x){return mat4_cast(x);}
+
+	/// Converts a 3 * 3 matrix to a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> toQuat(
+		tmat3x3<T, P> const & x){return quat_cast(x);}
+
+	/// Converts a 4 * 4 matrix to a quaternion.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> toQuat(
+		tmat4x4<T, P> const & x){return quat_cast(x);}
+
+	/// Quaternion interpolation using the rotation short path.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> shortMix(
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
+		T const & a);
+
+	/// Quaternion normalized linear interpolation.
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> fastMix(
+		tquat<T, P> const & x,
+		tquat<T, P> const & y,
+		T const & a);
+
+	/// Compute the rotation between two vectors.
+	/// param orig vector, needs to be normalized
+	/// param dest vector, needs to be normalized
+	///
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> rotation(
+		tvec3<T, P> const & orig, 
+		tvec3<T, P> const & dest);
+
+	/// Returns the squared length of x.
+	/// 
+	/// @see gtx_quaternion
+	template<typename T, precision P>
+	GLM_FUNC_DECL T length2(tquat<T, P> const & q);
+
+	/// @}
+}//namespace glm
+
+#include "quaternion.inl"

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/glm/gtx/quaternion.inl

@@ -0,0 +1,212 @@
+/// @ref gtx_quaternion
+/// @file glm/gtx/quaternion.inl
+
+#include <limits>
+#include "../gtc/constants.hpp"
+
+namespace glm
+{
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const& v, tquat<T, P> const& q)
+	{
+		return inverse(q) * v;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tquat<T, P> const& q, tvec3<T, P> const& v)
+	{
+		return q * v;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> squad
+	(
+		tquat<T, P> const & q1,
+		tquat<T, P> const & q2,
+		tquat<T, P> const & s1,
+		tquat<T, P> const & s2,
+		T const & h)
+	{
+		return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast<T>(2) * (static_cast<T>(1) - h) * h);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> intermediate
+	(
+		tquat<T, P> const & prev,
+		tquat<T, P> const & curr,
+		tquat<T, P> const & next
+	)
+	{
+		tquat<T, P> invQuat = inverse(curr);
+		return exp((log(next + invQuat) + log(prev + invQuat)) / static_cast<T>(-4)) * curr;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> exp(tquat<T, P> const& q)
+	{
+		tvec3<T, P> u(q.x, q.y, q.z);
+		T const Angle = glm::length(u);
+		if (Angle < epsilon<T>())
+			return tquat<T, P>();
+
+		tvec3<T, P> const v(u / Angle);
+		return tquat<T, P>(cos(Angle), sin(Angle) * v);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> log(tquat<T, P> const& q)
+	{
+		tvec3<T, P> u(q.x, q.y, q.z);
+		T Vec3Len = length(u);
+
+		if (Vec3Len < epsilon<T>())
+		{
+			if(q.w > static_cast<T>(0))
+				return tquat<T, P>(log(q.w), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0));
+			else if(q.w < static_cast<T>(0))
+				return tquat<T, P>(log(-q.w), pi<T>(), static_cast<T>(0), static_cast<T>(0));
+			else
+				return tquat<T, P>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity());
+		}
+		else
+		{
+			T t = atan(Vec3Len, T(q.w)) / Vec3Len;
+			T QuatLen2 = Vec3Len * Vec3Len + q.w * q.w;
+			return tquat<T, P>(static_cast<T>(0.5) * log(QuatLen2), t * q.x, t * q.y, t * q.z);
+		}
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> pow(tquat<T, P> const & x, T const & y)
+	{
+		//Raising to the power of 0 should yield 1
+		//Needed to prevent a division by 0 error later on
+		if(y > -epsilon<T>() && y < epsilon<T>())
+			return tquat<T, P>(1,0,0,0);
+
+		//To deal with non-unit quaternions
+		T magnitude = sqrt(x.x * x.x + x.y * x.y + x.z * x.z + x.w *x.w);
+
+		//Equivalent to raising a real number to a power
+		//Needed to prevent a division by 0 error later on
+		if(abs(x.w / magnitude) > static_cast<T>(1) - epsilon<T>() && abs(x.w / magnitude) < static_cast<T>(1) + epsilon<T>())
+			return tquat<T, P>(pow(x.w, y),0,0,0);
+
+		T Angle = acos(x.w / magnitude);
+		T NewAngle = Angle * y;
+		T Div = sin(NewAngle) / sin(Angle);
+		T Mag = pow(magnitude, y - static_cast<T>(1));
+
+		return tquat<T, P>(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec3<T, P> rotate(tquat<T, P> const& q, tvec3<T, P> const& v)
+	{
+		return q * v;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> rotate(tquat<T, P> const& q, tvec4<T, P> const& v)
+	{
+		return q * v;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T extractRealComponent(tquat<T, P> const& q)
+	{
+		T w = static_cast<T>(1) - q.x * q.x - q.y * q.y - q.z * q.z;
+		if(w < T(0))
+			return T(0);
+		else
+			return -sqrt(w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T length2(tquat<T, P> const& q)
+	{
+		return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> shortMix(tquat<T, P> const& x, tquat<T, P> const& y, T const& a)
+	{
+		if(a <= static_cast<T>(0)) return x;
+		if(a >= static_cast<T>(1)) return y;
+
+		T fCos = dot(x, y);
+		tquat<T, P> y2(y); //BUG!!! tquat<T> y2;
+		if(fCos < static_cast<T>(0))
+		{
+			y2 = -y;
+			fCos = -fCos;
+		}
+
+		//if(fCos > 1.0f) // problem
+		T k0, k1;
+		if(fCos > (static_cast<T>(1) - epsilon<T>()))
+		{
+			k0 = static_cast<T>(1) - a;
+			k1 = static_cast<T>(0) + a; //BUG!!! 1.0f + a;
+		}
+		else
+		{
+			T fSin = sqrt(T(1) - fCos * fCos);
+			T fAngle = atan(fSin, fCos);
+			T fOneOverSin = static_cast<T>(1) / fSin;
+			k0 = sin((static_cast<T>(1) - a) * fAngle) * fOneOverSin;
+			k1 = sin((static_cast<T>(0) + a) * fAngle) * fOneOverSin;
+		}
+
+		return tquat<T, P>(
+			k0 * x.w + k1 * y2.w,
+			k0 * x.x + k1 * y2.x,
+			k0 * x.y + k1 * y2.y,
+			k0 * x.z + k1 * y2.z);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> fastMix(tquat<T, P> const& x, tquat<T, P> const& y, T const & a)
+	{
+		return glm::normalize(x * (static_cast<T>(1) - a) + (y * a));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> rotation(tvec3<T, P> const& orig, tvec3<T, P> const& dest)
+	{
+		T cosTheta = dot(orig, dest);
+		tvec3<T, P> rotationAxis;
+
+		if(cosTheta >= static_cast<T>(1) - epsilon<T>())
+			return quat();
+
+		if(cosTheta < static_cast<T>(-1) + epsilon<T>())
+		{
+			// special case when vectors in opposite directions :
+			// there is no "ideal" rotation axis
+			// So guess one; any will do as long as it's perpendicular to start
+			// This implementation favors a rotation around the Up axis (Y),
+			// since it's often what you want to do.
+			rotationAxis = cross(tvec3<T, P>(0, 0, 1), orig);
+			if(length2(rotationAxis) < epsilon<T>()) // bad luck, they were parallel, try again!
+				rotationAxis = cross(tvec3<T, P>(1, 0, 0), orig);
+
+			rotationAxis = normalize(rotationAxis);
+			return angleAxis(pi<T>(), rotationAxis);
+		}
+
+		// Implementation from Stan Melax's Game Programming Gems 1 article
+		rotationAxis = cross(orig, dest);
+
+		T s = sqrt((T(1) + cosTheta) * static_cast<T>(2));
+		T invs = static_cast<T>(1) / s;
+
+		return tquat<T, P>(
+			s * static_cast<T>(0.5f), 
+			rotationAxis.x * invs,
+			rotationAxis.y * invs,
+			rotationAxis.z * invs);
+	}
+
+}//namespace glm

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/glm/gtx/range.hpp

@@ -0,0 +1,85 @@
+/// @ref gtx_range
+/// @file glm/gtx/range.hpp
+/// @author Joshua Moerman
+///
+/// @defgroup gtx_range GLM_GTX_range
+/// @ingroup gtx
+///
+/// @brief Defines begin and end for vectors and matrices. Useful for range-based for loop.
+/// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements).
+///
+/// <glm/gtx/range.hpp> need to be included to use these functionalities.
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+
+#if !GLM_HAS_RANGE_FOR
+#	error "GLM_GTX_range requires C++11 suppport or 'range for'"
+#endif
+
+#include "../gtc/type_ptr.hpp"
+#include "../gtc/vec1.hpp"
+
+namespace glm
+{
+	/// @addtogroup gtx_range
+	/// @{
+
+	template <typename T, precision P>
+	inline length_t components(tvec1<T, P> const & v)
+	{
+		return v.length();
+	}
+	
+	template <typename T, precision P>
+	inline length_t components(tvec2<T, P> const & v)
+	{
+		return v.length();
+	}
+	
+	template <typename T, precision P>
+	inline length_t components(tvec3<T, P> const & v)
+	{
+		return v.length();
+	}
+	
+	template <typename T, precision P>
+	inline length_t components(tvec4<T, P> const & v)
+	{
+		return v.length();
+	}
+	
+	template <typename genType>
+	inline length_t components(genType const & m)
+	{
+		return m.length() * m[0].length();
+	}
+	
+	template <typename genType>
+	inline typename genType::value_type const * begin(genType const & v)
+	{
+		return value_ptr(v);
+	}
+
+	template <typename genType>
+	inline typename genType::value_type const * end(genType const & v)
+	{
+		return begin(v) + components(v);
+	}
+
+	template <typename genType>
+	inline typename genType::value_type * begin(genType& v)
+	{
+		return value_ptr(v);
+	}
+
+	template <typename genType>
+	inline typename genType::value_type * end(genType& v)
+	{
+		return begin(v) + components(v);
+	}
+
+	/// @}
+}//namespace glm

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/glm/gtx/raw_data.hpp

@@ -0,0 +1,47 @@
+/// @ref gtx_raw_data
+/// @file glm/gtx/raw_data.hpp
+///
+/// @see core (dependence)
+///
+/// @defgroup gtx_raw_data GLM_GTX_raw_data
+/// @ingroup gtx
+///
+/// @brief Projection of a vector to other one
+///
+/// <glm/gtx/raw_data.hpp> need to be included to use these functionalities.
+
+#pragma once
+
+// Dependencies
+#include "../detail/setup.hpp"
+#include "../detail/type_int.hpp"
+
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_raw_data extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_raw_data
+	/// @{
+
+	//! Type for byte numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint8		byte;
+
+	//! Type for word numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint16		word;
+
+	//! Type for dword numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint32		dword;
+
+	//! Type for qword numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef detail::uint64		qword;
+
+	/// @}
+}// namespace glm
+
+#include "raw_data.inl"

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/glm/gtx/raw_data.inl

@@ -0,0 +1,2 @@
+/// @ref gtx_raw_data
+/// @file glm/gtx/raw_data.inl

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/glm/gtx/rotate_normalized_axis.hpp

@@ -0,0 +1,64 @@
+/// @ref gtx_rotate_normalized_axis
+/// @file glm/gtx/rotate_normalized_axis.hpp
+///
+/// @see core (dependence)
+/// @see gtc_matrix_transform
+/// @see gtc_quaternion
+///
+/// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis
+/// @ingroup gtx
+///
+/// @brief Quaternions and matrices rotations around normalized axis.
+///
+/// <glm/gtx/rotate_normalized_axis.hpp> need to be included to use these functionalities.
+
+#pragma once
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/epsilon.hpp"
+#include "../gtc/quaternion.hpp"
+
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
+#	pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included")
+#endif
+
+namespace glm
+{
+	/// @addtogroup gtx_rotate_normalized_axis
+	/// @{
+
+	/// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle. 
+	/// 
+	/// @param m Input matrix multiplied by this rotation matrix.
+	/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param axis Rotation axis, must be normalized.
+	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
+	/// 
+	/// @see gtx_rotate_normalized_axis
+	/// @see - rotate(T angle, T x, T y, T z) 
+	/// @see - rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z) 
+	/// @see - rotate(T angle, tvec3<T, P> const & v) 
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat4x4<T, P> rotateNormalizedAxis(
+		tmat4x4<T, P> const & m,
+		T const & angle,
+		tvec3<T, P> const & axis);
+
+	/// Rotates a quaternion from a vector of 3 components normalized axis and an angle.
+	/// 
+	/// @param q Source orientation
+	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param axis Normalized axis of the rotation, must be normalized.
+	/// 
+	/// @see gtx_rotate_normalized_axis
+	template <typename T, precision P>
+	GLM_FUNC_DECL tquat<T, P> rotateNormalizedAxis(
+		tquat<T, P> const & q,
+		T const & angle,
+		tvec3<T, P> const & axis);
+
+	/// @}
+}//namespace glm
+
+#include "rotate_normalized_axis.inl"

package/ios/dist/ViroRenderer/armv7_arm64/ViroKit.framework/Headers/glm/gtx/rotate_normalized_axis.inl

@@ -0,0 +1,59 @@
+/// @ref gtx_rotate_normalized_axis
+/// @file glm/gtx/rotate_normalized_axis.inl
+
+namespace glm
+{
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotateNormalizedAxis
+	(
+		tmat4x4<T, P> const & m,
+		T const & angle,
+		tvec3<T, P> const & v
+	)
+	{
+		T const a = angle;
+		T const c = cos(a);
+		T const s = sin(a);
+
+		tvec3<T, P> const axis(v);
+
+		tvec3<T, P> const temp((static_cast<T>(1) - c) * axis);
+
+		tmat4x4<T, P> Rotate(uninitialize);
+		Rotate[0][0] = c + temp[0] * axis[0];
+		Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+		Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+
+		Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+		Rotate[1][1] = c + temp[1] * axis[1];
+		Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+
+		Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+		Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+		Rotate[2][2] = c + temp[2] * axis[2];
+
+		tmat4x4<T, P> Result(uninitialize);
+		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+		Result[3] = m[3];
+		return Result;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tquat<T, P> rotateNormalizedAxis
+	(
+		tquat<T, P> const & q, 
+		T const & angle,
+		tvec3<T, P> const & v
+	)
+	{
+		tvec3<T, P> const Tmp(v);
+
+		T const AngleRad(angle);
+		T const Sin = sin(AngleRad * T(0.5));
+
+		return q * tquat<T, P>(cos(AngleRad * static_cast<T>(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
+		//return gtc::quaternion::cross(q, tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
+	}
+}//namespace glm