Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 490 insertions, 0 deletions

diff --git a/KaplaDemo/samples/sampleViewer3/Vec/Vec3.h b/KaplaDemo/samples/sampleViewer3/Vec/Vec3.h
new file mode 100644
index 00000000..13b877dd
--- /dev/null
+++ b/KaplaDemo/samples/sampleViewer3/Vec/Vec3.h
@@ -0,0 +1,490 @@
+#ifndef VEC3_H
+#define VEC3_H
+
+#include <math.h>
+
+//	Singe / VecReal Precision Vec 3
+//  Matthias Mueller
+//  derived from NxVec3.h
+
+namespace M
+{
+
+#define VEC3_DOUBLE 0
+
+#if VEC3_DOUBLE
+
+typedef double VecReal;
+#define MAX_VEC_REAL DBL_MAX 
+#define MIN_VEC_REAL -DBL_MAX 
+#define VEC_PI 3.14159265358979323846
+
+inline int vecFloor(VecReal f ) { return (int)::floor(f); }
+inline VecReal vecSqrt(VecReal f) { return ::sqrt(f); }
+inline VecReal vecSin(VecReal f) { return ::sin(f); }
+inline VecReal vecCos(VecReal f) { return ::cos(f); }
+inline VecReal vecAbs(VecReal f) { return ::abs(f); }
+inline VecReal vecAtan2(VecReal y, VecReal x) { return ::atan2(y, x); }
+inline VecReal vecASin(VecReal f) { return ::asin(f); }
+inline VecReal vecACos(VecReal f) { return ::acos(f); }
+inline VecReal vecATan(VecReal f) { return ::atan(f); }
+
+#else
+
+typedef float VecReal;
+#define MAX_VEC_REAL FLT_MAX 
+#define MIN_VEC_REAL -FLT_MAX 
+#define VEC_PI 3.14159265358979323846f
+
+inline int vecFloor(VecReal f ) { return (int)::floorf(f); }
+inline VecReal vecSqrt(VecReal f) { return ::sqrtf(f); }
+inline VecReal vecSin(VecReal f) { return ::sinf(f); }
+inline VecReal vecCos(VecReal f) { return ::cosf(f); }
+inline VecReal vecAbs(VecReal f) { return ::fabs(f); }
+inline VecReal vecAtan2(VecReal y, VecReal x) { return ::atan2f(y, x); }
+inline VecReal vecASin(VecReal f) { return ::asinf(f); }
+inline VecReal vecACos(VecReal f) { return ::acosf(f); }
+inline VecReal vecATan(VecReal f) { return ::atanf(f); }
+
+#endif
+
+
+/**
+\brief Enum to classify an axis.
+*/
+	enum DAxisType
+	{
+		D_AXIS_PLUS_X,
+		D_AXIS_MINUS_X,
+		D_AXIS_PLUS_Y,
+		D_AXIS_MINUS_Y,
+		D_AXIS_PLUS_Z,
+		D_AXIS_MINUS_Z,
+		D_AXIS_ARBITRARY
+	};
+
+// -------------------------------------------------------------------------------------
+class Vec3
+{
+public:
+	VecReal x,y,z;
+
+	Vec3() {};
+	Vec3(VecReal _x, VecReal _y, VecReal _z) : x(_x), y(_y), z(_z) {}
+	Vec3(const VecReal v[]) : x(v[0]), y(v[1]), z(v[2]) {}
+
+	const VecReal* Vec3::get() const { return &x;}
+	VecReal* get() { return &x; }
+	void  get(VecReal * v) const
+	{
+		v[0] = x;
+		v[1] = y;
+		v[2] = z;
+	}
+
+	VecReal& operator[](int index)
+	{
+		return (&x)[index];
+	}
+
+	const VecReal  operator[](int index) const
+	{
+		return (&x)[index];
+	}
+
+	void setx(const VecReal & d) 
+	{ 
+		x = d; 
+	}
+
+
+	void sety(const VecReal & d) 
+	{ 
+		y = d; 
+	}
+
+
+	void setz(const VecReal & d) 
+	{ 
+		z = d; 
+	}
+
+	Vec3 getNormalized() const
+	{
+		const VecReal m = magnitudeSquared();
+		return m>0 ? *this * 1.0 / vecSqrt(m) : Vec3(0,0,0);
+	}
+
+	//Operators
+
+	bool operator< (const Vec3&v) const
+	{
+		return ((x < v.x)&&(y < v.y)&&(z < v.z));
+	}
+
+
+	bool operator==(const Vec3& v) const
+	{
+		return ((x == v.x)&&(y == v.y)&&(z == v.z));
+	}
+
+
+	bool operator!=(const Vec3& v) const
+	{
+		return ((x != v.x)||(y != v.y)||(z != v.z));
+	}
+
+	//Methods
+
+	void  set(const Vec3 & v)
+	{
+		x = v.x;
+		y = v.y;
+		z = v.z;
+	}
+
+
+	void  setNegative(const Vec3 & v)
+	{
+		x = -v.x;
+		y = -v.y;
+		z = -v.z;
+	}
+
+
+	void  setNegative()
+	{
+		x = -x;
+		y = -y;
+		z = -z;
+	}
+
+
+
+	void  set(const VecReal * v)
+	{
+		x = v[0];
+		y = v[1];
+		z = v[2];
+	}
+
+
+	void  set(VecReal _x, VecReal _y, VecReal _z)
+	{
+		this->x = _x;
+		this->y = _y;
+		this->z = _z;
+	}
+
+
+	void set(VecReal v)
+	{
+		x = v;
+		y = v;
+		z = v;
+	}
+
+
+	void  zero()
+	{
+		x = y = z = 0.0;
+	}
+
+
+	void  setPlusInfinity()
+	{
+		x = y = z = MAX_VEC_REAL; 
+	}
+
+
+	void  setMinusInfinity()
+	{
+		x = y = z = MIN_VEC_REAL; 
+	}
+
+
+	void max(const Vec3 & v)
+	{
+		x = x > v.x ? x : v.x;
+		y = y > v.y ? y : v.y;
+		z = z > v.z ? z : v.z;
+	}
+
+	void min(const Vec3 & v)
+	{
+		x = x < v.x ? x : v.x;
+		y = y < v.y ? y : v.y;
+		z = z < v.z ? z : v.z;
+	}
+
+
+
+
+	void  add(const Vec3 & a, const Vec3 & b)
+	{
+		x = a.x + b.x;
+		y = a.y + b.y;
+		z = a.z + b.z;
+	}
+
+
+	void  subtract(const Vec3 &a, const Vec3 &b)
+	{
+		x = a.x - b.x;
+		y = a.y - b.y;
+		z = a.z - b.z;
+	}
+
+
+	void  arrayMultiply(const Vec3 &a, const Vec3 &b)
+	{
+		x = a.x * b.x;
+		y = a.y * b.y;
+		z = a.z * b.z;
+	}
+
+
+	void  multiply(VecReal s,  const Vec3 & a)
+	{
+		x = a.x * s;
+		y = a.y * s;
+		z = a.z * s;
+	}
+
+
+	void  multiplyAdd(VecReal s, const Vec3 & a, const Vec3 & b)
+	{
+		x = s * a.x + b.x;
+		y = s * a.y + b.y;
+		z = s * a.z + b.z;
+	}
+
+
+	VecReal normalize()
+	{
+		VecReal m = magnitude();
+		if (m)
+		{
+			const VecReal il =  VecReal(1.0) / m;
+			x *= il;
+			y *= il;
+			z *= il;
+		}
+		return m;
+	}
+
+
+	void setMagnitude(VecReal length)
+	{
+		VecReal m = magnitude();
+		if(m)
+		{
+			VecReal newLength = length / m;
+			x *= newLength;
+			y *= newLength;
+			z *= newLength;
+		}
+	}
+
+
+	DAxisType snapToClosestAxis()
+	{
+		const VecReal almostOne = 0.999999f;
+		if(x >=  almostOne) { set( 1.0f,  0.0f,  0.0f);	return D_AXIS_PLUS_X ; }
+		else	if(x <= -almostOne) { set(-1.0f,  0.0f,  0.0f);	return D_AXIS_MINUS_X; }
+		else	if(y >=  almostOne) { set( 0.0f,  1.0f,  0.0f);	return D_AXIS_PLUS_Y ; }
+		else	if(y <= -almostOne) { set( 0.0f, -1.0f,  0.0f);	return D_AXIS_MINUS_Y; }
+		else	if(z >=  almostOne) { set( 0.0f,  0.0f,  1.0f);	return D_AXIS_PLUS_Z ; }
+		else	if(z <= -almostOne) { set( 0.0f,  0.0f, -1.0f);	return D_AXIS_MINUS_Z; }
+		else													return D_AXIS_ARBITRARY;
+	}
+
+
+	unsigned int closestAxis() const
+	{
+		const VecReal* vals = &x;
+		unsigned int  m = 0;
+		if(abs(vals[1]) > abs(vals[m])) m = 1;
+		if(abs(vals[2]) > abs(vals[m])) m = 2;
+		return m;
+	}
+
+
+	//const methods
+
+	//bool isFinite() const
+	//{
+	//	return NxMath::isFinite(x) && NxMath::isFinite(y) && NxMath::isFinite(z);
+	//}
+
+
+	VecReal dot(const Vec3 &v) const
+	{
+		return x * v.x + y * v.y + z * v.z;
+	}
+
+
+	bool sameDirection(const Vec3 &v) const
+	{
+		return x*v.x + y*v.y + z*v.z >= 0.0f;
+	}
+
+
+	VecReal magnitude() const
+	{
+		return sqrt(x * x + y * y + z * z);
+	}
+
+
+	VecReal magnitudeSquared() const
+	{
+		return x * x + y * y + z * z;
+	}
+
+
+	VecReal distance(const Vec3 & v) const
+	{
+		VecReal dx = x - v.x;
+		VecReal dy = y - v.y;
+		VecReal dz = z - v.z;
+		return sqrt(dx * dx + dy * dy + dz * dz);
+	}
+
+
+	VecReal distanceSquared(const Vec3 &v) const
+	{
+		VecReal dx = x - v.x;
+		VecReal dy = y - v.y;
+		VecReal dz = z - v.z;
+		return dx * dx + dy * dy + dz * dz;
+	}
+
+
+	void cross(const Vec3 &left, const Vec3 & right)	//prefered version, w/o temp object.
+	{
+		// temps needed in case left or right is this.
+		VecReal a = (left.y * right.z) - (left.z * right.y);
+		VecReal b = (left.z * right.x) - (left.x * right.z);
+		VecReal c = (left.x * right.y) - (left.y * right.x);
+
+		x = a;
+		y = b;
+		z = c;
+	}
+
+
+	bool equals(const Vec3 & v, VecReal epsilon) const
+	{
+		return 
+			abs(x - v.x) < epsilon &&
+			abs(y - v.y) < epsilon &&
+			abs(z - v.z) < epsilon;
+	}
+
+
+
+	Vec3 operator -() const
+	{
+		return Vec3(-x, -y, -z);
+	}
+
+
+	Vec3 operator +(const Vec3 & v) const
+	{
+		return Vec3(x + v.x, y + v.y, z + v.z);	// RVO version
+	}
+
+
+	Vec3 operator -(const Vec3 & v) const
+	{
+		return Vec3(x - v.x, y - v.y, z - v.z);	// RVO version
+	}
+
+
+
+	Vec3 operator *(VecReal f) const
+	{
+		return Vec3(x * f, y * f, z * f);	// RVO version
+	}
+
+
+	Vec3 operator /(VecReal f) const
+	{
+		f = VecReal(1.0) / f; return Vec3(x * f, y * f, z * f);
+	}
+
+
+	Vec3& operator +=(const Vec3& v)
+	{
+		x += v.x;
+		y += v.y;
+		z += v.z;
+		return *this;
+	}
+
+
+	Vec3& operator -=(const Vec3& v)
+	{
+		x -= v.x;
+		y -= v.y;
+		z -= v.z;
+		return *this;
+	}
+
+
+	Vec3& operator *=(VecReal f)
+	{
+		x *= f;
+		y *= f;
+		z *= f;
+
+		return *this;
+	}
+
+
+	Vec3& operator /=(VecReal f)
+	{
+		f = 1.0f/f;
+		x *= f;
+		y *= f;
+		z *= f;
+
+		return *this;
+	}
+
+
+	Vec3 cross(const Vec3& v) const
+	{
+		Vec3 temp;
+		temp.cross(*this,v);
+		return temp;
+	}
+
+
+	Vec3 operator^(const Vec3& v) const
+	{
+		Vec3 temp;
+		temp.cross(*this,v);
+		return temp;
+	}
+
+
+	VecReal operator|(const Vec3& v) const
+	{
+		return x * v.x + y * v.y + z * v.z;
+	}
+};
+
+	/**
+	scalar pre-multiplication
+	*/
+
+inline Vec3 operator *(VecReal f, const Vec3& v)
+	{
+		return Vec3(f * v.x, f * v.y, f * v.z);
+	}
+
+
+}
+	/** @} */
+#endif