+Unity Runtime codeHEADmaster

1 files changed, 2391 insertions, 0 deletions

diff --git a/Runtime/Export/Math.txt b/Runtime/Export/Math.txt
new file mode 100644
index 0000000..6dbd21f
--- /dev/null
+++ b/Runtime/Export/Math.txt
@@ -0,0 +1,2391 @@
+C++RAW
+
+#include "UnityPrefix.h"
+#include "Runtime/Math/Quaternion.h"
+#include "Runtime/Utilities/Utility.h"
+#include "Runtime/Geometry/AABB.h"
+#include "Runtime/Geometry/Ray.h"
+#include "Runtime/Geometry/Ray2D.h"
+#include "Runtime/Geometry/Intersection.h"
+#include <vector>
+#include "Runtime/Utilities/BitUtility.h"
+#include "Runtime/Terrain/PerlinNoise.h"
+#include "Runtime/Camera/CameraUtil.h"
+#include "Runtime/Math/Color.h"
+#include "Runtime/Math/ColorSpaceConversion.h"
+#include "Runtime/Scripting/ScriptingUtility.h"
+
+CSRAW
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace UnityEngine
+{
+
+// Representation of 2D vectors and points.
+THREAD_SAFE
+STRUCT Vector2
+	// X component of the vector.
+	CSRAW public float x;
+	// Y component of the vector.
+	CSRAW public float y;
+	
+	// Access the /x/ or /y/ component using [0] or [1] respectively.
+	CSRAW public float this [int index]
+	{
+		get
+		{
+			switch(index)
+			{
+				case 0: return x;
+				case 1: return y;
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector2 index!");
+			}
+		}
+
+		set
+		{
+			switch(index)
+			{
+				case 0: x = value; break;
+				case 1: y = value; break;
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector2 index!");
+			}
+		}
+	}
+	
+	// Constructs a new vector with given x, y components.
+	public Vector2 (float x, float y) { this.x = x; this.y = y; }
+	
+	// Set x and y components of an existing Vector2.
+	CSRAW public void Set (float new_x, float new_y) { x = new_x; y = new_y; }
+	
+	// Linearly interpolates between two vectors.
+	CSRAW public static Vector2 Lerp (Vector2 from, Vector2 to, float t) 
+	{ 
+		t = Mathf.Clamp01 (t);
+		return new Vector2( 
+			from.x + (to.x - from.x)*t,
+			from.y + (to.y - from.y)*t
+		);
+	}
+	
+	// Moves a point /current/ towards /target/.
+	CSRAW static public Vector2 MoveTowards (Vector2 current, Vector2 target, float maxDistanceDelta)
+	{
+		Vector2 toVector = target - current;
+		float dist = toVector.magnitude;
+		if (dist <= maxDistanceDelta || dist == 0)
+			return target;
+		return current + toVector / dist * maxDistanceDelta;
+	}
+	
+	// Multiplies two vectors component-wise.
+	CSRAW public static Vector2 Scale (Vector2 a, Vector2 b) { return new Vector2 (a.x*b.x, a.y*b.y); }
+	
+	// Multiplies every component of this vector by the same component of /scale/.
+	CSRAW public void Scale (Vector2 scale) { x *= scale.x; y *= scale.y; }
+	
+	// Makes this vector have a ::ref::magnitude of 1.
+	CSRAW public void Normalize ()
+	{
+		float mag = this.magnitude;
+		if (mag > kEpsilon)
+			this = this / mag;
+		else
+			this = zero;
+	}
+	
+	// Returns this vector with a ::ref::magnitude of 1 (RO).
+	CSRAW public Vector2 normalized { get {
+		Vector2 v = new Vector2(x, y);
+		v.Normalize();
+		return v;
+	} }
+	
+	/// *listonly*
+	CSRAW override public string ToString() { return UnityString.Format("({0:F1}, {1:F1})", x, y); }
+	// Returns a nicely formatted string for this vector.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("({0}, {1})", x.ToString(format), y.ToString(format));
+	}
+	
+	// used to allow Vector2s to be used as keys in hash tables
+	public override int GetHashCode() {
+		return x.GetHashCode() ^ (y.GetHashCode()<<2);
+	}
+	
+	// also required for being able to use Vector2s as keys in hash tables
+	public override bool Equals(object other) {
+		if(!(other is Vector2)) return false;
+		
+		Vector2 rhs=(Vector2)other;
+		return x.Equals(rhs.x) && y.Equals(rhs.y);
+	}
+
+	// Dot Product of two vectors.
+	public static float Dot (Vector2 lhs, Vector2 rhs) { return lhs.x*rhs.x + lhs.y*rhs.y; }
+
+	// Returns the length of this vector (RO).
+	CSRAW public float magnitude { get { return Mathf.Sqrt (x*x + y*y); } }
+	// Returns the squared length of this vector (RO).
+	CSRAW public float sqrMagnitude { get { return x*x + y*y; } }
+	
+	// Returns the angle in degrees between /from/ and /to/.
+	CSRAW public static float Angle(Vector2 from, Vector2 to) { return Mathf.Acos(Mathf.Clamp (Vector2.Dot (from.normalized, to.normalized), -1F, 1F)) * Mathf.Rad2Deg; }
+	
+	// Returns the distance between /a/ and /b/.
+	CSRAW public static float Distance (Vector2 a, Vector2 b) { return (a-b).magnitude; }
+	
+	// Returns a copy of /vector/ with its magnitude clamped to /maxLength/.
+	CSRAW public static Vector2 ClampMagnitude (Vector2 vector, float maxLength)
+	{
+		if (vector.sqrMagnitude > maxLength * maxLength)
+			return vector.normalized * maxLength;
+		return vector;
+	}
+	
+	OBSOLETE planned Use Vector2.sqrMagnitude
+	CSRAW public static float SqrMagnitude (Vector2 a) { return a.x*a.x + a.y*a.y; }
+	OBSOLETE planned Use .sqrMagnitude
+	CSRAW public float SqrMagnitude () { return x*x + y*y; }
+	
+	// Returns a vector that is made from the smallest components of two vectors.
+	CSRAW public static Vector2 Min (Vector2 lhs, Vector2 rhs) { return new Vector2 (Mathf.Min(lhs.x,rhs.x), Mathf.Min(lhs.y,rhs.y)); }
+	
+	// Returns a vector that is made from the largest components of two vectors.
+	CSRAW public static Vector2 Max (Vector2 lhs, Vector2 rhs) { return new Vector2 (Mathf.Max(lhs.x,rhs.x), Mathf.Max(lhs.y,rhs.y)); }
+	
+	// Adds two vectors.
+	CSRAW public static Vector2 operator + (Vector2 a, Vector2 b) { return new Vector2 (a.x+b.x, a.y+b.y); }
+	// Subtracts one vector from another.
+	CSRAW public static Vector2 operator - (Vector2 a, Vector2 b) { return new Vector2 (a.x-b.x, a.y-b.y); }
+	// Negates a vector.
+	CSRAW public static Vector2 operator - (Vector2 a) { return new Vector2 (-a.x, -a.y); }
+	// Multiplies a vector by a number.
+	CSRAW public static Vector2 operator * (Vector2 a, float d) { return new Vector2 (a.x*d, a.y*d); }
+	// Multiplies a vector by a number.
+	CSRAW public static Vector2 operator * (float d, Vector2 a) { return new Vector2 (a.x*d, a.y*d); }
+	// Divides a vector by a number.
+	CSRAW public static Vector2 operator / (Vector2 a, float d) { return new Vector2 (a.x/d, a.y/d); }
+	// Returns true if the vectors are equal.
+	CSRAW public static bool operator == (Vector2 lhs, Vector2 rhs) {
+		return SqrMagnitude (lhs - rhs) < kEpsilon * kEpsilon;
+	}
+	// Returns true if vectors different.
+	CSRAW public static bool operator != (Vector2 lhs, Vector2 rhs)
+	{
+		return SqrMagnitude (lhs - rhs) >= kEpsilon * kEpsilon;
+	}
+	
+	// Converts a [[Vector3]] to a Vector2.
+	CSRAW public static implicit operator Vector2(Vector3 v) {
+		return new Vector2(v.x, v.y);
+	}
+	// Converts a Vector2 to a [[Vector3]].
+	CSRAW public static implicit operator Vector3(Vector2 v) {
+		return new Vector3(v.x, v.y, 0);
+	}
+	
+	// Shorthand for writing @@Vector2(0, 0)@@
+	CSRAW public static Vector2 zero { get { return new Vector2 (0.0F, 0.0F); } }
+	// Shorthand for writing @@Vector2(1, 1)@@
+	CSRAW public static Vector2 one { get { return new Vector2 (1.0F, 1.0F); }   }
+	// Shorthand for writing @@Vector2(0, 1)@@
+	CSRAW public static Vector2 up { get { return new Vector2 (0.0F, 1.0F); } }
+	// Shorthand for writing @@Vector2(1, 0)@@
+	CSRAW public static Vector2 right { get { return new Vector2 (1.0F, 0.0F); } }
+
+	// *Undocumented*
+	CSRAW public const float kEpsilon = 0.00001F;
+END
+
+
+// Representation of 3D vectors and points.
+CSRAW
+THREAD_SAFE
+STRUCT Vector3
+
+	// *undocumented*
+	CSRAW public const float kEpsilon = 0.00001F;
+
+	// X component of the vector.
+	CSRAW public float x;
+	// Y component of the vector.
+	CSRAW public float y;
+	// Z component of the vector.
+	CSRAW public float z;
+
+
+	// Linearly interpolates between two vectors.
+	CSRAW public static Vector3 Lerp (Vector3 from, Vector3 to, float t) 
+	{ 
+		t = Mathf.Clamp01 (t);       
+		return new Vector3( 
+			from.x + (to.x - from.x)*t, 
+			from.y + (to.y - from.y)*t, 
+			from.z + (to.z - from.z)*t 
+		); 
+	 }
+
+
+	// Spherically interpolates between two vectors.
+	CUSTOM static Vector3 Slerp (Vector3 from, Vector3 to, float t) { return Slerp (from, to, clamp01 (t)); }
+
+
+	CUSTOM private static void Internal_OrthoNormalize2 (ref Vector3 a, ref Vector3 b) { OrthoNormalize (&a, &b); }
+	CUSTOM private static void Internal_OrthoNormalize3 (ref Vector3 a, ref Vector3 b, ref Vector3 c) { OrthoNormalize (&a, &b, &c); }
+
+	// Makes vectors normalized and orthogonal to each other.
+	CSRAW static public void OrthoNormalize (ref Vector3 normal, ref Vector3 tangent) { Internal_OrthoNormalize2 (ref normal, ref tangent); }
+	// Makes vectors normalized and orthogonal to each other.
+	CSRAW static public void OrthoNormalize (ref Vector3 normal, ref Vector3 tangent, ref Vector3 binormal) { Internal_OrthoNormalize3 (ref normal, ref tangent, ref binormal); }
+
+	
+	// Moves a point /current/ in a straight line towards a /target/ point.
+	CSRAW static public Vector3 MoveTowards (Vector3 current, Vector3 target, float maxDistanceDelta)
+	{
+		Vector3 toVector = target - current;
+		float dist = toVector.magnitude;
+		if (dist <= maxDistanceDelta || dist == 0)
+			return target;
+		return current + toVector / dist * maxDistanceDelta;
+	}
+	
+	// Rotates a vector /current/ towards /target/.
+	CUSTOM static Vector3 RotateTowards (Vector3 current, Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta) { return RotateTowards (current, target, maxRadiansDelta, maxMagnitudeDelta); }
+	
+	// Gradually changes a vector towards a desired goal over time.
+	CSRAW public static Vector3 SmoothDamp (Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity, float deltaTime = Time.deltaTime)
+	{
+		// Based on Game Programming Gems 4 Chapter 1.10
+		smoothTime = Mathf.Max(0.0001F, smoothTime);
+		float omega = 2F / smoothTime;
+
+		float x = omega * deltaTime;
+		float exp = 1F / (1F + x + 0.48F*x*x + 0.235F*x*x*x);
+		Vector3 change = current - target;
+		Vector3 originalTo = target;
+
+		// Clamp maximum speed
+		float maxChange = maxSpeed * smoothTime;
+		change = Vector3.ClampMagnitude(change, maxChange);
+		target = current - change;
+		
+		Vector3 temp = (currentVelocity + omega * change) * deltaTime;
+		currentVelocity = (currentVelocity - omega * temp) * exp;
+		Vector3 output = target + (change + temp) * exp;
+
+		// Prevent overshooting
+		if (Vector3.Dot(originalTo - current, output - originalTo) > 0)
+		{
+			output = originalTo;
+			currentVelocity = (output - originalTo) / deltaTime;
+		}
+
+		return output;
+	}
+	
+	// Access the x, y, z components using [0], [1], [2] respectively.
+	CSRAW public float this [int index]
+	{
+		get
+		{
+			switch(index)
+			{
+				case 0: return x;
+				case 1: return y;
+				case 2: return z;
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector3 index!");
+			}
+		}
+
+		set
+		{
+			switch(index)
+			{
+				case 0: x = value; break;
+				case 1: y = value; break;
+				case 2: z = value; break; 
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector3 index!");
+			}
+		}
+	}
+
+	// Creates a new vector with given x, y, z components.
+	public Vector3 (float x, float y, float z) { this.x = x; this.y = y; this.z = z; }
+	// Creates a new vector with given x, y components and sets /z/ to zero.
+	public Vector3 (float x, float y) { this.x = x; this.y = y; z = 0F; }
+		
+	// Set x, y and z components of an existing Vector3.
+	CSRAW public void Set (float new_x, float new_y, float new_z) { x = new_x; y = new_y; z = new_z; }
+		
+	// Multiplies two vectors component-wise.
+	CSRAW public static Vector3 Scale (Vector3 a, Vector3 b) { return new Vector3 (a.x*b.x, a.y*b.y, a.z*b.z); }
+	
+	// Multiplies every component of this vector by the same component of /scale/.
+	CSRAW public void Scale (Vector3 scale) { x *= scale.x; y *= scale.y; z *= scale.z; }
+	
+	// Cross Product of two vectors.
+	CSRAW public static Vector3 Cross (Vector3 lhs, Vector3 rhs)
+	{
+		return new Vector3 (
+		lhs.y * rhs.z - lhs.z * rhs.y,
+		lhs.z * rhs.x - lhs.x * rhs.z,
+		lhs.x * rhs.y - lhs.y * rhs.x);
+	}
+		
+	// used to allow Vector3s to be used as keys in hash tables
+	public override int GetHashCode() {
+		return x.GetHashCode() ^ (y.GetHashCode()<<2) ^ (z.GetHashCode()>>2);
+	}
+	
+	// also required for being able to use Vector3s as keys in hash tables
+	public override bool Equals(object other) {
+		if(!(other is Vector3)) return false;
+		
+		Vector3 rhs=(Vector3)other;
+		return x.Equals(rhs.x) && y.Equals(rhs.y) && z.Equals(rhs.z);
+	}
+
+	// Reflects a vector off the plane defined by a normal.
+	CSRAW public static Vector3 Reflect (Vector3 inDirection, Vector3 inNormal)
+	{
+		return -2F * Dot (inNormal, inDirection) * inNormal + inDirection;
+	}
+	
+	// *undoc* --- we have normalized property now
+	CSRAW public static Vector3 Normalize (Vector3 value)
+	{
+		float mag = Magnitude (value);
+		if (mag > kEpsilon)
+			return value / mag;
+		else
+			return zero;			
+	}
+
+	// Makes this vector have a ::ref::magnitude of 1.
+	CSRAW public void Normalize ()
+	{
+		float mag = Magnitude (this);
+		if (mag > kEpsilon)
+			this = this / mag;
+		else
+			this = zero;
+	}
+	
+	// Returns this vector with a ::ref::magnitude of 1 (RO).
+	CSRAW public Vector3 normalized { get { return Vector3.Normalize (this); } }
+
+	/// *listonly*
+	CSRAW override public string ToString() { return UnityString.Format("({0:F1}, {1:F1}, {2:F1})", x, y, z); }
+	// Returns a nicely formatted string for this vector.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("({0}, {1}, {2})", x.ToString(format), y.ToString(format), z.ToString(format));
+	}
+
+	// Dot Product of two vectors.
+	public static float Dot (Vector3 lhs, Vector3 rhs) { return lhs.x*rhs.x + lhs.y*rhs.y + lhs.z*rhs.z; }
+
+	// Projects a vector onto another vector.
+	public static Vector3 Project (Vector3 vector, Vector3 onNormal) { 
+		float sqrMag = Dot(onNormal,onNormal);
+		if (sqrMag < Mathf.Epsilon)
+			return zero;
+		else
+			return onNormal * Dot (vector, onNormal) / sqrMag;
+	}
+
+	//*undocumented* --------------------------- TODO is this generally useful? What is the intention? I know i understood it once upon a time but it evaded my mind.
+	CSRAW public static Vector3 Exclude (Vector3 excludeThis, Vector3 fromThat) {
+		return fromThat - Project (fromThat, excludeThis);
+	}
+	
+	// Returns the angle in degrees between /from/ and /to/. This is always the smallest
+	CSRAW public static float Angle(Vector3 from, Vector3 to) { return Mathf.Acos(Mathf.Clamp (Vector3.Dot (from.normalized, to.normalized), -1F, 1F)) * Mathf.Rad2Deg; }
+
+	// Returns the distance between /a/ and /b/.
+	public static float Distance (Vector3 a, Vector3 b) { Vector3 vec = new Vector3 (a.x - b.x, a.y - b.y, a.z - b.z); return Mathf.Sqrt (vec.x * vec.x + vec.y * vec.y + vec.z * vec.z); }
+	
+	// Returns a copy of /vector/ with its magnitude clamped to /maxLength/.
+	CSRAW public static Vector3 ClampMagnitude (Vector3 vector, float maxLength)
+	{
+		if (vector.sqrMagnitude > maxLength * maxLength)
+			return vector.normalized * maxLength;
+		return vector;
+	}
+	
+	// *undoc* --- there's a property now
+	CSRAW public static float Magnitude (Vector3 a) { return Mathf.Sqrt (a.x*a.x + a.y*a.y + a.z*a.z); }
+
+	// Returns the length of this vector (RO).
+	CSRAW public float magnitude { get { return Mathf.Sqrt (x*x + y*y + z*z); } }
+
+	// *undoc* --- there's a property now
+	CSRAW public static float SqrMagnitude (Vector3 a) { return a.x*a.x + a.y*a.y + a.z*a.z; }
+	
+	// Returns the squared length of this vector (RO).
+	CSRAW public float sqrMagnitude { get { return x * x + y * y + z * z; } }
+	
+	
+	// Returns a vector that is made from the smallest components of two vectors.
+	CSRAW public static Vector3 Min (Vector3 lhs, Vector3 rhs) { return new Vector3 (Mathf.Min(lhs.x,rhs.x), Mathf.Min(lhs.y,rhs.y), Mathf.Min(lhs.z,rhs.z)); }
+	
+	// Returns a vector that is made from the largest components of two vectors.
+	CSRAW public static Vector3 Max (Vector3 lhs, Vector3 rhs) { return new Vector3 (Mathf.Max(lhs.x,rhs.x), Mathf.Max(lhs.y,rhs.y), Mathf.Max(lhs.z,rhs.z)); }
+	
+	// Shorthand for writing @@Vector3(0, 0, 0)@@
+	CSRAW public static Vector3 zero { get { return new Vector3 (0F, 0F, 0F); }   }
+	// Shorthand for writing @@Vector3(1, 1, 1)@@
+	CSRAW public static Vector3 one { get { return new Vector3 (1F, 1F, 1F); }   }
+	// Shorthand for writing @@Vector3(0, 0, 1)@@
+	CSRAW public static Vector3 forward { get { return new Vector3 (0F, 0F, 1F); }   }
+	OBSOLETE planned Use -Vector3.forward
+	CSRAW public static Vector3 back { get { return new Vector3 (0F, 0F, -1F); }   }
+	// Shorthand for writing @@Vector3(0, 1, 0)@@
+	CSRAW public static Vector3 up { get { return new Vector3 (0F, 1F, 0F); }   }
+	OBSOLETE planned Use -Vector3.up
+	CSRAW public static Vector3 down { get { return new Vector3 (0F, -1F, 0F); }   }
+	OBSOLETE planned Use -Vector3.right
+	CSRAW public static Vector3 left { get { return new Vector3 (-1F, 0F, 0F); }   }
+	// Shorthand for writing @@Vector3(1, 0, 0)@@
+	CSRAW public static Vector3 right { get { return new Vector3 (1F, 0F, 0F); }   }
+
+
+	// Adds two vectors.
+	CSRAW public static Vector3 operator + (Vector3 a, Vector3 b) { return new Vector3 (a.x+b.x, a.y+b.y, a.z+b.z); }
+	// Subtracts one vector from another.
+	CSRAW public static Vector3 operator - (Vector3 a, Vector3 b) { return new Vector3 (a.x-b.x, a.y-b.y, a.z-b.z); }
+	// Negates a vector.
+	CSRAW public static Vector3 operator - (Vector3 a) { return new Vector3 (-a.x, -a.y, -a.z); }
+	// Multiplies a vector by a number.
+	CSRAW public static Vector3 operator * (Vector3 a, float d) { return new Vector3 (a.x*d, a.y*d, a.z*d); }
+	// Multiplies a vector by a number.
+	CSRAW public static Vector3 operator * (float d, Vector3 a) { return new Vector3 (a.x*d, a.y*d, a.z*d); }
+	// Divides a vector by a number.
+	CSRAW public static Vector3 operator / (Vector3 a, float d) { return new Vector3 (a.x/d, a.y/d, a.z/d); }
+	
+	// Returns true if the vectors are equal.
+	CSRAW public static bool operator == (Vector3 lhs, Vector3 rhs)
+	{
+		return SqrMagnitude (lhs - rhs) < kEpsilon * kEpsilon;
+	}
+
+	// Returns true if vectors different.
+	CSRAW public static bool operator != (Vector3 lhs, Vector3 rhs)
+	{
+		return SqrMagnitude (lhs - rhs) >= kEpsilon * kEpsilon;
+	}
+	
+	OBSOLETE warning Use Vector3.forward instead.
+	CSRAW public static Vector3 fwd { get { return new Vector3 (0F, 0F, 1F); }   }
+	
+	OBSOLETE warning Use Vector3.Angle instead. AngleBetween uses radians instead of degrees and was deprecated for this reason
+	CSRAW public static float AngleBetween(Vector3 from, Vector3 to) { return Mathf.Acos(Mathf.Clamp (Vector3.Dot (from.normalized, to.normalized), -1F, 1F)); }
+END
+
+
+// Representation of RGBA colors.
+
+THREAD_SAFE
+STRUCT Color
+	// Red component of the color.
+	CSRAW public float r;
+
+	// Green component of the color.
+	CSRAW public float g;
+
+	// Blue component of the color.
+	CSRAW public float b;
+
+	// Alpha component of the color.
+	CSRAW public float a;
+
+
+	// Constructs a new Color with given r,g,b,a components.
+	CSRAW public Color (float r, float g, float b, float a)
+	{
+		this.r = r; this.g = g; this.b = b; this.a = a;
+	}
+
+	// Constructs a new Color with given r,g,b components and sets /a/ to 1.
+	CSRAW public Color (float r, float g, float b)
+	{
+		this.r = r; this.g = g; this.b = b; this.a = 1.0F;
+	}
+
+	/// *listonly*
+	CSRAW override public string ToString() {
+		return UnityString.Format("RGBA({0:F3}, {1:F3}, {2:F3}, {3:F3})", r, g, b, a);
+	}
+	// Returns a nicely formatted string of this color.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("RGBA({0}, {1}, {2}, {3})", r.ToString(format), g.ToString(format), b.ToString(format), a.ToString(format));
+	}
+	
+	// used to allow Colors to be used as keys in hash tables
+	public override int GetHashCode() {
+		return ((Vector4)this).GetHashCode();
+	}
+	
+	// also required for being able to use Colors as keys in hash tables
+	public override bool Equals(object other) {
+		if (!(other is Color)) return false;
+		Color rhs = (Color)other;
+		return r.Equals(rhs.r) && g.Equals(rhs.g) && b.Equals(rhs.b) && a.Equals(rhs.a);
+	}
+	
+	// Adds two colors together. Each component is added separately.
+	CSRAW public static Color operator + (Color a, Color b) { return new Color (a.r+b.r, a.g+b.g, a.b+b.b, a.a+b.a); }
+
+	// Subtracts color /b/ from color /a/. Each component is subtracted separately.
+	CSRAW public static Color operator - (Color a, Color b) { return new Color (a.r-b.r, a.g-b.g, a.b-b.b, a.a-b.a); }
+
+	// Multiplies two colors together. Each component is multiplied separately.
+	CSRAW public static Color operator * (Color a, Color b) { return new Color (a.r*b.r, a.g*b.g, a.b*b.b, a.a*b.a); }
+
+	// Multiplies color /a/ by the float /b/. Each color component is scaled separately.
+	CSRAW public static Color operator * (Color a, float b) { return new Color (a.r*b, a.g*b, a.b*b, a.a*b); }
+
+	// Multiplies color /a/ by the float /b/. Each color component is scaled separately.
+	CSRAW public static Color operator * (float b, Color a) { return new Color (a.r*b, a.g*b, a.b*b, a.a*b); }
+
+	// Divides color /a/ by the float /b/. Each color component is scaled separately.
+	CSRAW public static Color operator / (Color a, float b) { return new Color (a.r/b, a.g/b, a.b/b, a.a/b); }
+	
+	//*undoc*
+	CSRAW public static bool operator == (Color lhs, Color rhs)
+	{
+		return ((Vector4)lhs == (Vector4)rhs);
+	}
+	//*undoc*
+	CSRAW public static bool operator != (Color lhs, Color rhs)
+	{
+		return ((Vector4)lhs != (Vector4)rhs);
+	}
+	
+	// Interpolates between colors /a/ and /b/ by /t/.
+	CSRAW public static Color Lerp (Color a, Color b, float t)
+	{ 
+		t = Mathf.Clamp01 (t);       
+		return new Color( 
+			a.r + (b.r - a.r)*t, 
+			a.g + (b.g - a.g)*t, 
+			a.b + (b.b - a.b)*t,
+			a.a + (b.a - a.a)*t 
+		); 
+	 }
+	
+	// Returns new color that has RGB components multiplied, but leaving alpha untouched.
+	CSRAW internal Color RGBMultiplied (float multiplier) { return new Color (r * multiplier, g * multiplier, b * multiplier, a); }
+	// Returns new color that has RGB components multiplied, but leaving alpha untouched.
+	CSRAW internal Color AlphaMultiplied (float multiplier) { return new Color (r,g,b,a * multiplier); }
+	// Returns new color that has RGB components multiplied, but leaving alpha untouched.
+	CSRAW internal Color RGBMultiplied (Color multiplier) { return new Color (r * multiplier.r, g * multiplier.g, b * multiplier.b, a); }
+
+	// Solid red. RGBA is (1, 0, 0, 1).
+	CSRAW public static Color red { get { return new Color (1F, 0F, 0F, 1F); } }
+	// Solid green. RGBA is (0, 1, 0, 1).
+	CSRAW public static Color green { get { return new Color (0F, 1F, 0F, 1F); } }
+	// Solid blue. RGBA is (0, 0, 1, 1).
+	CSRAW public static Color blue { get { return new Color (0F, 0F, 1F, 1F); } }
+	// Solid white. RGBA is (1, 1, 1, 1).
+	CSRAW public static Color white { get { return new Color (1F, 1F, 1F, 1F); } }
+	// Solid black. RGBA is (0, 0, 0, 1).
+	CSRAW public static Color black { get { return new Color (0F, 0F, 0F, 1F); } }
+	// Yellow. RGBA is (1, 0.92, 0.016, 1), but the color is nice to look at!
+	CSRAW public static Color yellow { get { return new Color (1F, 235F / 255F, 4F / 255F, 1F); } }
+	// Cyan. RGBA is (0, 1, 1, 1).
+	CSRAW public static Color cyan { get { return new Color (0F, 1F, 1F, 1F); } }
+	// Magenta. RGBA is (1, 0, 1, 1).
+	CSRAW public static Color magenta { get { return new Color (1F, 0F, 1F, 1F); } }
+	// Gray. RGBA is (0.5, 0.5, 0.5, 1).
+	CSRAW public static Color gray { get { return new Color (.5F, .5F, .5F, 1F); } }
+	// English spelling for ::ref::gray. RGBA is the same (0.5, 0.5, 0.5, 1).
+	CSRAW public static Color grey { get { return new Color (.5F, .5F, .5F, 1F); } }
+	// Completely transparent. RGBA is (0, 0, 0, 0).
+	CSRAW public static Color clear { get { return new Color (0F, 0F, 0F, 0F); } }
+	
+	// The grayscale value of the color (RO)
+	CSRAW public float grayscale { get { return 0.299F * r + 0.587F * g + 0.114F * b; } }
+	
+	// A version of the color that has had the inverse gamma curve applied
+	CSRAW public Color linear 
+	{
+		get {
+			return new Color (Mathf.GammaToLinearSpace(r), Mathf.GammaToLinearSpace(g), Mathf.GammaToLinearSpace(b), a);
+		}
+	}
+	
+	// A version of the color that has had the gamma curve applied
+	CSRAW public Color gamma 
+	{
+		get {
+			return new Color (Mathf.LinearToGammaSpace(r), Mathf.LinearToGammaSpace(g), Mathf.LinearToGammaSpace(b), a);
+		}
+	}
+	
+	// Colors can be implicitly converted to and from [[Vector4]].
+	CSRAW public static implicit operator Vector4(Color c) {
+		return new Vector4(c.r, c.g, c.b, c.a);
+	}
+	// Colors can be implicitly converted to and from [[Vector4]].
+	CSRAW public static implicit operator Color(Vector4 v) {
+		return new Color(v.x, v.y, v.z, v.w);
+	}
+	
+	// Access the r, g, b,a components using [0], [1], [2], [3] respectively.
+	CSRAW public float this [int index]
+	{
+		get
+		{
+			switch(index)
+			{
+				case 0: return r;
+				case 1: return g;
+				case 2: return b;
+				case 3: return a;
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector3 index!");
+			}
+		}
+
+		set
+		{
+			switch(index)
+			{
+				case 0: r = value; break;
+				case 1: g = value; break;
+				case 2: b = value; break; 
+				case 3: a = value; break; 
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector3 index!");
+			}
+		}
+	}
+
+	
+END
+
+
+// Representation of RGBA colors in 32 bit format
+THREAD_SAFE
+STRUCT Color32 
+	// Red component of the color.
+	CSRAW public byte r;
+
+	// Green component of the color.
+	CSRAW public byte g;
+
+	// Blue component of the color.
+	CSRAW public byte b;
+
+	// Alpha component of the color.
+	CSRAW public byte a;
+	
+	// Constructs a new Color with given r, g, b, a components.
+	CSRAW public Color32(byte r, byte g, byte b, byte a) {
+		this.r = r; this.g = g; this.b = b; this.a = a;
+	}
+	
+	// Color32 can be implicitly converted to and from [[Color]].
+	CSRAW public static implicit operator Color32(Color c) {
+		return new Color32((byte)(Mathf.Clamp01(c.r) * 255), (byte)(Mathf.Clamp01(c.g) * 255), (byte)(Mathf.Clamp01(c.b) * 255), (byte)(Mathf.Clamp01(c.a) * 255));
+	}
+	
+	// Color32 can be implicitly converted to and from [[Color]].
+	CSRAW public static implicit operator Color (Color32 c) {
+		return new Color(c.r / 255f, c.g / 255f, c.b / 255f, c.a / 255f);
+	}
+	
+	/// *listonly*
+	CSRAW override public string ToString() {
+		return UnityString.Format("RGBA({0}, {1}, {2}, {3})", r, g, b, a);
+	}
+	// Returns a nicely formatted string of this color.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("RGBA({0}, {1}, {2}, {3})", r.ToString(format), g.ToString(format), b.ToString(format), a.ToString(format));
+	}
+	
+	// Interpolates between colors /a/ and /b/ by /t/.
+	CSRAW public static Color32 Lerp (Color32 a, Color32 b, float t)
+	{ 
+		t = Mathf.Clamp01 (t);       
+		return new Color32( 
+			(byte)(a.r + (b.r - a.r)*t), 
+			(byte)(a.g + (b.g - a.g)*t), 
+			(byte)(a.b + (b.b - a.b)*t),
+			(byte)(a.a + (b.a - a.a)*t) 
+		); 
+	 }	
+END
+
+
+// Quaternions are used to represent rotations.
+
+CSRAW
+THREAD_SAFE
+STRUCT Quaternion
+	
+	// X component of the Quaternion. Don't modify this directly unless you know quaternions inside out.
+	CSRAW public float x;
+	// Y component of the Quaternion. Don't modify this directly unless you know quaternions inside out.
+	CSRAW public float y;
+	// Z component of the Quaternion. Don't modify this directly unless you know quaternions inside out.
+	CSRAW public float z;
+	// W component of the Quaternion. Don't modify this directly unless you know quaternions inside out.
+	CSRAW public float w;
+	
+	// Access the x, y, z, w components using [0], [1], [2], [3] respectively.
+	CSRAW public float this [int index]
+	{
+		get
+		{
+			switch(index)
+			{
+				case 0: return x;
+				case 1: return y;
+				case 2: return z;
+				case 3: return w;
+				default:
+				throw new IndexOutOfRangeException("Invalid Quaternion index!");
+			}
+		}
+
+		set
+		{
+			switch(index)
+			{
+				case 0: x = value; break;
+				case 1: y = value; break;
+				case 2: z = value; break;
+				case 3: w = value; break;
+				default:
+				throw new IndexOutOfRangeException("Invalid Quaternion index!");
+			}
+		}
+	}
+
+	
+	// Constructs new Quaternion with given x,y,z,w components.
+	CSRAW public Quaternion (float x, float y, float z, float w) { this.x = x; this.y = y; this.z = z; this.w = w; }
+
+	// Set x, y, z and w components of an existing Quaternion.
+	CSRAW public void Set (float new_x, float new_y, float new_z, float new_w) { x = new_x; y = new_y; z = new_z; w = new_w; }
+
+	// The identity rotation (RO). This quaternion corresponds to "no rotation": the object
+	CSRAW public static Quaternion identity { get { return new Quaternion (0F, 0F, 0F, 1F); } }
+	
+	// Combines rotations /lhs/ and /rhs/.
+	CSRAW public static Quaternion operator * (Quaternion lhs, Quaternion rhs)
+	{
+		return new Quaternion (
+				lhs.w*rhs.x + lhs.x*rhs.w + lhs.y*rhs.z - lhs.z*rhs.y,
+				lhs.w*rhs.y + lhs.y*rhs.w + lhs.z*rhs.x - lhs.x*rhs.z,
+				lhs.w*rhs.z + lhs.z*rhs.w + lhs.x*rhs.y - lhs.y*rhs.x,
+				lhs.w*rhs.w - lhs.x*rhs.x - lhs.y*rhs.y - lhs.z*rhs.z);
+	}
+
+	// Rotates the point /point/ with /rotation/.
+	CSRAW public static Vector3 operator * (Quaternion rotation, Vector3 point)
+	{
+		float x = rotation.x * 2F;
+		float y = rotation.y * 2F;
+		float z = rotation.z * 2F;
+		float xx = rotation.x * x;
+		float yy = rotation.y * y;
+		float zz = rotation.z * z;
+		float xy = rotation.x * y;
+		float xz = rotation.x * z;
+		float yz = rotation.y * z;
+		float wx = rotation.w * x;
+		float wy = rotation.w * y;
+		float wz = rotation.w * z;
+
+		Vector3 res;
+		res.x = (1F - (yy + zz)) * point.x + (xy - wz)          * point.y + (xz + wy)          * point.z;
+		res.y = (xy + wz)          * point.x + (1F - (xx + zz)) * point.y + (yz - wx)          * point.z;
+		res.z = (xz - wy)          * point.x + (yz + wx)          * point.y + (1F - (xx + yy)) * point.z;
+		return res;
+	}
+
+	// *undocumented*
+	CSRAW public const float kEpsilon = 0.000001F;
+
+	// Are two quaternions equal to each other?
+	CSRAW public static bool operator == (Quaternion lhs, Quaternion rhs)
+	{
+		return Dot (lhs, rhs) > 1.0f-kEpsilon;
+	}
+
+	// Are two quaternions different from each other?
+	CSRAW public static bool operator != (Quaternion lhs, Quaternion rhs)
+	{
+		return Dot (lhs, rhs) <= 1.0f-kEpsilon;
+	}
+
+	// The dot product between two rotations.
+	CSRAW public static float Dot (Quaternion a, Quaternion b) { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; }
+	
+	// Creates a rotation which rotates /angle/ degrees around /axis/.
+	CUSTOM static Quaternion AngleAxis (float angle, Vector3 axis) { return AxisAngleToQuaternionSafe (axis, Deg2Rad(angle)); }
+
+	// Converts a rotation to angle-axis representation.
+	CSRAW public void ToAngleAxis (out float angle, out Vector3 axis) { Internal_ToAxisAngleRad (this, out axis, out angle); angle *= Mathf.Rad2Deg;  }
+
+	// Creates a rotation which rotates from /fromDirection/ to /toDirection/.
+	CUSTOM static Quaternion FromToRotation (Vector3 fromDirection, Vector3 toDirection) { return FromToQuaternionSafe (fromDirection, toDirection); }
+
+	// Creates a rotation which rotates from /fromDirection/ to /toDirection/.
+	CSRAW public void SetFromToRotation (Vector3 fromDirection, Vector3 toDirection) { this = FromToRotation (fromDirection, toDirection); }
+
+	// Creates a rotation with the specified /forward/ and /upwards/ directions.
+	CUSTOM static Quaternion LookRotation (Vector3 forward, Vector3 upwards = Vector3.up)
+	{
+		Quaternionf q = Quaternionf::identity ();
+		if (!LookRotationToQuaternion (forward, upwards, &q))
+		{
+			float mag = Magnitude (forward);
+			if (mag > Vector3f::epsilon)
+			{
+				Matrix3x3f m;
+				m.SetFromToRotation (Vector3f::zAxis, forward / mag);
+				MatrixToQuaternion (m, q);
+			}
+			else
+			{
+				LogString ("Look rotation viewing vector is zero");
+			}
+		}
+		return q;
+	}
+	
+	// Creates a rotation with the specified /forward/ and /upwards/ directions.
+	CSRAW public void SetLookRotation (Vector3 view, Vector3 up = Vector3.up) { this = LookRotation (view, up); }
+	
+	// Spherically interpolates between /from/ and /to/ by t.
+	CUSTOM static Quaternion Slerp (Quaternion from, Quaternion to, float t) { return Slerp (from, to, clamp01 (t)); }
+
+	// Interpolates between /from/ and /to/ by /t/ and normalizes the result afterwards.
+	CUSTOM static Quaternion Lerp (Quaternion from, Quaternion to, float t) { return Lerp (from, to, clamp01 (t)); }
+	
+	// Rotates a rotation /from/ towards /to/.
+	CSRAW public static Quaternion RotateTowards (Quaternion from, Quaternion to, float maxDegreesDelta)
+	{
+		float angle = Quaternion.Angle(from, to);
+		if (angle == 0.0f)
+			return to;
+		float slerpValue = Mathf.Min(1.0f, maxDegreesDelta / angle);
+		return UnclampedSlerp(from, to, slerpValue);
+	}
+	
+	CUSTOM private static Quaternion UnclampedSlerp (Quaternion from, Quaternion to, float t) { return Slerp (from, to, t); }
+	
+	// Returns the Inverse of /rotation/.
+	CUSTOM static Quaternion Inverse (Quaternion rotation) { return Inverse (rotation); }
+
+	
+	/// *listonly*
+	CSRAW override public string ToString() {
+		return UnityString.Format("({0:F1}, {1:F1}, {2:F1}, {3:F1})", x, y, z, w);
+	}
+	// Returns a nicely formatted string of the Quaternion
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("({0}, {1}, {2}, {3})", x.ToString(format), y.ToString(format), z.ToString(format), w.ToString(format));
+	}
+	 
+	// Returns the angle in degrees between two rotations /a/ and /b/.
+	CSRAW static public float Angle (Quaternion a, Quaternion b)
+	{
+		float dot = Dot(a, b);
+		return Mathf.Acos(Mathf.Min(Mathf.Abs(dot), 1.0F)) * 2.0F * Mathf.Rad2Deg;
+	}
+
+	// Returns the euler angle representation of the rotation.
+	CSRAW public Vector3 eulerAngles { get { return Internal_ToEulerRad(this) * Mathf.Rad2Deg; } set { this=Internal_FromEulerRad(value * Mathf.Deg2Rad); } }
+
+	// Returns a rotation that rotates z degrees around the z axis, x degrees around the x axis, and y degrees around the y axis (in that order).
+	CSRAW static public Quaternion Euler (float x, float y, float z) { return Internal_FromEulerRad (new Vector3 (x, y, z) * Mathf.Deg2Rad); }
+
+	// Returns a rotation that rotates z degrees around the z axis, x degrees around the x axis, and y degrees around the y axis (in that order). 
+	CSRAW static public Quaternion Euler (Vector3 euler) { return Internal_FromEulerRad (euler * Mathf.Deg2Rad); }
+
+
+	// Internal implementation. Note Rad suffix that indicates that this method works in radians.
+	CUSTOM static private Vector3 Internal_ToEulerRad (Quaternion rotation)
+	{
+		Quaternionf outRotation = NormalizeSafe (rotation);
+		return QuaternionToEuler (outRotation);
+	}
+
+	// Internal implementation. Note Rad suffix that indicates that this method works in radians.
+	CUSTOM static private Quaternion Internal_FromEulerRad (Vector3 euler) { 
+		return EulerToQuaternion (euler); 
+	}
+
+	// Internal implementation. Note Rad suffix that indicates that this method works in radians.
+	CUSTOM private static void Internal_ToAxisAngleRad (Quaternion q, out Vector3 axis, out float angle) { 
+		QuaternionToAxisAngle (NormalizeSafe (q), axis, angle); 
+	}
+
+
+	// Old obsolete radians-based Euler functions:
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW static public Quaternion EulerRotation (float x, float y, float z) { return Internal_FromEulerRad (new Vector3 (x, y, z)); }
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public static Quaternion EulerRotation (Vector3 euler) { return Internal_FromEulerRad (euler); }
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public void SetEulerRotation (float x, float y, float z) { this = Internal_FromEulerRad (new Vector3 (x, y, z)); }
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public void SetEulerRotation (Vector3 euler) { this = Internal_FromEulerRad (euler); }
+	OBSOLETE warning Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public Vector3 ToEuler () { return Internal_ToEulerRad (this); }
+	
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW static public Quaternion EulerAngles (float x, float y, float z) { return Internal_FromEulerRad (new Vector3 (x, y, z)); }
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public static Quaternion EulerAngles (Vector3 euler) {  return Internal_FromEulerRad (euler); }
+
+	OBSOLETE warning Use Quaternion.ToAngleAxis instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public void ToAxisAngle (out Vector3 axis, out float angle) { Internal_ToAxisAngleRad (this, out axis, out angle);  }
+
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public void SetEulerAngles (float x, float y, float z) { SetEulerRotation (new Vector3 (x, y, z)); }
+	OBSOLETE warning Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public void SetEulerAngles (Vector3 euler) { this = EulerRotation (euler); }
+	OBSOLETE warning Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public static Vector3 ToEulerAngles (Quaternion rotation) { return Quaternion.Internal_ToEulerRad (rotation); }
+	OBSOLETE warning Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public Vector3 ToEulerAngles () { return Quaternion.Internal_ToEulerRad (this); }
+
+	OBSOLETE warning Use Quaternion.AngleAxis instead. This function was deprecated because it uses radians instead of degrees
+	CUSTOM static Quaternion AxisAngle (Vector3 axis, float angle) { return AxisAngleToQuaternionSafe (axis, angle); }
+	
+	OBSOLETE warning Use Quaternion.AngleAxis instead. This function was deprecated because it uses radians instead of degrees
+	CSRAW public void SetAxisAngle (Vector3 axis, float angle) { this = AxisAngle (axis, angle); }
+
+	// used to allow Quaternions to be used as keys in hash tables
+	CSRAW public override int GetHashCode() {
+		return x.GetHashCode() ^ (y.GetHashCode()<<2) ^ (z.GetHashCode()>>2) ^ (w.GetHashCode()>>1);
+	}
+	
+	// also required for being able to use Quaternions as keys in hash tables
+	public override bool Equals(object other) {
+		if(!(other is Quaternion)) return false;
+		
+		Quaternion rhs=(Quaternion)other;
+		return x.Equals(rhs.x) && y.Equals(rhs.y) && z.Equals(rhs.z) && w.Equals(rhs.w);
+	}
+
+END			
+
+
+// A 2D Rectangle defined by x, y position and width, height
+THREAD_SAFE
+STRUCT Rect
+	CSRAW private float m_XMin, m_YMin, m_Width, m_Height;
+	
+	// Creates a new rectangle.
+	CSRAW public Rect (float left, float top, float width, float height) {
+		m_XMin = left;
+		m_YMin = top;
+		m_Width = width;
+		m_Height = height;
+	}
+
+	//*undocumented*
+	CSRAW public Rect (Rect source) {
+		m_XMin = source.m_XMin;
+		m_YMin = source.m_YMin;
+		m_Width = source.m_Width;
+		m_Height= source.m_Height;
+	}
+	
+	// Creates a rectangle from min/max coordinate values.
+	static public Rect MinMaxRect (float left, float top, float right, float bottom)
+	{
+		return new Rect (left, top, right - left, bottom - top);
+	}
+
+	// Set components of an existing Rect.
+	CSRAW public void Set (float left, float top, float width, float height) {
+		m_XMin = left;
+		m_YMin = top;
+		m_Width = width;
+		m_Height = height;
+	}
+
+	// Left coordinate of the rectangle.
+	CSRAW public float x { get { return m_XMin; } set { m_XMin = value; } }
+	
+	// Top coordinate of the rectangle.
+	CSRAW public float y { get { return m_YMin; } set { m_YMin = value; } }
+	
+	// Center coordinate of the rectangle.
+	CSRAW public Vector2 center { get { return new Vector2 (x + m_Width / 2f, y + m_Height / 2f); } set { m_XMin = value.x - m_Width / 2f; m_YMin = value.y - m_Height / 2f; } }
+	
+	// Width of the rectangle.
+	CSRAW public float width { get { return m_Width; } set { m_Width = value; } }
+
+	// Height of the rectangle.
+	CSRAW public float height { get { return m_Height; } set { m_Height = value;  } }
+
+	OBSOLETE warning use xMin
+	CSRAW public float left { get { return m_XMin; }  }
+	OBSOLETE warning use xMax
+	CSRAW public float right { get { return m_XMin + m_Width; }  }
+	OBSOLETE warning use yMin
+	CSRAW public float top { get { return m_YMin; }  }
+	OBSOLETE warning use yMax
+	CSRAW public float bottom { get { return m_YMin + m_Height; }  }
+
+	// Left coordinate of the rectangle.
+	CSRAW public float xMin { get { return m_XMin; } set { float oldxmax = xMax; m_XMin = value; m_Width = oldxmax - m_XMin; } }
+	// Top coordinate of the rectangle.
+	CSRAW public float yMin { get { return m_YMin; } set { float oldymax = yMax; m_YMin = value; m_Height = oldymax - m_YMin;  } }
+	// Right coordinate of the rectangle.
+	CSRAW public float xMax { get { return m_Width + m_XMin; }  set { m_Width = value - m_XMin; } }
+	// Bottom coordinate of the rectangle.
+	CSRAW public float yMax { get { return m_Height + m_YMin; }  set { m_Height = value - m_YMin; } }
+
+	/// *listonly*
+	CSRAW override public string ToString() { return UnityString.Format("(x:{0:F2}, y:{1:F2}, width:{2:F2}, height:{3:F2})", x, y, width, height); }
+	// Returns a nicely formatted string for this Rect.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("(x:{0}, y:{1}, width:{2}, height:{3})", x.ToString(format), y.ToString(format), width.ToString(format), height.ToString(format));
+	}
+	
+	/// *listonly*
+	CSRAW public bool Contains (Vector2 point)
+	{
+		return (point.x >= xMin) && (point.x < xMax) && (point.y >= yMin) && (point.y < yMax);
+	}
+	// Returns true if the /x/ and /y/ components of /point/ is a point inside this rectangle.
+	public bool Contains (Vector3 point)
+	{
+		return (point.x >= xMin) && (point.x < xMax) && (point.y >= yMin) && (point.y < yMax);
+	}
+	public bool Contains(Vector3 point, bool allowInverse)
+	{
+		if (!allowInverse)
+		{
+			return Contains(point);
+		}
+		bool xAxis = false;
+		if (width < 0f && (point.x <= xMin) && (point.x > xMax) || width >= 0f && (point.x >= xMin) && (point.x < xMax))
+			xAxis = true;
+		if (xAxis && (height < 0f && (point.y <= yMin) && (point.y > yMax) || height >= 0f && (point.y >= yMin) && (point.y < yMax)))
+			return true;
+		return false;
+	}
+	// removed for 2.0
+	// Clamp a point to be within a rectangle.
+//	CSRAW public Vector2 Clamp (Vector2 point) {
+//		return new Vector2 (Mathf.Clamp (point.x, left, xMax-1), Mathf.Clamp (point.y, yMin, yMax-1));
+//	}
+	
+	// Swaps min and max if min was greater than max.
+	private static Rect OrderMinMax (Rect rect)
+	{
+		if (rect.xMin > rect.xMax)
+		{
+			float temp = rect.xMin;
+			rect.xMin = rect.xMax;
+			rect.xMax = temp;
+		}
+		if (rect.yMin > rect.yMax)
+		{
+			float temp = rect.yMin;
+			rect.yMin = rect.yMax;
+			rect.yMax = temp;
+		}
+		return rect;
+	}
+	
+	CSRAW public bool Overlaps (Rect other)
+	{
+		return (other.xMax > xMin &&
+				other.xMin < xMax &&
+				other.yMax > yMin &&
+				other.yMin < yMax);
+	}
+	
+	CSRAW public bool Overlaps (Rect other, bool allowInverse)
+	{
+		Rect self = this;
+		if (allowInverse)
+		{
+			self = OrderMinMax (self);
+			other = OrderMinMax (other);
+		}
+		return self.Overlaps (other);
+	}
+
+	// Returns true if the rectangles are different.
+	CSRAW public static bool operator != (Rect lhs, Rect rhs)
+	{
+		return lhs.x != rhs.x || lhs.y != rhs.y || lhs.width != rhs.width || lhs.height != rhs.height;
+	}
+
+	// Returns true if the rectangles are the same.
+	CSRAW public static bool operator == (Rect lhs, Rect rhs) {
+		return lhs.x == rhs.x && lhs.y == rhs.y && lhs.width == rhs.width && lhs.height == rhs.height;
+	}
+
+	public override int GetHashCode() {
+		return x.GetHashCode() ^ (width.GetHashCode()<<2) ^ (y.GetHashCode()>>2) ^ (height.GetHashCode()>>1);
+	}
+	
+	public override bool Equals(object other) {
+		if(!(other is Rect)) return false;
+		
+		Rect rhs=(Rect)other;
+		return x.Equals(rhs.x) && y.Equals(rhs.y) && width.Equals(rhs.width) && height.Equals(rhs.height);
+	}
+END
+
+
+// A standard 4x4 transformation matrix.
+THREAD_SAFE
+STRUCT Matrix4x4
+	CSRAW
+	///*undocumented*
+	public float m00;
+	///*undocumented*
+	public float m10;
+	///*undocumented*
+	public float m20;
+	///*undocumented*
+	public float m30;
+	
+	///*undocumented*
+	public float m01;
+	///*undocumented*
+	public float m11;
+	///*undocumented*
+	public float m21;
+	///*undocumented*
+	public float m31;
+	
+	///*undocumented*
+ 	public float m02;
+	///*undocumented*
+	public float m12;
+	///*undocumented*
+	public float m22;
+	///*undocumented*	
+	public float m32;
+	
+	///*undocumented*
+ 	public float m03;
+	///*undocumented*
+	public float m13;
+	///*undocumented*
+	public float m23;
+	///*undocumented*
+	public float m33;
+
+
+	CSRAW
+	// Access element at [row, column].
+	public float this [int row, int column]
+	{
+		get
+		{
+			return this [ row + column*4 ];
+		}
+
+		set
+		{
+			this [ row + column*4 ] = value;
+		}			
+	}
+	
+	// Access element at sequential index (0..15 inclusive).
+	CSRAW public float this [int index]
+	{
+		get
+		{
+			switch(index)
+			{
+				case 0: return m00;
+				case 1: return m10;
+				case 2: return m20;
+				case 3: return m30;
+				case 4: return m01;
+				case 5: return m11;
+				case 6: return m21;
+				case 7: return m31;
+				case 8: return m02;
+				case 9: return m12;
+				case 10:return m22;
+				case 11:return m32;
+				case 12:return m03;
+				case 13:return m13;
+				case 14:return m23;
+				case 15:return m33;
+				default:
+				throw new IndexOutOfRangeException("Invalid matrix index!");
+			}
+		}
+
+		set
+		{			
+			switch(index)
+			{
+				case 0: m00 = value; break;
+				case 1: m10 = value; break;
+				case 2: m20 = value; break;
+				case 3: m30 = value; break;
+				case 4: m01 = value; break;
+				case 5: m11 = value; break;
+				case 6: m21 = value; break;
+				case 7: m31 = value; break;
+				case 8: m02 = value; break;
+				case 9: m12 = value; break;
+				case 10:m22 = value; break;
+				case 11:m32 = value; break;
+				case 12:m03 = value; break;
+				case 13:m13 = value; break;
+				case 14:m23 = value; break;
+				case 15:m33 = value; break;
+
+				default:
+				throw new IndexOutOfRangeException("Invalid matrix index!");
+			}
+		}
+	}
+	
+	// used to allow Matrix4x4s to be used as keys in hash tables
+	public override int GetHashCode() {
+		return GetColumn( 0 ).GetHashCode() ^ (GetColumn( 1 ).GetHashCode()<<2) ^ (GetColumn( 2 ).GetHashCode()>>2) ^ (GetColumn( 3 ).GetHashCode()>>1);
+	}
+	
+	// also required for being able to use Matrix4x4s as keys in hash tables
+	public override bool Equals(object other) {
+		if(!(other is Matrix4x4)) return false;
+		
+		Matrix4x4 rhs=(Matrix4x4)other;
+		return GetColumn( 0 ).Equals(rhs.GetColumn( 0 )) 
+			&& GetColumn( 1 ).Equals(rhs.GetColumn( 1 )) 
+			&& GetColumn( 2 ).Equals(rhs.GetColumn( 2 )) 
+			&& GetColumn( 3 ).Equals(rhs.GetColumn( 3 ));
+	}
+	
+	// Multiplies two matrices.
+	CSRAW static public Matrix4x4 operator * (Matrix4x4 lhs, Matrix4x4 rhs)
+	{
+		Matrix4x4 res = new Matrix4x4();
+		res.m00 = lhs.m00 * rhs.m00 + lhs.m01 * rhs.m10 + lhs.m02 * rhs.m20 + lhs.m03 * rhs.m30;
+		res.m01 = lhs.m00 * rhs.m01 + lhs.m01 * rhs.m11 + lhs.m02 * rhs.m21 + lhs.m03 * rhs.m31;
+		res.m02 = lhs.m00 * rhs.m02 + lhs.m01 * rhs.m12 + lhs.m02 * rhs.m22 + lhs.m03 * rhs.m32;
+		res.m03 = lhs.m00 * rhs.m03 + lhs.m01 * rhs.m13 + lhs.m02 * rhs.m23 + lhs.m03 * rhs.m33;
+
+		res.m10 = lhs.m10 * rhs.m00 + lhs.m11 * rhs.m10 + lhs.m12 * rhs.m20 + lhs.m13 * rhs.m30;
+		res.m11 = lhs.m10 * rhs.m01 + lhs.m11 * rhs.m11 + lhs.m12 * rhs.m21 + lhs.m13 * rhs.m31;
+		res.m12 = lhs.m10 * rhs.m02 + lhs.m11 * rhs.m12 + lhs.m12 * rhs.m22 + lhs.m13 * rhs.m32;
+		res.m13 = lhs.m10 * rhs.m03 + lhs.m11 * rhs.m13 + lhs.m12 * rhs.m23 + lhs.m13 * rhs.m33;
+
+		res.m20 = lhs.m20 * rhs.m00 + lhs.m21 * rhs.m10 + lhs.m22 * rhs.m20 + lhs.m23 * rhs.m30;
+		res.m21 = lhs.m20 * rhs.m01 + lhs.m21 * rhs.m11 + lhs.m22 * rhs.m21 + lhs.m23 * rhs.m31;
+		res.m22 = lhs.m20 * rhs.m02 + lhs.m21 * rhs.m12 + lhs.m22 * rhs.m22 + lhs.m23 * rhs.m32;
+		res.m23 = lhs.m20 * rhs.m03 + lhs.m21 * rhs.m13 + lhs.m22 * rhs.m23 + lhs.m23 * rhs.m33;
+
+		res.m30 = lhs.m30 * rhs.m00 + lhs.m31 * rhs.m10 + lhs.m32 * rhs.m20 + lhs.m33 * rhs.m30;
+		res.m31 = lhs.m30 * rhs.m01 + lhs.m31 * rhs.m11 + lhs.m32 * rhs.m21 + lhs.m33 * rhs.m31;
+		res.m32 = lhs.m30 * rhs.m02 + lhs.m31 * rhs.m12 + lhs.m32 * rhs.m22 + lhs.m33 * rhs.m32;
+		res.m33 = lhs.m30 * rhs.m03 + lhs.m31 * rhs.m13 + lhs.m32 * rhs.m23 + lhs.m33 * rhs.m33;
+
+		return res;
+	}
+
+	// Transforms a [[Vector4]] by a matrix.
+	CSRAW static public Vector4 operator * (Matrix4x4 lhs, Vector4 v)
+	{
+		Vector4 res;
+		res.x = lhs.m00 * v.x + lhs.m01 * v.y + lhs.m02 * v.z + lhs.m03 * v.w; 
+		res.y = lhs.m10 * v.x + lhs.m11 * v.y + lhs.m12 * v.z + lhs.m13 * v.w;
+		res.z = lhs.m20 * v.x + lhs.m21 * v.y + lhs.m22 * v.z + lhs.m23 * v.w;
+		res.w = lhs.m30 * v.x + lhs.m31 * v.y + lhs.m32 * v.z + lhs.m33 * v.w;
+		return res;
+	}
+	
+	//*undoc*
+	CSRAW public static bool operator == (Matrix4x4 lhs, Matrix4x4 rhs)
+	{
+		return lhs.GetColumn( 0 ) == rhs.GetColumn( 0 )
+			&& lhs.GetColumn( 1 ) == rhs.GetColumn( 1 )
+			&& lhs.GetColumn( 2 ) == rhs.GetColumn( 2 )
+			&& lhs.GetColumn( 3 ) == rhs.GetColumn( 3 );
+	}	
+	//*undoc*
+	CSRAW public static bool operator != (Matrix4x4 lhs, Matrix4x4 rhs)
+	{
+		return !(lhs == rhs);
+	}
+	
+	//*undocumented* --- have a property now
+	CUSTOM static Matrix4x4 Inverse (Matrix4x4 m) { Matrix4x4f output (m); output.Invert_Full(); return output; }
+	//*undocumented* --- have a property now
+	CUSTOM static Matrix4x4 Transpose (Matrix4x4 m) { Matrix4x4f output (m); output.Transpose(); return output; }
+	
+	// Invert a matrix and return the success code.
+	CUSTOM internal static bool Invert (Matrix4x4 inMatrix, out Matrix4x4 dest) { return Matrix4x4f::Invert_Full(inMatrix, *dest); }
+	
+	// The inverse of this matrix (RO).
+	CSRAW public Matrix4x4 inverse { get { return Matrix4x4.Inverse (this); } }	
+	
+	// Returns the transpose of this matrix (RO).
+	CSRAW public Matrix4x4 transpose { get { return Matrix4x4.Transpose (this); } }	
+	
+	// Is this the identity matrix?
+	CUSTOM_PROP bool isIdentity { return self.IsIdentity(); }
+		
+	// Get a column of the matrix.
+	CSRAW public Vector4 GetColumn (int i)   { return new Vector4 (this[0, i], this[1, i], this[2, i], this[3, i]); }
+	// Returns a row of the matrix.
+	CSRAW public Vector4 GetRow (int i)      { return new Vector4 (this[i, 0], this[i, 1], this[i, 2], this[i, 3]); }
+	// Sets a column of the matrix.
+	CSRAW public void SetColumn (int i, Vector4 v) { this[0, i] = v.x; this[1, i] = v.y; this[2, i] = v.z; this[3, i] = v.w; }
+	// Sets a row of the matrix.
+	CSRAW public void SetRow (int i, Vector4 v){ this[i, 0] = v.x; this[i, 1] = v.y; this[i, 2] = v.z; this[i, 3] = v.w; }
+	
+	
+	// Transforms a position by this matrix (generic).
+	CSRAW public Vector3 MultiplyPoint (Vector3 v)
+	{
+		Vector3 res;
+		float w;
+		res.x = this.m00 * v.x + this.m01 * v.y + this.m02 * v.z + this.m03; 
+		res.y = this.m10 * v.x + this.m11 * v.y + this.m12 * v.z + this.m13;
+		res.z = this.m20 * v.x + this.m21 * v.y + this.m22 * v.z + this.m23;
+		w     = this.m30 * v.x + this.m31 * v.y + this.m32 * v.z + this.m33;
+		
+		w = 1F / w;
+		res.x *= w;
+		res.y *= w;
+		res.z *= w;
+		return res;
+	}
+	
+	// Transforms a position by this matrix (fast).
+	CSRAW public Vector3 MultiplyPoint3x4 (Vector3 v)
+	{
+		Vector3 res;
+		res.x = this.m00 * v.x + this.m01 * v.y + this.m02 * v.z + this.m03;
+		res.y = this.m10 * v.x + this.m11 * v.y + this.m12 * v.z + this.m13;
+		res.z = this.m20 * v.x + this.m21 * v.y + this.m22 * v.z + this.m23;
+		return res;
+	}
+	
+	// Transforms a direction by this matrix.
+	CSRAW public Vector3 MultiplyVector (Vector3 v)
+	{
+		Vector3 res;
+		res.x = this.m00 * v.x + this.m01 * v.y + this.m02 * v.z;
+		res.y = this.m10 * v.x + this.m11 * v.y + this.m12 * v.z;
+		res.z = this.m20 * v.x + this.m21 * v.y + this.m22 * v.z;
+		return res;
+	}
+		
+	// Creates a scaling matrix.
+	CSRAW static public Matrix4x4 Scale (Vector3 v)
+	{
+		Matrix4x4 m = new Matrix4x4();
+		m.m00 = v.x; m.m01 =  0F; m.m02 =  0F; m.m03 =  0F; 
+		m.m10 =  0F; m.m11 = v.y; m.m12 =  0F; m.m13 =  0F; 
+		m.m20 =  0F; m.m21 =  0F; m.m22 = v.z; m.m23 =  0F; 
+		m.m30 =  0F; m.m31 =  0F; m.m32 =  0F; m.m33 =  1F; 
+		return m;
+	}
+	
+	// Returns a matrix with all elements set to zero (RO).
+	CSRAW public static Matrix4x4 zero {
+		get
+		{
+			Matrix4x4 m = new Matrix4x4();
+			m.m00 = 0F; m.m01 = 0F; m.m02 = 0F; m.m03 = 0F;
+			m.m10 = 0F; m.m11 = 0F; m.m12 = 0F; m.m13 = 0F;
+			m.m20 = 0F; m.m21 = 0F; m.m22 = 0F; m.m23 = 0F;
+			m.m30 = 0F; m.m31 = 0F; m.m32 = 0F; m.m33 = 0F;
+			return m;
+		}
+	}
+	
+	// Returns the identity matrix (RO).
+	CSRAW public static Matrix4x4 identity {
+		get
+		{
+			Matrix4x4 m = new Matrix4x4();
+			m.m00 = 1F; m.m01 = 0F; m.m02 = 0F; m.m03 = 0F;
+			m.m10 = 0F; m.m11 = 1F; m.m12 = 0F; m.m13 = 0F;
+			m.m20 = 0F; m.m21 = 0F; m.m22 = 1F; m.m23 = 0F;
+			m.m30 = 0F; m.m31 = 0F; m.m32 = 0F; m.m33 = 1F;
+			return m;
+		}
+	}
+	
+	// Sets this matrix to a translation, rotation and scaling matrix.
+	CSRAW public void SetTRS(Vector3 pos, Quaternion q, Vector3 s)
+	{
+		this = Matrix4x4.TRS(pos, q, s);
+	}
+	
+	// Creates a translation, rotation and scaling matrix.
+	CUSTOM static Matrix4x4 TRS(Vector3 pos, Quaternion q, Vector3 s)
+	{
+		Matrix4x4f temp;
+		temp.SetTRS(pos,q,s);
+		return temp;
+	}
+	
+	/// *listonly*
+	CSRAW override public string ToString() {
+		return UnityString.Format("{0:F5}\t{1:F5}\t{2:F5}\t{3:F5}\n{4:F5}\t{5:F5}\t{6:F5}\t{7:F5}\n{8:F5}\t{9:F5}\t{10:F5}\t{11:F5}\n{12:F5}\t{13:F5}\t{14:F5}\t{15:F5}\n", m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33);
+	}
+	// Returns a nicely formatted string for this matrix.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("{0}\t{1}\t{2}\t{3}\n{4}\t{5}\t{6}\t{7}\n{8}\t{9}\t{10}\t{11}\n{12}\t{13}\t{14}\t{15}\n",
+			m00.ToString(format), m01.ToString(format), m02.ToString(format), m03.ToString(format),
+			m10.ToString(format), m11.ToString(format), m12.ToString(format), m13.ToString(format),
+			m20.ToString(format), m21.ToString(format), m22.ToString(format), m23.ToString(format),
+			m30.ToString(format), m31.ToString(format), m32.ToString(format), m33.ToString(format));
+	}
+	
+	// Creates an orthogonal projection matrix.
+	CUSTOM static public Matrix4x4 Ortho (float left, float right, float bottom, float top, float zNear, float zFar) {
+		Matrix4x4f m;
+		m.SetOrtho(left, right, bottom, top, zNear, zFar);
+		return m;
+	}
+
+	// Creates a perspective projection matrix.
+	CUSTOM static public Matrix4x4 Perspective (float fov, float aspect, float zNear, float zFar) {
+		Matrix4x4f m;
+		m.SetPerspective( fov, aspect, zNear, zFar );
+		return m;
+	}
+END
+
+
+// Represents an axis aligned bounding box.
+THREAD_SAFE
+STRUCT Bounds
+	
+	CSRAW private Vector3 m_Center;
+	CSRAW private Vector3 m_Extents;
+
+	// Creates new Bounds with a given /center/ and total /size/. Bound ::ref::extents will be half the given size.
+	CSRAW public Bounds (Vector3 center, Vector3 size)
+	{
+		m_Center = center;
+		m_Extents = size * 0.5F;
+	}
+
+	// used to allow Bounds to be used as keys in hash tables
+	public override int GetHashCode() {
+		return center.GetHashCode() ^ (extents.GetHashCode()<<2);
+	}
+	
+	// also required for being able to use Vector4s as keys in hash tables
+	public override bool Equals(object other) {
+		if(!(other is Bounds)) return false;
+		
+		Bounds rhs=(Bounds)other;
+		return center.Equals(rhs.center) && extents.Equals(rhs.extents);
+	}
+
+	// The center of the bounding box.
+	CSRAW public Vector3 center { get { return m_Center; } set { m_Center = value; } }
+
+	// The total size of the box. This is always twice as large as the ::ref::extents.
+	CSRAW public Vector3 size { get { return m_Extents * 2.0F; } set { m_Extents = value * 0.5F; } }
+	
+	// The extents of the box. This is always half of the ::ref::size.
+	CSRAW public Vector3 extents { get { return m_Extents; } set { m_Extents = value; } }
+	
+	// The minimal point of the box. This is always equal to ''center-extents''.
+	CSRAW public Vector3 min { get { return center - extents; } set { SetMinMax (value, max); } }
+	// The maximal point of the box. This is always equal to ''center+extents''.
+	CSRAW public Vector3 max { get { return center + extents; } set { SetMinMax (min, value); } }
+
+	//*undoc*
+	CSRAW public static bool operator == (Bounds lhs, Bounds rhs)
+	{
+		return (lhs.center == rhs.center && lhs.extents == rhs.extents);
+	}	
+	//*undoc*
+	CSRAW public static bool operator != (Bounds lhs, Bounds rhs)
+	{
+		return !(lhs == rhs);
+	}
+
+	// Sets the bounds to the /min/ and /max/ value of the box.
+	CSRAW public void SetMinMax (Vector3 min, Vector3 max)
+	{
+		extents = (max - min) * 0.5F;
+		center = min + extents;
+	}
+		
+	// Grows the Bounds to include the /point/.
+	CSRAW public void Encapsulate (Vector3 point)
+	{
+		SetMinMax(Vector3.Min (min, point), Vector3.Max (max, point));
+	}
+
+	// Grow the bounds to encapsulate the bounds.
+	CSRAW public void Encapsulate (Bounds bounds) {
+		Encapsulate (bounds.center - bounds.extents);
+		Encapsulate (bounds.center + bounds.extents);
+	}	
+	
+	// Expand the bounds by increasing its /size/ by /amount/ along each side.
+	CSRAW public void Expand (float amount) {
+		amount *= .5f;
+		extents += new Vector3 (amount, amount, amount);
+	}
+	
+	// Expand the bounds by increasing its /size/ by /amount/ along each side.
+	CSRAW public void Expand (Vector3 amount) {
+		extents += amount * .5f;
+	}
+	
+	// Does another bounding box intersect with this bounding box?
+	CSRAW public bool Intersects (Bounds bounds) {
+		return (min.x <= bounds.max.x) && (max.x >= bounds.min.x) &&
+			   (min.y <= bounds.max.y) && (max.y >= bounds.min.y) &&
+			   (min.z <= bounds.max.z) && (max.z >= bounds.min.z);
+	}
+
+	CUSTOM private static bool Internal_Contains (Bounds m, Vector3 point) { return m.IsInside (point); }
+	// Is /point/ contained in the bounding box?
+	CSRAW public bool Contains (Vector3 point) { return Internal_Contains (this, point); }
+
+	CUSTOM private static float Internal_SqrDistance (Bounds m, Vector3 point) { return CalculateSqrDistance(point, m); }
+	
+	// The smallest squared distance between the point and this bounding box.
+	CSRAW public float SqrDistance (Vector3 point) { return Internal_SqrDistance(this, point); }
+
+	CUSTOM private static bool Internal_IntersectRay (ref Ray ray, ref Bounds bounds, out float distance) { return IntersectRayAABB(ray, bounds, distance); }
+
+	// Does /ray/ intersect this bounding box?
+	CSRAW public bool IntersectRay (Ray ray) { float dist; return Internal_IntersectRay (ref ray, ref this, out dist); }
+
+	// Does /ray/ intersect this bounding box?
+	CSRAW public bool IntersectRay (Ray ray, out float distance) { return Internal_IntersectRay (ref ray, ref this, out distance);	}
+	
+	/// *listonly*
+	CSRAW override public string ToString() {
+		return UnityString.Format("Center: {0}, Extents: {1}", m_Center, m_Extents);
+	}
+	// Returns a nicely formatted string for the bounds.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("Center: {0}, Extents: {1}", m_Center.ToString(format), m_Extents.ToString(format));
+	}
+
+
+END
+
+
+
+// Representation of four-dimensional vectors.
+THREAD_SAFE
+STRUCT Vector4
+
+	// *undocumented*
+	CSRAW public const float kEpsilon = 0.00001F;
+	
+	// X component of the vector.
+	CSRAW public float x;
+	// Y component of the vector.
+	CSRAW public float y;
+	// Z component of the vector.
+	CSRAW public float z;
+	// W component of the vector.
+	CSRAW public float w;
+	
+	// Access the x, y, z, w components using [0], [1], [2], [3] respectively.
+	CSRAW public float this [int index]
+	{
+		get
+		{
+			switch(index)
+			{
+				case 0: return x;
+				case 1: return y;
+				case 2: return z;
+				case 3: return w;
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector4 index!");
+			}
+		}
+
+		set
+		{
+			switch(index)
+			{
+				case 0: x = value; break;
+				case 1: y = value; break;
+				case 2: z = value; break;
+				case 3: w = value; break;
+				default:
+				throw new IndexOutOfRangeException("Invalid Vector4 index!");
+			}
+		}
+	}
+		
+	// Creates a new vector with given x, y, z, w components.
+	CSRAW public Vector4 (float x, float y, float z, float w) { this.x = x; this.y = y; this.z = z; this.w = w; }
+	// Creates a new vector with given x, y, z components and sets /w/ to zero.
+	CSRAW public Vector4 (float x, float y, float z) { this.x = x; this.y = y; this.z = z; this.w = 0F; }
+	// Creates a new vector with given x, y components and sets /z/ and /w/ to zero.
+	CSRAW public Vector4 (float x, float y) { this.x = x; this.y = y; this.z = 0F; this.w = 0F; }
+
+	// Set x, y, z and w components of an existing Vector4.
+	CSRAW public void Set (float new_x, float new_y, float new_z, float new_w) { x = new_x; y = new_y; z = new_z; w = new_w; }
+
+	// Linearly interpolates between two vectors.
+	CSRAW public static Vector4 Lerp (Vector4 from, Vector4 to, float t)
+	{ 
+		t = Mathf.Clamp01 (t);       
+		return new Vector4( 
+			from.x + (to.x - from.x)*t, 
+			from.y + (to.y - from.y)*t, 
+			from.z + (to.z - from.z)*t,
+			from.w + (to.w - from.w)*t 
+		); 
+	}
+	
+	// Moves a point /current/ towards /target/.
+	CSRAW static public Vector4 MoveTowards (Vector4 current, Vector4 target, float maxDistanceDelta)
+	{
+		Vector4 toVector = target - current;
+		float dist = toVector.magnitude;
+		if (dist <= maxDistanceDelta || dist == 0)
+			return target;
+		return current + toVector / dist * maxDistanceDelta;
+	}
+	
+	// Multiplies two vectors component-wise.
+	CSRAW public static Vector4 Scale (Vector4 a, Vector4 b) { return new Vector4 (a.x*b.x, a.y*b.y, a.z*b.z, a.w*b.w); }
+	// Multiplies every component of this vector by the same component of /scale/.
+	CSRAW public void Scale (Vector4 scale) { x *= scale.x; y *= scale.y; z *= scale.z; w *= scale.w; }
+	
+	
+	// used to allow Vector4s to be used as keys in hash tables
+	public override int GetHashCode() {
+		return x.GetHashCode() ^ (y.GetHashCode()<<2) ^ (z.GetHashCode()>>2) ^ (w.GetHashCode()>>1);
+	}
+	
+	// also required for being able to use Vector4s as keys in hash tables
+	public override bool Equals(object other) {
+		if(!(other is Vector4)) return false;
+		
+		Vector4 rhs=(Vector4)other;
+		return x.Equals(rhs.x) && y.Equals(rhs.y) && z.Equals(rhs.z) && w.Equals(rhs.w);
+	}
+	
+	// *undoc* --- we have normalized property now
+	CSRAW public static Vector4 Normalize (Vector4 a)
+	{
+		float mag = Magnitude (a);
+		if (mag > kEpsilon)
+			return a / mag;
+		else
+			return zero;			
+	}
+
+	// Makes this vector have a ::ref::magnitude of 1.
+	CSRAW public void Normalize ()
+	{
+		float mag = Magnitude (this);
+		if (mag > kEpsilon)
+			this = this / mag;
+		else
+			this = zero;
+	}
+	
+	// Returns this vector with a ::ref::magnitude of 1 (RO).
+	CSRAW public Vector4 normalized { get { return Vector4.Normalize(this); } }
+
+	
+	/// *listonly*
+	CSRAW override public string ToString() {
+		return UnityString.Format("({0:F1}, {1:F1}, {2:F1}, {3:F1})", x, y, z, w);
+	}
+	// Returns a nicely formatted string for this vector.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("({0}, {1}, {2}, {3})", x.ToString(format), y.ToString(format), z.ToString(format), w.ToString(format));
+	}
+
+
+	// Dot Product of two vectors.
+	CSRAW public static float Dot (Vector4 a, Vector4 b) { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; }
+	
+	// Projects a vector onto another vector.
+	CSRAW public static Vector4 Project (Vector4 a, Vector4 b) { return b * Dot (a, b) / Dot (b, b); }
+
+	// Returns the distance between /a/ and /b/.
+	CSRAW public static float Distance (Vector4 a, Vector4 b) { return Magnitude (a-b); }
+	
+	// *undoc* --- there's a property now
+	CSRAW public static float Magnitude (Vector4 a) { return Mathf.Sqrt (Dot (a, a)); }
+	
+	// Returns the length of this vector (RO).
+	CSRAW public float magnitude { get { return Mathf.Sqrt (Dot (this, this)); } }
+		
+	// *undoc* --- there's a property now
+	CSRAW public static float SqrMagnitude (Vector4 a) { return Vector4.Dot (a, a); }
+	// *undoc* --- there's a property now
+	CSRAW public float SqrMagnitude () { return Dot (this, this); }
+	
+	// Returns the squared length of this vector (RO).
+	CSRAW public float sqrMagnitude { get { return Dot (this, this); } }
+	
+	
+	// Returns a vector that is made from the smallest components of two vectors.
+	CSRAW public static Vector4 Min (Vector4 lhs, Vector4 rhs) { return new Vector4 (Mathf.Min(lhs.x,rhs.x), Mathf.Min(lhs.y,rhs.y), Mathf.Min(lhs.z,rhs.z), Mathf.Min(lhs.w,rhs.w)); }
+
+	// Returns a vector that is made from the largest components of two vectors.
+	CSRAW public static Vector4 Max (Vector4 lhs, Vector4 rhs) { return new Vector4 (Mathf.Max(lhs.x,rhs.x), Mathf.Max(lhs.y,rhs.y), Mathf.Max(lhs.z,rhs.z), Mathf.Max(lhs.w,rhs.w)); }
+	
+	// Shorthand for writing @@Vector4(0,0,0,0)@@
+	CSRAW public static Vector4 zero { get { return new Vector4 (0F, 0F, 0F, 0F); }   }
+	// Shorthand for writing @@Vector4(1,1,1,1)@@
+	CSRAW public static Vector4 one { get { return new Vector4 (1F, 1F, 1F, 1F); }   }
+
+
+	// Adds two vectors.
+	CSRAW public static Vector4 operator + (Vector4 a, Vector4 b) { return new Vector4 (a.x+b.x, a.y+b.y, a.z+b.z, a.w+b.w); }
+	// Subtracts one vector from another.
+	CSRAW public static Vector4 operator - (Vector4 a, Vector4 b) { return new Vector4 (a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w); }
+	// Negates a vector.
+	CSRAW public static Vector4 operator - (Vector4 a) { return new Vector4 (-a.x, -a.y, -a.z, -a.w); }
+	// Multiplies a vector by a number.
+	CSRAW public static Vector4 operator * (Vector4 a, float d) { return new Vector4 (a.x*d, a.y*d, a.z*d, a.w*d); }
+	// Multiplies a vector by a number.
+	CSRAW public static Vector4 operator * (float d, Vector4 a) { return new Vector4 (a.x*d, a.y*d, a.z*d, a.w*d); }
+	// Divides a vector by a number.
+	CSRAW public static Vector4 operator / (Vector4 a, float d) { return new Vector4 (a.x/d, a.y/d, a.z/d, a.w/d); }
+		
+	// Returns true if the vectors are equal.
+	CSRAW public static bool operator == (Vector4 lhs, Vector4 rhs)
+	{
+		return SqrMagnitude (lhs - rhs) < kEpsilon * kEpsilon;
+	}
+	// Returns true if vectors different.
+	CSRAW public static bool operator != (Vector4 lhs, Vector4 rhs)
+	{
+		return SqrMagnitude (lhs - rhs) >= kEpsilon * kEpsilon;
+	}
+	
+	// Converts a [[Vector3]] to a Vector4.
+	CSRAW public static implicit operator Vector4(Vector3 v) {
+		return new Vector4(v.x, v.y, v.z, 0.0F);
+	}
+	
+	// Converts a Vector4 to a [[Vector3]].
+	CSRAW public static implicit operator Vector3(Vector4 v) {
+		return new Vector3(v.x, v.y, v.z);
+	}
+	
+	// Converts a [[Vector2]] to a Vector4.
+	CSRAW public static implicit operator Vector4(Vector2 v) {
+		return new Vector4(v.x, v.y, 0.0F, 0.0F);
+	}
+	
+	// Converts a Vector4 to a [[Vector2]].
+	CSRAW public static implicit operator Vector2(Vector4 v) {
+		return new Vector2(v.x, v.y);
+	}
+
+END
+
+
+// Representation of rays.
+THREAD_SAFE
+STRUCT Ray
+	CSRAW private Vector3 m_Origin;
+	CSRAW private Vector3 m_Direction;
+
+	// Creates a ray starting at /origin/ along /direction/.
+	CSRAW public Ray (Vector3 origin, Vector3 direction) { m_Origin = origin; m_Direction = direction.normalized; }
+	
+	// The origin point of the ray.
+	CSRAW public Vector3 origin    { get { return m_Origin; } set { m_Origin = value; } }
+	// The direction of the ray.
+	CSRAW public Vector3 direction { get { return m_Direction; } set { m_Direction = value.normalized; } }
+	
+	// Returns a point at /distance/ units along the ray.
+	CSRAW public Vector3 GetPoint (float distance) { return m_Origin + m_Direction * distance; }
+
+	/// *listonly*
+	CSRAW override public string ToString() { return UnityString.Format("Origin: {0}, Dir: {1}", m_Origin, m_Direction); }
+	// Returns a nicely formatted string for this ray.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("Origin: {0}, Dir: {1}", m_Origin.ToString(format), m_Direction.ToString(format));
+	}
+
+END
+
+// Representation of 2D rays.
+THREAD_SAFE
+STRUCT Ray2D
+	CSRAW private Vector2 m_Origin;
+	CSRAW private Vector2 m_Direction;
+
+	// Creates a ray starting at /origin/ along /direction/.
+	CSRAW public Ray2D (Vector2 origin, Vector2 direction) { m_Origin = origin; m_Direction = direction.normalized; }
+	
+	// The origin point of the ray.
+	CSRAW public Vector2 origin { get { return m_Origin; } set { m_Origin = value; } }
+
+	// The direction of the ray.
+	CSRAW public Vector2 direction { get { return m_Direction; } set { m_Direction = value.normalized; } }
+	
+	// Returns a point at /distance/ units along the ray.
+	CSRAW public Vector2 GetPoint (float distance) { return m_Origin + m_Direction * distance; }
+
+	/// *listonly*
+	CSRAW override public string ToString() { return UnityString.Format("Origin: {0}, Dir: {1}", m_Origin, m_Direction); }
+
+	// Returns a nicely formatted string for this ray.
+	CSRAW public string ToString(string format) {
+		return UnityString.Format("Origin: {0}, Dir: {1}", m_Origin.ToString(format), m_Direction.ToString(format));
+	}
+
+END
+
+// Representation of planes.
+THREAD_SAFE
+STRUCT Plane 
+	CSRAW  Vector3 m_Normal;
+	CSRAW  float m_Distance;
+
+	// Normal vector of the plane.
+	CSRAW public Vector3 normal { get { return m_Normal; } set { m_Normal = value; } }
+	// Distance from the origin to the plane.
+	CSRAW public float distance { get { return m_Distance; } set { m_Distance = value; } }
+	
+	// Creates a plane.
+	public Plane (Vector3 inNormal, Vector3 inPoint) {	
+		m_Normal = Vector3.Normalize (inNormal);
+		m_Distance = -Vector3.Dot (inNormal, inPoint);
+	}
+
+	// Creates a plane.
+	public Plane (Vector3 inNormal, float d) {	
+		m_Normal = Vector3.Normalize (inNormal);
+		m_Distance = d;
+	}
+	
+	// Creates a plane.
+	public Plane (Vector3 a, Vector3 b, Vector3 c) {
+		m_Normal = Vector3.Normalize (Vector3.Cross (b - a, c - a));
+		m_Distance = -Vector3.Dot (m_Normal, a);	
+	}
+
+	// Sets a plane using a point that lies within it plus a normal to orient it (note that the normal must be a normalised vector).
+	public void SetNormalAndPosition (Vector3 inNormal, Vector3 inPoint) {
+		normal = Vector3.Normalize (inNormal);
+		distance = -Vector3.Dot (inNormal, inPoint);
+	}
+	
+	// Sets a plane using three points that lie within it.  The points go around clockwise as you look down on the top surface of the plane.
+	public void Set3Points (Vector3 a, Vector3 b, Vector3 c) {
+		normal = Vector3.Normalize (Vector3.Cross (b - a, c - a));
+		distance = -Vector3.Dot (normal, a);	
+	}
+
+	// Returns a signed distance from plane to point. 
+	public float GetDistanceToPoint (Vector3 inPt) { return Vector3.Dot (normal, inPt) + distance; }
+	
+	// Is a point on the positive side of the plane?
+	public bool GetSide (Vector3 inPt) { return Vector3.Dot (normal, inPt) + distance > 0.0F; }
+	
+	// Are two points on the same side of the plane?
+	public bool SameSide (Vector3 inPt0, Vector3 inPt1) {
+		float d0 = GetDistanceToPoint(inPt0);
+		float d1 = GetDistanceToPoint(inPt1);
+		if (d0 > 0.0f && d1 > 0.0f)
+			return true;
+		else if (d0 <= 0.0f && d1 <= 0.0f)
+			return true;
+		else
+			return false;
+	}
+
+	// Intersects a ray with the plane.
+	public bool Raycast (Ray ray, out float enter) {
+		float vdot = Vector3.Dot (ray.direction, normal);
+		float ndot = -Vector3.Dot (ray.origin, normal) - distance;
+
+		// is line parallel to the plane? if so, even if the line is
+		// at the plane it is not considered as intersection because
+		// it would be impossible to determine the point of intersection
+		if ( Mathf.Approximately (vdot, 0.0f) ) {
+			enter = 0.0F;
+			return false;
+		}
+		
+		// the resulting intersection is behind the origin of the ray
+		// if the result is negative ( enter < 0 )
+		enter = ndot / vdot;
+	
+		return enter > 0.0F;
+	}
+
+END
+
+
+// A collection of common math functions.
+THREAD_SAFE
+STRUCT Mathf
+	CSRAW
+
+	// Returns the sine of angle /f/ in radians.
+	CSRAW public static float Sin (float f) { return (float)Math.Sin (f); }
+
+	// Returns the cosine of angle /f/ in radians.
+	CSRAW public static float Cos (float f) { return (float)Math.Cos (f); }
+
+	// Returns the tangent of angle /f/ in radians.
+	CSRAW public static float Tan (float f) { return (float)Math.Tan (f); }
+
+	// Returns the arc-sine of /f/ - the angle in radians whose sine is /f/.
+	CSRAW public static float Asin (float f) { return (float)Math.Asin (f); }
+
+	// Returns the arc-cosine of /f/ - the angle in radians whose cosine is /f/.
+	CSRAW public static float Acos (float f) { return (float)Math.Acos (f); }
+
+	// Returns the arc-tangent of /f/ - the angle in radians whose tangent is /f/.
+	CSRAW public static float Atan (float f) { return (float)Math.Atan (f); }
+
+	// Returns the angle in radians whose ::ref::Tan is @@y/x@@.
+	CSRAW public static float Atan2 (float y, float x) { return (float)Math.Atan2 (y,x); }
+	
+	// Returns square root of /f/.
+	CSRAW public static float Sqrt (float f) { return (float)Math.Sqrt (f); }
+
+	// Returns the absolute value of /f/.
+	CSRAW public static float Abs (float f) { return (float)Math.Abs (f); }	
+
+	// Returns the absolute value of /value/.
+	CSRAW public static int Abs (int value) { return Math.Abs (value); }
+
+	/// *listonly*
+	CSRAW public static float Min (float a, float b) { return a < b ? a : b; }
+	// Returns the smallest of two or more values.
+	CSRAW public static float Min (params float[] values)
+	{
+		int len = values.Length; // cache the length
+		if (len == 0)
+			return 0;
+		float m = values[0];
+		for (int i=1; i<len; i++)
+		{
+			if (values[i] < m)
+				m = values[i];
+		}
+		return m;
+	}
+	
+	/// *listonly*
+	CSRAW public static int Min (int a, int b) { return a < b ? a : b; }
+	// Returns the smallest of two or more values.
+	CSRAW public static int Min (params int[] values)
+	{
+		int len = values.Length; // cache the length
+		if (len == 0)
+			return 0;
+		int m = values[0];
+		for (int i=1; i<len; i++)
+		{
+			if (values[i] < m)
+				m = values[i];
+		}
+		return m;
+	}
+
+	/// *listonly*
+	CSRAW public static float Max (float a, float b) { return a > b ? a : b; }
+	// Returns largest of two or more values.
+	CSRAW public static float Max (params float[] values)
+	{
+		int len = values.Length; // cache the length
+		if (len == 0)
+			return 0;
+		float m = values[0];
+		for (int i=1; i<len; i++)
+		{
+			if (values[i] > m)
+				m = values[i];
+		}
+		return m;
+	}
+
+	/// *listonly*
+	CSRAW public static int Max (int a, int b) { return a > b ? a : b; }
+	// Returns the largest of two or more values.
+	CSRAW public static int Max (params int[] values)
+	{
+		int len = values.Length; // cache the length
+		if (len == 0)
+			return 0;
+		int m = values[0];
+		for (int i=1; i<len; i++)
+		{
+			if (values[i] > m)
+				m = values[i];
+		}
+		return m;
+	}
+
+	// Returns /f/ raised to power /p/.
+	CSRAW public static float Pow (float f, float p) { return (float)Math.Pow (f, p); }
+
+	// Returns e raised to the specified power.
+	CSRAW public static float Exp (float power) { return (float)Math.Exp (power); }
+
+	// Returns the logarithm of a specified number in a specified base.
+	CSRAW public static float Log (float f, float p) { return (float)Math.Log (f, p); }
+
+	// Returns the natural (base e) logarithm of a specified number.
+	CSRAW public static float Log (float f) { return (float)Math.Log (f); }
+
+	// Returns the base 10 logarithm of a specified number.
+	CSRAW public static float Log10 (float f) { return (float)Math.Log10 (f); }
+
+	// Returns the smallest integer greater to or equal to /f/.
+	CSRAW public static float Ceil (float f) { return (float)Math.Ceiling (f); }
+
+	// Returns the largest integer smaller to or equal to /f/.
+	CSRAW public static float Floor (float f) { return (float)Math.Floor (f); }
+
+	// Returns /f/ rounded to the nearest integer.
+	CSRAW public static float Round (float f) { return (float)Math.Round (f); }
+
+	// Returns the smallest integer greater to or equal to /f/.
+	CSRAW public static int CeilToInt (float f) { return (int)Math.Ceiling (f); }
+
+	// Returns the largest integer smaller to or equal to /f/.
+	CSRAW public static int FloorToInt (float f) { return (int)Math.Floor (f); }
+
+	// Returns /f/ rounded to the nearest integer.
+	CSRAW public static int RoundToInt (float f) { return (int)Math.Round (f); }
+
+	// Returns the sign of /f/.
+	CSRAW public static float Sign (float f) { return f >= 0F ? 1F : -1F; }
+
+	// The infamous ''3.14159265358979...'' value (RO).
+	CSRAW public const float PI = (float)Math.PI;
+
+
+	// A representation of positive infinity (RO).
+	CSRAW public const float Infinity = Single.PositiveInfinity;
+
+
+	// A representation of negative infinity (RO).
+	CSRAW public const float NegativeInfinity = Single.NegativeInfinity;
+
+	
+	// Degrees-to-radians conversion constant (RO).
+	CSRAW public const float Deg2Rad = PI * 2F / 360F;
+	
+	// Radians-to-degrees conversion constant (RO).
+	CSRAW public const float Rad2Deg = 1F / Deg2Rad;
+	
+	// A tiny floating point value (RO).
+	#if UNITY_IPHONE || UNITY_BB10 || UNITY_TIZEN
+	CSRAW public const float Epsilon = 1.17549435E-38f; // VFP rounds de-normlized values to 0, unfortunatelly Single.Epsilon is de-normalized value!
+	#else
+	CSRAW public const float Epsilon = Single.Epsilon;
+	#endif
+	
+	
+	// Clamps a value between a minimum float and maximum float value.
+	CSRAW public static float Clamp (float value, float min, float max)
+	{
+		if (value < min)
+			value = min;
+		else if (value > max)
+			value = max;
+		return value;
+	}
+
+	// Clamps value between min and max and returns value.
+	// Set the position of the transform to be that of the time
+	// but never less than 1 or more than 3
+	//
+	CSRAW public static int Clamp (int value, int min, int max)
+	{
+		if (value < min)
+			value = min;
+		else if (value > max)
+			value = max;
+		return value;
+	}
+
+	// Clamps value between 0 and 1 and returns value
+	CSRAW public static float Clamp01 (float value)
+	{
+		if (value < 0F)
+			return 0F;
+		else if (value > 1F)
+			return 1F;
+		else
+			return value;
+	}
+	
+	// Interpolates between /a/ and /b/ by /t/. /t/ is clamped between 0 and 1.
+	CSRAW public static float Lerp (float from, float to, float t)
+	{
+		return from + (to - from) * Clamp01 (t);
+	}
+
+	// Same as ::ref::Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees.
+	CSRAW public static float LerpAngle (float a, float b, float t)
+	{
+		float delta = Repeat ((b - a), 360);
+		if (delta > 180)
+			delta -= 360;
+		return a + delta * Clamp01 (t);
+	}
+	
+	// Moves a value /current/ towards /target/.
+	CSRAW static public float MoveTowards (float current, float target, float maxDelta)
+	{
+		if (Mathf.Abs(target - current) <= maxDelta)
+			return target;
+		return current + Mathf.Sign(target - current) * maxDelta;
+	}
+	
+	// Same as ::ref::MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees.
+	CSRAW static public float MoveTowardsAngle (float current, float target, float maxDelta)
+	{
+		target = current + DeltaAngle(current, target);
+		return MoveTowards(current, target, maxDelta);
+	}
+	
+	// Interpolates between /min/ and /max/ with smoothing at the limits.
+	CSRAW public static float SmoothStep (float from, float to, float t) 
+	{
+		t = Mathf.Clamp01(t);
+		t = -2.0F * t*t*t + 3.0F * t*t;
+		return to * t + from * (1F - t);
+	}
+
+	//*undocumented
+	CSRAW public static float Gamma (float value, float absmax, float gamma)
+	{
+		bool negative = false;
+		if (value < 0F) 
+			negative = true;
+		float absval = Abs(value);
+		if (absval > absmax) 
+			return negative ? -absval : absval;
+		
+		float result = Pow(absval / absmax, gamma) * absmax;
+		return negative ? -result : result;
+	}
+	
+	// Compares two floating point values if they are similar.
+	CSRAW public static bool Approximately (float a, float b)
+	{
+		// If a or b is zero, compare that the other is less or equal to epsilon.
+		// If neither a or b are 0, then find an epsilon that is good for
+		// comparing numbers at the maximum magnitude of a and b.
+		// Floating points have about 7 significant digits, so
+		// 1.000001f can be represented while 1.0000001f is rounded to zero,
+		// thus we could use an epsilon of 0.000001f for comparing values close to 1.
+		// We multiply this epsilon by the biggest magnitude of a and b.
+		return Abs(b - a) < Max( 0.000001f * Max(Abs(a), Abs(b)), Epsilon*8);
+	}
+	
+	// Gradually changes a value towards a desired goal over time.
+	CSRAW public static float SmoothDamp (float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity, float deltaTime = Time.deltaTime)
+	{
+		// Based on Game Programming Gems 4 Chapter 1.10
+		smoothTime = Mathf.Max(0.0001F, smoothTime);
+		float omega = 2F / smoothTime;
+
+		float x = omega * deltaTime;
+		float exp = 1F / (1F + x + 0.48F*x*x + 0.235F*x*x*x);
+		float change = current - target;
+		float originalTo = target;
+
+		// Clamp maximum speed
+		float maxChange = maxSpeed * smoothTime;
+		change = Mathf.Clamp(change, -maxChange, maxChange);
+		target = current - change;
+		
+		float temp = (currentVelocity + omega * change) * deltaTime;
+		currentVelocity = (currentVelocity - omega * temp) * exp;
+		float output = target + (change + temp) * exp;
+
+		// Prevent overshooting
+		if (originalTo - current > 0.0F == output > originalTo)
+		{
+			output = originalTo;
+			currentVelocity = (output - originalTo) / deltaTime;
+		}
+
+		return output;
+	}
+	
+	
+	// Gradually changes an angle given in degrees towards a desired goal angle over time.
+	CSRAW public static float SmoothDampAngle (float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity, float deltaTime = Time.deltaTime)
+	{
+		// Normalize angles
+		target = current + DeltaAngle(current, target);
+		return SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
+	}
+
+	// Loops the value t, so that it is never larger than length and never smaller than 0.
+	CSRAW public static float Repeat (float t, float length)
+	{
+		return t - Mathf.Floor (t / length) * length;
+	}
+	
+	// PingPongs the value t, so that it is never larger than length and never smaller than 0.
+	CSRAW public static float PingPong (float t, float length)
+	{
+		t = Repeat (t, length * 2F);
+		return length - Mathf.Abs (t - length);
+	}
+	
+	// Calculates the ::ref::Lerp parameter between of two values.
+	CSRAW public static float InverseLerp (float from, float to, float value)
+	{
+		if (from < to)
+		{
+			if (value < from)
+				return 0.0F;
+			else if (value > to)
+				return 1.0F;
+			else
+			{
+				value -= from;
+				value /= (to - from);
+				return value;
+			}
+		}
+		else if (from > to)
+		{
+			if (value < to)
+				return 1.0F;
+			else if (value > from)
+				return 0.0F;
+			else
+			{
+				return 1.0F - ((value - to) / (from - to));
+			}
+		}
+		else
+		{
+			return 0.0F;
+		}
+	}
+
+	// Returns the closest power of two value.
+	CUSTOM static int ClosestPowerOfTwo (int value)
+	{
+		return ClosestPowerOfTwo(value);
+	}
+	
+	// Converts the given value from gamma to linear color space.
+	CUSTOM static float GammaToLinearSpace (float value)
+	{
+		return GammaToLinearSpace (value);
+	}
+	
+	// Converts the given value from linear to gamma color space.
+	CUSTOM static float LinearToGammaSpace (float value)
+	{
+		return LinearToGammaSpace (value);
+	}
+	
+	// Returns true if the value is power of two.
+	CUSTOM static bool IsPowerOfTwo (int value)
+	{
+		return IsPowerOfTwo(value);
+	}
+	
+	// Returns the next power of two value 
+	CUSTOM static int NextPowerOfTwo (int value)
+	{
+		return NextPowerOfTwo(value);
+	}	
+
+	// Calculates the shortest difference between two given angles.
+	CSRAW public static float DeltaAngle (float current, float target)
+	{
+		float delta = Mathf.Repeat ((target - current), 360.0F);
+		if (delta > 180.0F)
+			delta -= 360.0F;
+		return delta;
+	}
+
+	// Generate 2D Perlin noise.
+	CUSTOM static float PerlinNoise (float x, float y)
+	{
+		return PerlinNoise::NoiseNormalized (x,y);
+	}
+	
+
+	// Infinite Line Intersection (line1 is p1-p2 and line2 is p3-p4)
+	CSRAW internal static bool LineIntersection (Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, ref Vector2 result)
+	{
+		float bx = p2.x - p1.x;
+		float by = p2.y - p1.y;
+		float dx = p4.x - p3.x;
+		float dy = p4.y - p3.y;
+		float bDotDPerp = bx * dy - by * dx;
+		if (bDotDPerp == 0)
+		{
+			return false;
+		}
+		float cx = p3.x - p1.x;
+		float cy = p3.y - p1.y;
+		float t = (cx * dy - cy * dx) / bDotDPerp;
+
+		result = new Vector2 (p1.x + t * bx, p1.y + t * by);
+		return true;
+	}
+
+	// Line Segment Intersection (line1 is p1-p2 and line2 is p3-p4)
+	CSRAW internal static bool LineSegmentIntersection(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, ref Vector2 result)
+	{
+		float bx = p2.x - p1.x;
+		float by = p2.y - p1.y;
+		float dx = p4.x - p3.x;
+		float dy = p4.y - p3.y;
+		float bDotDPerp = bx * dy - by * dx;
+		if (bDotDPerp == 0)
+		{
+			return false;
+		}
+		float cx = p3.x - p1.x;
+		float cy = p3.y - p1.y;
+		float t = (cx * dy - cy * dx) / bDotDPerp;
+		if (t < 0 || t > 1)
+		{
+			return false;
+		}
+		float u = (cx * by - cy * bx) / bDotDPerp;
+		if (u < 0 || u > 1)
+		{
+			return false;
+		}
+		result = new Vector2(p1.x + t * bx, p1.y + t * by);
+		return true;
+	}	
+END
+CSRAW
+}