Adding ViroKit. Needs AWSCore :(

mobile/ios/ViroKit.framework/Headers/VROQuaternion.h

@@ -0,0 +1,180 @@
+//
+//  VROQuaternion.h
+//  ViroRenderer
+//
+//  Created by Raj Advani on 10/15/15.
+//  Copyright © 2015 Viro Media. All rights reserved.
+//
+
+#ifndef __VROQUATERNION_H_INCLUDED__
+#define __VROQUATERNION_H_INCLUDED__
+
+#include "VROVector3f.h"
+#include "VROMatrix4f.h"
+
+static float kRoundingErrorQuatFloat = 0.00001;
+
+//! Quaternion class for representing rotations.
+/** It provides cheap combinations and avoids gimbal locks.
+Also useful for interpolations. */
+class VROQuaternion {
+	public:
+
+		//! Default Constructor
+		VROQuaternion() noexcept : X(0.0f), Y(0.0f), Z(0.0f), W(1.0f) {}
+
+		//! Constructor
+		VROQuaternion(float x, float y, float z, float w) : X(x), Y(y), Z(z), W(w) { }
+
+		//! Constructor which converts euler angles (radians) to a quaternion
+		VROQuaternion(float x, float y, float z);
+
+		//! Constructor which converts euler angles (radians) to a quaternion
+		VROQuaternion(const VROVector3f& vec);
+
+		//! Constructor which converts a matrix to a quaternion
+		VROQuaternion(const VROMatrix4f& mat);
+
+		//! Equalilty operator
+		bool operator==(const VROQuaternion &other) const;
+
+		//! inequality operator
+		bool operator!=(const VROQuaternion &other) const;
+    
+		//! Matrix assignment operator
+		VROQuaternion& operator=(const VROMatrix4f& other);
+
+		//! Add operator
+		VROQuaternion operator+(const VROQuaternion &other) const;
+    
+        //! Subtract operator
+        VROQuaternion operator-(const VROQuaternion &other) const;
+
+		//! Multiplication operator
+		//! Be careful, unfortunately the operator order here is opposite of that in CVROMatrix4f::operator*
+		VROQuaternion operator*(const VROQuaternion &other) const;
+
+		//! Multiplication operator with scalar
+		VROQuaternion operator*(float s) const;
+
+		//! Multiplication operator with scalar
+		VROQuaternion &operator*=(float s);
+
+		//! Multiplication operator
+		VROVector3f operator*(const VROVector3f& v) const;
+
+		//! Multiplication operator
+		VROQuaternion &operator*=(const VROQuaternion &other);
+
+		//! Calculates the dot product
+		float dotProduct(const VROQuaternion &other) const;
+    
+        // Get the magnitude of the angle represented by this quaternion.
+        float getAngle() const;
+
+		//! Sets new quaternion
+		VROQuaternion &set(float x, float y, float z, float w);
+
+		//! Sets new quaternion based on euler angles (radians)
+		VROQuaternion &set(float x, float y, float z);
+
+		//! Sets new quaternion based on euler angles (radians)
+		VROQuaternion &set(const VROVector3f& vec);
+
+		//! Sets new quaternion from other quaternion
+		VROQuaternion &set(const VROQuaternion &quat);
+
+		//! returns if this quaternion equals the other one, taking floating point rounding errors into account
+		bool equals(const VROQuaternion &other,
+                    const float tolerance = kRoundingErrorQuatFloat ) const;
+
+		//! Normalizes the quaternion
+		VROQuaternion &normalize();
+    
+        // Get the norm of the quaternion
+        float getNorm();
+
+		//! Creates a matrix from this quaternion
+		VROMatrix4f getMatrix() const;
+
+		//! Creates a matrix from this quaternion
+		void getMatrix( VROMatrix4f &dest, const VROVector3f &translation=VROVector3f() ) const;
+
+		/*!
+			Creates a matrix from this quaternion
+			Rotate about a center point
+			shortcut for
+			quaternion q;
+			q.rotationFromTo ( vin[i].Normal, forward );
+			q.getMatrixCenter ( lookat, center, newPos );
+
+			VROMatrix4f m2;
+			m2.setInverseTranslation ( center );
+			lookat *= m2;
+
+			VROMatrix4f m3;
+			m2.setTranslation ( newPos );
+			lookat *= m3;
+
+		*/
+		void getMatrixCenter( VROMatrix4f &dest, const VROVector3f &center, const VROVector3f &translation ) const;
+
+		//! Creates a matrix from this quaternion
+		void getMatrix_transposed( VROMatrix4f &dest ) const;
+
+		//! Inverts this quaternion
+		VROQuaternion &makeInverse();
+
+		//! Set this quaternion to the linear interpolation between two quaternions
+		/** \param q1 First quaternion to be interpolated.
+		\param q2 Second quaternion to be interpolated.
+		\param time Progress of interpolation. For time=0 the result is
+		q1, for time=1 the result is q2. Otherwise interpolation
+		between q1 and q2.
+		*/
+		static VROQuaternion lerp(VROQuaternion q1, VROQuaternion q2, float time);
+
+		//! Set this quaternion to the result of the spherical interpolation between two quaternions
+		/** \param q1 First quaternion to be interpolated.
+		\param q2 Second quaternion to be interpolated.
+		\param time Progress of interpolation. For time=0 the result is
+		q1, for time=1 the result is q2. Otherwise interpolation
+		between q1 and q2.
+		\param threshold To avoid inaccuracies at the end (time=1) the
+		interpolation switches to linear interpolation at some point.
+		This value defines how much of the remaining interpolation will
+		be calculated with lerp. Everything from 1-threshold up will be
+		linear interpolation.
+		*/
+		static VROQuaternion slerp(VROQuaternion q1, VROQuaternion q2,
+                                    float time, float threshold=.05f);
+
+		//! Create quaternion from rotation angle and rotation axis.
+		/** Axis must be unit length.
+		The quaternion representing the rotation is
+		q = cos(A/2)+sin(A/2)*(x*i+y*j+z*k).
+		\param angle Rotation Angle in radians.
+		\param axis Rotation axis. */
+		static VROQuaternion fromAngleAxis (float angle, const VROVector3f& axis);
+
+		//! Fills an angle (radians) around an axis (unit vector)
+		void toAngleAxis (float &angle, VROVector3f& axis) const;
+
+		//! Output this quaternion to an euler angle (radians)
+		VROVector3f toEuler() const;
+
+		//! Set quaternion to identity
+		VROQuaternion &makeIdentity();
+
+		//! Set quaternion to represent a rotation from one vector to another.
+		static VROQuaternion rotationFromTo(const VROVector3f& from, const VROVector3f& to);
+
+		//! Quaternion elements.
+		float X; // vectorial (imaginary) part
+		float Y;
+		float Z;
+		float W; // real part
+};
+
+#endif
+