Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 168 insertions, 0 deletions

diff --git a/APEX_1.4/common/include/Spline.h b/APEX_1.4/common/include/Spline.h
new file mode 100644
index 00000000..39e3bf60
--- /dev/null
+++ b/APEX_1.4/common/include/Spline.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef SPLINE_H
+
+#define SPLINE_H
+
+
+/** @file spline.h
+ *  @brief A utility class to manage 3d spline curves.
+ *
+ *  This is used heavily by the terrain terraforming tools for roads, lakes, and flatten operations.
+ *
+ *  @author John W. Ratcliff
+*/
+
+/** @file spline.cpp
+ *  @brief A utility class to manage 3d spline curves.
+ *
+ *  This is used heavily by the terrain terraforming tools for roads, lakes, and flatten operations.
+ *
+ *  @author John W. Ratcliff
+*/
+
+
+#include "PsArray.h"
+#include "PsUserAllocated.h"
+#include "PxVec3.h"
+#include "ApexUsingNamespace.h"
+
+class SplineNode
+{
+public:
+	float GetY(void) const
+	{ 
+		return y; 
+	};
+	float x;              // time/distance x-axis component.
+	float y;              // y component.
+	float u;
+	float p;
+};
+
+typedef nvidia::Array< SplineNode > SplineNodeVector;
+typedef nvidia::Array< physx::PxVec3 > PxVec3Vector;
+typedef nvidia::Array< uint32_t > uint32_tVector;
+
+class Spline : public nvidia::UserAllocated
+{
+public:
+	void Reserve(int32_t size)
+	{
+		mNodes.reserve((uint32_t)size);
+	};
+	void AddNode(float x,float y);
+	void ComputeSpline(void);
+	float Evaluate(float x,uint32_t &index,float &fraction) const; // evaluate Y component based on X
+	int32_t GetSize(void)  const
+	{ 
+		return (int32_t)mNodes.size(); 
+	}
+	float GetEntry(int32_t i) const 
+	{ 
+		return mNodes[(uint32_t)i].GetY(); 
+	};
+	void Clear(void)
+	{
+		mNodes.clear();
+	};
+private:
+	SplineNodeVector mNodes; // nodes.
+};
+
+class SplineCurve : public nvidia::UserAllocated
+{
+public:
+	void Reserve(int32_t size)
+	{
+		mXaxis.Reserve(size);
+		mYaxis.Reserve(size);
+		mZaxis.Reserve(size);
+	};
+
+	void setControlPoints(const PxVec3Vector &points)
+	{
+		Clear();
+		Reserve( (int32_t)points.size() );
+		for (uint32_t i=0; i<points.size(); i++)
+		{
+			AddControlPoint(points[i]);
+		}
+		ComputeSpline();
+	}
+
+	float AddControlPoint(const physx::PxVec3& p); // add control point, time is computed based on distance along the curve.
+	void AddControlPoint(const physx::PxVec3& p,float t); // add control point.
+
+	void GetPointOnSpline(float t,physx::PxVec3 &pos)
+	{
+		float d = t*mTime;
+		uint32_t index;
+		float fraction;
+		pos = Evaluate(d,index,fraction);
+	}
+
+	physx::PxVec3 Evaluate(float dist,uint32_t &index,float &fraction);
+
+	float GetLength(void) { return mTime; }; //total length of spline
+
+	int32_t GetSize(void) { return mXaxis.GetSize(); };
+
+	physx::PxVec3 GetEntry(int32_t i);
+
+	void ComputeSpline(void); // compute spline.
+
+	void Clear(void)
+	{
+		mXaxis.Clear();
+		mYaxis.Clear();
+		mZaxis.Clear();
+		mTime = 0;
+	};
+
+	float Set(const PxVec3Vector &vlist)
+	{
+		Clear();
+		int32_t count = (int32_t)vlist.size();
+		Reserve(count);
+		for (uint32_t i=0; i<vlist.size(); i++)
+		{
+			AddControlPoint( vlist[i] );
+		}
+		ComputeSpline();
+		return mTime;
+	};
+
+	void ResampleControlPoints(const PxVec3Vector &inputpoints,
+									  PxVec3Vector &outputpoints,
+									  uint32_tVector &outputIndex,
+ 									float dtime)
+	{
+		float length = Set(inputpoints);
+		for (float l=0; l<=length; l+=dtime)
+		{
+			uint32_t index;
+			float fraction;
+			physx::PxVec3 pos = Evaluate(l,index,fraction);
+			outputpoints.pushBack(pos);
+			outputIndex.pushBack(index);
+		}
+	};
+
+private:
+	float  mTime; // time/distance traveled.
+	Spline mXaxis;
+	Spline mYaxis;
+	Spline mZaxis;
+};
+
+#endif