Hello Everyone. [I just downloaded this tool ][1]called “C# version extended with break time by by Francesco Montors” As soon as i imported it onto my game i got the following error,
Assets/SplineController_CS_Extended/SplineInterpolator.cs(290,17): error CS0103: The name `DebugUtils’ does not exist in the current context
/**
* STUFF DOWNLOADED FROM http://wiki.unity3d.com/index.php/Hermite_Spline_Controller
* AUTHOR: Benoit FOULETIER (http://wiki.unity3d.com/index.php/User:Benblo)
* MODIFIED BY F. Montorsi
*/
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class SplineNode
{
internal string Name;
internal Vector3 Point;
internal Quaternion Rot;
internal float ArrivalTime;
internal float BreakTime;
internal Vector2 EaseIO;
internal SplineNode(string n, Vector3 p, Quaternion q, float tArrival, float tBreak, Vector2 io)
{ Name = n; Point = p; Rot = q; ArrivalTime = tArrival; BreakTime = tBreak; EaseIO = io; }
internal SplineNode(SplineNode o)
{ Name = o.Name; Point = o.Point; Rot = o.Rot;
ArrivalTime = o.ArrivalTime; BreakTime = o.BreakTime;
EaseIO = o.EaseIO; }
// this is the constructor used by SplineController:
internal SplineNode(string n, Transform t, float tBreak)
{ Name = n; Point = t.position; Rot = t.rotation; BreakTime = tBreak; }
public float GetLeaveTime()
{ return ArrivalTime + BreakTime; }
}
public enum eEndPointsMode { AUTO, AUTOCLOSED, EXPLICIT }
public enum eWrapMode { ONCE, LOOP }
public delegate void OnPathEndCallback();
public delegate void OnNodeArrivalCallback(int idxArrival, SplineNode nodeArrival);
public delegate void OnNodeLeavingCallback(int idxLeaving, SplineNode nodeLeaving);
public class SplineInterpolator : MonoBehaviour
{
List<SplineNode> mNodes = new List<SplineNode>();
eEndPointsMode mEndPointsMode = eEndPointsMode.AUTO;
string mState = ""; // can be "Reset", "Stopped", "Once" or "Loop"
bool mRotations;
float mCurrentTime;
int mCurrentIdx = 1;
OnPathEndCallback mOnPathEndCallback;
OnNodeArrivalCallback mOnNodeArrivalCallback;
OnNodeLeavingCallback mOnNodeLeavingCallback;
int mLastNodeCallback = 0;
// --------------------------------------------------------------------------------------------
// UNITY CALLBACKS
// --------------------------------------------------------------------------------------------
void Awake()
{
Reset();
}
void Update()
{
if (mState == "Reset" || mState == "Stopped" || mNodes.Count < 4)
return;
mCurrentTime += Time.deltaTime;
if (mCurrentTime >= mNodes[mCurrentIdx + 1].ArrivalTime)
{
// advance to next point in the path
if (mCurrentIdx < mNodes.Count - 3)
{
mCurrentIdx++;
// Inform that we have just arrived to the mCurrentIdx -th node!
if (mOnNodeArrivalCallback != null)
mOnNodeArrivalCallback(mCurrentIdx, mNodes[mCurrentIdx]);
}
else
{
if (mState != "Loop")
{
mState = "Stopped";
// We stop right in the end point
transform.position = mNodes[mNodes.Count - 2].Point;
if (mRotations)
transform.rotation = mNodes[mNodes.Count - 2].Rot;
// We call back to inform that we are ended
if (mOnNodeArrivalCallback != null)
mOnNodeArrivalCallback(mCurrentIdx+1, mNodes[mCurrentIdx+1]);
if (mOnPathEndCallback != null)
mOnPathEndCallback();
}
else
{
mCurrentIdx = 1;
mCurrentTime = 0;
}
}
}
if (mState != "Stopped")
{
if (mCurrentTime >= mNodes[mCurrentIdx].GetLeaveTime())
{
if (mLastNodeCallback < mCurrentIdx && mOnNodeLeavingCallback != null)
{
// Inform that we have just left the mCurrentIdx-th node!
mOnNodeLeavingCallback(mCurrentIdx, mNodes[mCurrentIdx]);
mLastNodeCallback++;
}
//else: callback has already been called
// Calculates the t param between 0 and 1
float param = GetNormalizedTime(mCurrentIdx, mCurrentTime, mCurrentIdx+1);
// Smooth the param
param = MathUtils.Ease(param, mNodes[mCurrentIdx].EaseIO.x, mNodes[mCurrentIdx].EaseIO.y);
// Move attached transform
transform.position = GetHermiteInternal(mCurrentIdx, param);
/*
// simulate human walking (FIXME)
Vector3 tmp = new Vector3(transform.position.x, transform.position.y, transform.position.z);
tmp.y += 0.7f * Mathf.Sin (7*mCurrentTime);
transform.position = tmp;*/
if (mRotations)
{
// Rotate attached transform
transform.rotation = GetSquad(mCurrentIdx, param);
}
}
// else: we are in the "stop time" for the mCurrentIdx-th node
}
}
// --------------------------------------------------------------------------------------------
// PUBLIC MEMBERS
// --------------------------------------------------------------------------------------------
public void StartInterpolation(OnPathEndCallback endCallback,
OnNodeArrivalCallback nodeArrival,
OnNodeLeavingCallback nodeCallback,
bool bRotations, eWrapMode mode)
{
if (mState != "Reset")
throw new System.Exception("First reset, add points and then call here");
mState = mode == eWrapMode.ONCE ? "Once" : "Loop";
mRotations = bRotations;
mOnPathEndCallback = endCallback;
mOnNodeArrivalCallback = nodeArrival;
mOnNodeLeavingCallback = nodeCallback;
SetInput();
}
public void Reset()
{
mNodes.Clear();
mState = "Reset";
mCurrentIdx = 1;
mCurrentTime = 0;
mRotations = false;
mEndPointsMode = eEndPointsMode.AUTO;
}
public void AddPoint(string name, Vector3 pos, Quaternion quat,
float timeInSeconds, float timeStop,
Vector2 easeInOut)
{
if (mState != "Reset")
throw new System.Exception("Cannot add points after start");
mNodes.Add(new SplineNode(name, pos, quat, timeInSeconds, timeStop, easeInOut));
}
public void SetAutoCloseMode(float joiningPointTime)
{
if (mState != "Reset")
throw new System.Exception("Cannot change mode after start");
mEndPointsMode = eEndPointsMode.AUTOCLOSED;
mNodes.Add(new SplineNode(mNodes[0] as SplineNode));
mNodes[mNodes.Count - 1].ArrivalTime = joiningPointTime;
Vector3 vInitDir = (mNodes[1].Point - mNodes[0].Point).normalized;
Vector3 vEndDir = (mNodes[mNodes.Count - 2].Point - mNodes[mNodes.Count - 1].Point).normalized;
float firstLength = (mNodes[1].Point - mNodes[0].Point).magnitude;
float lastLength = (mNodes[mNodes.Count - 2].Point - mNodes[mNodes.Count - 1].Point).magnitude;
SplineNode firstNode = new SplineNode(mNodes[0] as SplineNode);
firstNode.Point = mNodes[0].Point + vEndDir * firstLength;
SplineNode lastNode = new SplineNode(mNodes[mNodes.Count - 1] as SplineNode);
lastNode.Point = mNodes[0].Point + vInitDir * lastLength;
mNodes.Insert(0, firstNode);
mNodes.Add(lastNode);
}
public Vector3 GetHermiteAtTime(float t)
{
// find the indices of the two nodes used for spline interpolation
// at time t
int c;
for (c = 0; c < mNodes.Count - 1 /* - 1 because we look at c+1 */; c++)
{
if (mNodes
.ArrivalTime <= t &&
t <= mNodes[c+1].ArrivalTime)
break;
}
// ensure c is in the correct range
if (c == mNodes.Count - 1)
return mNodes[c].Point;
float param = GetNormalizedTime(c, t, c+1); // c+1 is safe here thanks to prev check
param = MathUtils.Ease(param, mNodes[c].EaseIO.x, mNodes[c].EaseIO.y);
return GetHermiteInternal(c, param);
}
// --------------------------------------------------------------------------------------------
// PRIVATE MEMBERS
// --------------------------------------------------------------------------------------------
void SetInput()
{
if (mNodes.Count < 2)
throw new System.Exception("Invalid number of points");
if (mRotations)
{
for (int c = 1; c < mNodes.Count; c++)
{
SplineNode node = mNodes[c];
SplineNode prevNode = mNodes[c - 1];
// Always interpolate using the shortest path -> Selective negation
if (Quaternion.Dot(node.Rot, prevNode.Rot) < 0)
{
node.Rot.x = -node.Rot.x;
node.Rot.y = -node.Rot.y;
node.Rot.z = -node.Rot.z;
node.Rot.w = -node.Rot.w;
}
}
}
if (mEndPointsMode == eEndPointsMode.AUTO)
{
mNodes.Insert(0, mNodes[0]);
mNodes.Add(mNodes[mNodes.Count - 1]);
}
else if (mEndPointsMode == eEndPointsMode.EXPLICIT && (mNodes.Count < 4))
throw new System.Exception("Invalid number of points");
}
void SetExplicitMode()
{
if (mState != "Reset")
throw new System.Exception("Cannot change mode after start");
mEndPointsMode = eEndPointsMode.EXPLICIT;
}
float GetNormalizedTime(int idxPrev, float t, int idxNext)
{
DebugUtils.Assert(idxNext - idxPrev == 1);
// we take two params just for clariness, but idxNext must be idxPrev+1 always
if (t > mNodes[idxPrev].ArrivalTime &&
t < mNodes[idxPrev].GetLeaveTime())
return 0;
float ret = (t - mNodes[idxPrev].GetLeaveTime()) /
(mNodes[idxNext].ArrivalTime - mNodes[idxPrev].GetLeaveTime());
DebugUtils.Assert(ret >= 0 && ret <= 1);
return ret;
}
Quaternion GetSquad(int idxFirstPoint, float t)
{
Quaternion Q0 = mNodes[idxFirstPoint - 1].Rot;
Quaternion Q1 = mNodes[idxFirstPoint].Rot;
Quaternion Q2 = mNodes[idxFirstPoint + 1].Rot;
Quaternion Q3 = mNodes[idxFirstPoint + 2].Rot;
Quaternion T1 = MathUtils.GetSquadIntermediate(Q0, Q1, Q2);
Quaternion T2 = MathUtils.GetSquadIntermediate(Q1, Q2, Q3);
return MathUtils.GetQuatSquad(t, Q1, Q2, T1, T2);
}
Vector3 GetHermiteInternal(int idxFirstPoint, float t)
{
//DebugUtils.Assert(idxFirstPoint > 0 && idxFirstPoint < mNodes.Count - 2);
// the spline can be computed only from the second node up to the penultimate node!
if (idxFirstPoint == 0)
return mNodes[0].Point;
else if (idxFirstPoint == mNodes.Count - 1 ||
idxFirstPoint == mNodes.Count - 2)
return mNodes[idxFirstPoint].Point;
else if (idxFirstPoint > 0 && idxFirstPoint < mNodes.Count - 2)
{
float t2 = t * t;
float t3 = t2 * t;
Vector3 P0 = mNodes[idxFirstPoint - 1].Point; // take previous node
Vector3 P1 = mNodes[idxFirstPoint].Point;
Vector3 P2 = mNodes[idxFirstPoint + 1].Point; // take following node
Vector3 P3 = mNodes[idxFirstPoint + 2].Point; // take the following of the following!!
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;
return Blend1 * P1 + Blend2 * P2 + Blend3 * T1 + Blend4 * T2;
}
throw new System.Exception("logic error");
//return new Vector3(); // to avoid warnings
}
}
Thanks for the help!!!