GenInterpolationPoint_BF.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class GenInterpolationPoint_BF {
    
    //public parameters
    public GameObject SplineParent;
    public float Duration = 1.0f;
    public int lineCount=1000;
    public ArrayList InputKeyNodes;
    public List<string> InputTypeArray;
    //C.R
    public List<float> InputBfactArray;
    
    public List<float[]> OutputKeyNodes;
    public List<string> OutputTypeArray;
    //C.R
    public List<float> OutputBfactArray;

//  private Transform[] mTransforms;
    private List<SplineNode> mNodes;
    
    public static int smoothnessFactor = 8 ;
    
    //test the node data varibles
    
    public GameObject temp;
    public float moveSpeed=10f;
//  private int curIdx=0;
//  private float curTime=0;
//  private float moveTime=0;
    private Vector3 NextPos;
    private Vector3 CurPos;
    private Quaternion CurRot;
    private Quaternion NextRot;
    
    private Vector3[] Nodes;
    

    public void CalculateSpline() {
            lineCount=InputKeyNodes.Count*smoothnessFactor;

            SetupSplineInterpolator();
            OutputKeyNodes=new List<float[]>();
            OutputTypeArray=new List<string>();
            //C.R
            OutputBfactArray = new List<float> ();
            
            Gizmos.color = new Color(0.0f, 0.0f, 1.0f);
            for (int c=1; c <lineCount; c++) {
                float currTime = c * Duration / lineCount;
                Vector3 currPos = GetHermiteAtTime(currTime);
                
                float[] currposfloat=new float[3];
                currposfloat[0]=currPos.x;
                currposfloat[1]=currPos.y;
                currposfloat[2]=currPos.z;
                OutputKeyNodes.Add(currposfloat);
                OutputTypeArray.Add(InputTypeArray[0]);
//              MonoBehaviour.print("CalculateSpline");
            }
    }

    void SetupSplineInterpolator() {
        int c;
        float step;
        mNodes = new List<SplineNode>();
        step = Duration/InputKeyNodes.Count;
        
        for (c = 0; c < InputKeyNodes.Count; c++) {
            float[] vect=(float[])InputKeyNodes[c];
            Vector3 inputnode=new Vector3(vect[0],vect[1],vect[2]);
            mNodes.Add(new SplineNode(inputnode, step*c));
        }
//      SetAutoCloseMode(step*c);
        
        mNodes.Insert(0,mNodes[0]);
        mNodes.Add(mNodes[mNodes.Count-1]);
    }
    
        
    public Vector3 GetHermiteInternal(int idxFirstPoint ,float t){
        float t2 = t*t; float t3 = t2*t;
        
        Vector3 P0 = mNodes[idxFirstPoint-1].Point;
        Vector3 P1 = mNodes[idxFirstPoint].Point;
        Vector3 P2 = mNodes[idxFirstPoint+1].Point;
        Vector3 P3 = mNodes[idxFirstPoint+2].Point;
        
        float tension = 0.5f;  // 0.5 equivale a catmull-rom
        
        Vector3 T1 = tension * (P2 - P0);
        Vector3 T2 = tension * (P3 - P1);
        
        float Blend1 =  2*t3 - 3*t2 + 1;
        float Blend2 = -2*t3 + 3*t2;
        float Blend3 =    t3 - 2*t2 + t;
        float Blend4 =    t3 -   t2;

        //C.R

        if (idxFirstPoint < mNodes.Count - 3) {
            OutputBfactArray.Add (InputBfactArray [idxFirstPoint] + ((InputBfactArray [idxFirstPoint+1] - InputBfactArray [idxFirstPoint]) / smoothnessFactor) * (t * smoothnessFactor));
    //      Debug.Log ("resultat " + ((InputBfactArray [idxFirstPoint] - InputBfactArray [idxFirstPoint + 1]) / smoothnessFactor)* (t * smoothnessFactor));
        }else
            OutputBfactArray.Add (InputBfactArray [idxFirstPoint]);

        // C.R

        return Blend1*P1 + Blend2*P2 + Blend3*T1 + Blend4*T2;
    }
    
    public Vector3 GetHermiteAtTime(float timeParam){   
        int c;
        if (timeParam >= mNodes [mNodes.Count - 2].Time) {
        //  C.R
            OutputBfactArray.Add (InputBfactArray[InputBfactArray.Count-1]);
        //C.R
            return mNodes [mNodes.Count - 2].Point;
                }
        
        for (c = 1; c < mNodes.Count-2; c++){
            if (mNodes[c].Time > timeParam)
                break;
        }
        
        int idx = c-1;
        float param = (timeParam - mNodes[idx].Time) / (mNodes[idx+1].Time - mNodes[idx].Time);                                                                                                                                                                                                                                                                                                                                        
        param = MathUtils.Ease(param, 0.0f, 0.1f);
        
        return GetHermiteInternal(idx, param);
    }
    
    //define the node class
    class SplineNode{
        public Vector3 Point;
        public float Time;
                
        public SplineNode(Vector3 p,float t){ 
            Point=p; 
            Time=t; 
        }
        
        public SplineNode(SplineNode o){ 
            Point=o.Point; 
            Time=o.Time; 
        }
    }

}