Cunning Code

Here’s a simple cached C Sharp CR spline that takes control point input from a series of Transforms. Since GameObject.GetComponentsInChildren doesn’t supply an ordered iterator, the control points has to be assigned in the Inspector. It’s based on this spline code, so check that out as well.

The assigned transforms are rendered as spheres if you enable Gizmo draw mode. The actual curve render can also be toggled from the Inspector. Source code below.

using UnityEngine;
using System.Collections;

[System.Serializable]
public class CRSpline : MonoBehaviour {

 // User input ctrl points
 public Transform[] orderedPoints;

 // Renders the spline in game view
 public bool renderInGameView = true;

 // Renders the control points in gizmo draw mode
 public bool renderGizmos = true;

 // Same ctrl points, but padded endpoints
 private Transform[] pts; 

 // Number of subdivisions
 private int numSections = 60;

 // Precomputed cache
 private float[] cacheIx;
 private Vector3[] cacheVal;

 void Awake() {
   BuildCache(40);       
 }

 public void Update() {

   if(!renderInGameView) return;

   Vector3 lastPoint = InterpCached(0f);

   for(int i=0; i<numSections; i++) {
     float p = i / (float)numSections;
     Vector3 point = InterpCached(p);
     Debug.DrawLine(lastPoint, point, Color.white);       
     lastPoint = point;
   }   
 }

 // Draw spheres at the control points in edit mode / gizmo draw
 public void OnDrawGizmos() {

   if(!renderGizmos) return;

   if(pts != null) {
     foreach(Transform t in orderedPoints) {
       Gizmos.DrawSphere(t.position, 0.05f);               
     }   
   }
 }

 // Computes a cached version of the spline
 private void BuildCache(int numSegments) {

   // Pad control points in each end to clamp curve
   pts = new Transform[orderedPoints.Length + 2];

   for(int i=0; i<orderedPoints.Length; i++) {
     pts[i+1] = orderedPoints[i];
   }  

   pts[0] = pts[1];
   pts[pts.Length - 1] = pts[pts.Length - 2];

   // Build a cache table
   cacheVal = new Vector3[numSegments];
   cacheIx = new float[numSegments];
   for(int i=0; i<numSegments; i++) {
     float t = i / (float)numSegments;   
     Vector3 val = Interp(t);
     cacheIx[i] = t;
     cacheVal[i] = val;
   }
 }

 // Does a LERP on the precomputed cache, built at Awake.
 public Vector3 InterpCached(float t) {
   for(int i=0; i<cacheIx.Length-1; i++) {
     if(t >= cacheIx[i] && t < cacheIx[i+1])  {
       float rv = cacheIx[i+1] - cacheIx[i];
       float tv = t - cacheIx[i];
       return Vector3.Lerp(cacheVal[i], cacheVal[i+1], tv / rv);
     }
   }
   return cacheVal[cacheVal.Length-1];
 }

 /** Calculates the CR spline at T [0,1] */
 public Vector3 Interp(float t) {
   int numSections = pts.Length - 3;
   int currPt = Mathf.Min(Mathf.FloorToInt(t * (float) numSections), numSections - 1);
   float u = t * (float) numSections - (float) currPt;

   Vector3 a = pts[currPt].position;
   Vector3 b = pts[currPt + 1].position;
   Vector3 c = pts[currPt + 2].position;
   Vector3 d = pts[currPt + 3].position;

   return .5f * (
   (-a + 3f * b - 3f * c + d) * (u * u * u)
   + (2f * a - 5f * b + 4f * c - d) * (u * u)
   + (-a + c) * u
   + 2f * b
   );
 }
}

So, you would use the CRSpline.InterpCached(float) for efficient use of the spline during gameplay. If you need actual values and not interpolated ones, CRSpline.Interp(float) can be used.