private void BezierCubicTest(MyVector3 posA, MyVector3 posB, MyVector3 handleA, MyVector3 handleB)
{
//Store the interpolated values so we later can display them
List <Vector3> interpolatedValues = new List <Vector3>();
//Loop between 0 and 1 in steps, where 1 step is minimum
//So if steps is 5 then the line will be cut in 5 sections
int steps = 20;
float t_stepSize = 1f / (float)steps;
float t = 0f;
//+1 becuase wa also have to include the first point
for (int i = 0; i < steps + 1; i++)
{
//Debug.Log(t);
MyVector3 interpolatedPos = BezierCubic.GetPosition(posA, posB, handleA, handleB, t);
interpolatedValues.Add(interpolatedPos.ToVector3());
t += t_stepSize;
}
//The curve
DisplayInterpolation.DisplayCurve(interpolatedValues, useRandomColor: true);
//The start and end values and the handle points
DisplayInterpolation.DisplayHandle(handleA.ToVector3(), posA.ToVector3());
DisplayInterpolation.DisplayHandle(handleB.ToVector3(), posB.ToVector3());
}
private void BezierLinearTest(MyVector3 posA, MyVector3 posB)
{
//Store the interpolated values so we later can display them
List <Vector3> interpolatedValues = new List <Vector3>();
//Loop between 0 and 1 in steps, where 1 step is minimum
//So if steps is 5 then the line will be cut in 5 sections
int steps = 5;
float stepSize = 1f / (float)steps;
float t = 0f;
//+1 becuase wa also have to include the first point
for (int i = 0; i < steps + 1; i++)
{
//Debug.Log(t);
MyVector3 interpolatedValue = BezierLinear.GetPosition(posA, posB, t);
interpolatedValues.Add(interpolatedValue.ToVector3());
t += stepSize;
}
DisplayInterpolation.DisplayCurve(interpolatedValues, useRandomColor: true);
}
public bool DeepEquals(StatGroupScaledStat other)
{
return(other != null &&
DisplayAsNumeric == other.DisplayAsNumeric &&
DisplayInterpolation.DeepEqualsReadOnlyCollections(other.DisplayInterpolation) &&
MaximumValue == other.MaximumValue &&
Stat.DeepEquals(other.Stat));
}
private void CatmullRomTest(MyVector3 posA, MyVector3 posB, MyVector3 handleA, MyVector3 handleB)
{
CatmullRom catmullRomCurve = new CatmullRom(posA, posB, handleA, handleB);
//Store the interpolated values so we later can display them
List <Vector3> positions = new List <Vector3>();
List <Vector3> tangents = new List <Vector3>();
List <float> tValues = new List <float>();
//Loop between 0 and 1 in steps, where 1 step is minimum
//So if steps is 5 then the line will be cut in 5 sections
int steps = 5;
float stepSize = 1f / (float)steps;
float t = 0f;
//+1 becuase wa also have to include the first point
for (int i = 0; i < steps + 1; i++)
{
//Debug.Log(t);
MyVector3 interpolatedPos = CatmullRom.GetPosition(posA, posB, handleA, handleB, t);
positions.Add(interpolatedPos.ToVector3());
MyVector3 interpolatedTangent = CatmullRom.GetTangent(posA, posB, handleA, handleB, t);
tangents.Add(interpolatedTangent.ToVector3());
tValues.Add(t);
t += stepSize;
}
List <InterpolationTransform> transforms = InterpolationTransform.GetTransforms_RotationMinimisingFrame(catmullRomCurve, tValues, MyVector3.Up);
//Display
//DisplayInterpolation.DisplayCurve(positions, useRandomColor: true);
DisplayInterpolation.DisplayCurve(positions, Color.black);
//The actual curve for comparison
DisplayInterpolation.DisplayCurve(catmullRomCurve, Color.gray);
//The control points
//The start and end values and the handle points
DisplayInterpolation.DisplayHandle(handleA.ToVector3(), posA.ToVector3());
DisplayInterpolation.DisplayHandle(handleB.ToVector3(), posB.ToVector3());
//Other stuff
//DisplayInterpolation.DisplayDirections(positions, tangents, 1f, Color.blue);
DisplayInterpolation.DisplayOrientations(transforms, 1f);
}
//Interpolation between values
private void OtherInterpolations(MyVector3 a, MyVector3 b)
{
//Store the interpolated values so we later can display them
List <Vector3> interpolatedValues = new List <Vector3>();
//Loop between 0 and 1 in steps, where 1 step is minimum
//So if steps is 5 then the line will be cut in 5 sections
int steps = 10;
float stepSize = 1f / (float)steps;
float t = 0f;
//+1 becuase wa also have to include the first point
for (int i = 0; i < steps + 1; i++)
{
//Debug.Log(t);
//Ease out
//float interpolatedValueX = _Interpolation.Sinerp(a.x, b.x, t);
//float interpolatedValueZ = _Interpolation.Sinerp(a.z, b.z, t);
//Ease in
//float interpolatedValueX = _Interpolation.Coserp(a.x, b.x, t);
//float interpolatedValueZ = _Interpolation.Coserp(a.z, b.z, t);
//Exponential
//float interpolatedValueX = _Interpolation.Eerp(a.x, b.x, t);
//float interpolatedValueZ = _Interpolation.Eerp(a.z, b.z, t);
//Smoothstep and Smootherstep
float interpolatedValueX = _Interpolation.Smoothersteperp(a.x, b.x, t);
float interpolatedValueZ = _Interpolation.Smoothersteperp(a.z, b.z, t);
//Similar to bezier cubic
//float handleA = 0f;
//float handleB = 0.5f;
//float interpolatedValueX = _Interpolation.CubicBezierErp(a.x, b.x, handleA, handleB, t);
//float interpolatedValueZ = _Interpolation.CubicBezierErp(a.z, b.z, handleA, handleB, t);
Vector3 interpolatedPos = new Vector3(interpolatedValueX, 0f, interpolatedValueZ);
interpolatedValues.Add(interpolatedPos);
t += stepSize;
}
DisplayInterpolation.DisplayCurve(interpolatedValues, useRandomColor: true);
}
private void BezierQuadraticTest(MyVector3 posA, MyVector3 posB, MyVector3 handle)
{
//Store the interpolated values so we later can display them
List <Vector3> interpolatedValues = new List <Vector3>();
//Loop between 0 and 1 in steps, where 1 step is minimum
//So if steps is 5 then the line will be cut in 5 sections
int steps = 10;
float stepSize = 1f / (float)steps;
float t = 0f;
//+1 becuase wa also have to include the first point
for (int i = 0; i < steps + 1; i++)
{
//Debug.Log(t);
MyVector3 interpolatedValue = BezierQuadratic.GetPosition(posA, posB, handle, t);
interpolatedValues.Add(interpolatedValue.ToVector3());
t += stepSize;
}
//Display the curve
DisplayInterpolation.DisplayCurve(interpolatedValues, useRandomColor: true);
//Display the start and end values and the handle points
DisplayInterpolation.DisplayHandle(handle.ToVector3(), posA.ToVector3());
DisplayInterpolation.DisplayHandle(handle.ToVector3(), posB.ToVector3());
//Display other related data
//Get the forwrd dir of the point at t and display it
MyVector3 forwardDir = BezierQuadratic.GetTangent(posA, posB, handle, tSliderValue);
MyVector3 slidePos = BezierQuadratic.GetPosition(posA, posB, handle, tSliderValue);
Gizmos.color = Color.blue;
Gizmos.DrawRay(slidePos.ToVector3(), forwardDir.ToVector3());
Gizmos.color = Color.red;
Gizmos.DrawWireSphere(slidePos.ToVector3(), 0.15f);
}
//Uses transforms as start and end position, the length of the handles is determines by the z scale of each transform
private void BezierCubicTest_Transform(InterpolationTransform transA, InterpolationTransform transB, float scaleA, float scaleB)
{
MyVector3 posA = transA.position;
MyVector3 posB = transB.position;
//The forward vector should move along from a to b
MyVector3 handleA = posA + transA.Forward * scaleA;
MyVector3 handleB = posB + -transB.Forward * scaleB;
BezierCubic curve = new BezierCubic(posA, posB, handleA, handleB);
//The interpolated values
List <Vector3> positions = new List <Vector3>();
List <float> tValues = new List <float>();
//Loop between 0 and 1 in steps, where 1 step is minimum
//So if steps is 5 then the line will be cut in 5 sections
int steps = 30;
float t_stepSize = 1f / (float)steps;
float t = 0f;
//+1 becuase wa also have to include the first point
for (int i = 0; i < steps + 1; i++)
{
//Debug.Log(t);
MyVector3 interpolatedPos = BezierCubic.GetPosition(posA, posB, handleA, handleB, t);
positions.Add(interpolatedPos.ToVector3());
tValues.Add(t);
t += t_stepSize;
}
//Different orientation algorithms
List <InterpolationTransform> transforms = InterpolationTransform.GetTransforms_InterpolateBetweenUpVectors(curve, tValues, transA.Up, transB.Up);
//List<InterpolationTransform> transforms = InterpolationTransform.GetTransforms_UpRef(curve, tValues, transA.Up);
//List<InterpolationTransform> transforms = InterpolationTransform.GetTransforms_FrenetNormal(curve, tValues);
//List<InterpolationTransform> transforms = InterpolationTransform.GetTransforms_RotationMinimisingFrame(curve, tValues, transA.Up);
//The curve
DisplayInterpolation.DisplayCurve(positions, useRandomColor: true);
//The start and end values and the handle points
DisplayInterpolation.DisplayHandle(handleA.ToVector3(), posA.ToVector3());
DisplayInterpolation.DisplayHandle(handleB.ToVector3(), posB.ToVector3());
//Display transform
DisplayInterpolation.DisplayOrientations(transforms, 1f);
//Mesh
Mesh extrudedMesh = ExtrudeMeshAlongCurve.GenerateMesh(transforms, meshProfile, 0.25f);
if (extrudedMesh != null && displayMeshFilter != null)
{
displayMeshFilter.sharedMesh = extrudedMesh;
}
}
private void BezierCubicTest_EqualSteps(MyVector3 posA, MyVector3 posB, MyVector3 handleA, MyVector3 handleB)
{
//Create a curve which is the data structure used in the following calculations
BezierCubic bezierCubic = new BezierCubic(posA, posB, handleA, handleB);
//Step 1. Calculate the length of the entire curve
//This is needed so we know for how long we should walk each step
float lengthNaive = InterpolationHelpMethods.GetLength_Naive(bezierCubic, steps: 20, tEnd: 1f);
float lengthExact = InterpolationHelpMethods.GetLength_SimpsonsRule(bezierCubic, tStart: 0f, tEnd: 1f);
//Debug.Log("Naive length: " + lengthNaive + " Exact length: " + lengthExact);
//Step 2. Convert the t's to be percentage along the curve
//Save the accurate t at each position on the curve
List <float> accurateTs = new List <float>();
//The number of sections we want to divide the curve into
int steps = 20;
//Important not to confuse this with the step size we use to iterate t
//This step size is distance in m
float curveLength = lengthNaive;
float curveLength_stepSize = curveLength / (float)steps;
float t_stepSize = 1f / (float)steps;
float t = 0f;
float distanceTravelled = 0f;
for (int i = 0; i < steps + 1; i++)
{
//MyVector3 inaccuratePos = bezierCubic.GetPosition(t);
//Calculate the t needed to get to this distance along the curve
//Method 1
//float accurateT = InterpolationHelpMethods.Find_t_FromDistance_Iterative(bezierCubic, distanceTravelled, length);
//Method 2
float accurateT = InterpolationHelpMethods.Find_t_FromDistance_Lookup(bezierCubic, distanceTravelled, accumulatedDistances: null);
accurateTs.Add(accurateT);
//Debug.Log(accurateT);
//Test that the derivative calculations are working
//float dEst = InterpolationHelpMethods.EstimateDerivative(bezierCubic, t);
//float dAct = bezierCubic.ExactDerivative(t);
//Debug.Log("Estimated derivative: " + dEst + " Actual derivative: " + dAct);
//Debug.Log("Distance " + distanceTravelled);
//Move on to next iteration
distanceTravelled += curveLength_stepSize;
t += t_stepSize;
}
//Step3. Use the new t's to get information from the curve
//The interpolated positions
List <Vector3> actualPositions = new List <Vector3>();
//Save the tangent at each position on the curve
List <Vector3> tangents = new List <Vector3>();
//Save the orientation, which includes the tangent
//List<InterpolationTransform> orientations = new List<InterpolationTransform>();
for (int i = 0; i < accurateTs.Count; i++)
{
float accurateT = accurateTs[i];
//Position on the curve
MyVector3 actualPos = bezierCubic.GetPosition(accurateT);
actualPositions.Add(actualPos.ToVector3());
//Tangent at each position
MyVector3 tangentDir = BezierCubic.GetTangent(posA, posB, handleA, handleB, accurateT);
tangents.Add(tangentDir.ToVector3());
//Orientation, which includes both position and tangent
//InterpolationTransform orientation = InterpolationTransform.GetTransform(bezierCubic, accurateT);
//orientations.Add(orientation);
}
//The orientation at each t position
MyVector3 startUpRef = MyVector3.Up;
List <InterpolationTransform> orientationsFrames = InterpolationTransform.GetTransforms_RotationMinimisingFrame(bezierCubic, accurateTs, startUpRef);
//Display stuff
//The curve which is split into steps
//DisplayInterpolation.DisplayCurve(actualPositions, useRandomColor: true);
DisplayInterpolation.DisplayCurve(actualPositions, Color.gray);
//The start and end values and the handle points
DisplayInterpolation.DisplayHandle(handleA.ToVector3(), posA.ToVector3());
DisplayInterpolation.DisplayHandle(handleB.ToVector3(), posB.ToVector3());
//The actual Bezier cubic for reference
DisplayInterpolation.DisplayCurve(bezierCubic, Color.black);
//Handles.DrawBezier(posA.ToVector3(), posB.ToVector3(), handleA.ToVector3(), handleB.ToVector3(), Color.black, EditorGUIUtility.whiteTexture, 1f);
//The tangents
//DisplayInterpolation.DisplayDirections(actualPositions, tangents, 1f, Color.red);
//The orientation
//DisplayInterpolation.DisplayOrientations(orientations, 1f);
DisplayInterpolation.DisplayOrientations(orientationsFrames, 1f);
//Extrude mesh along the curve
//InterpolationTransform testTrans = orientationsFrames[1];
//MyVector3 pos = testTrans.LocalToWorld(MyVector3.Up * 2f);
//MyVector3 pos = testTrans.LocalToWorld(MyVector3.Right * 2f);
//Gizmos.DrawSphere(pos.ToVector3(), 0.1f);
//DisplayInterpolation.DisplayExtrudedMesh(orientationsFrames, meshProfile);
}
private void BezierQuadraticTest_EqualSteps(MyVector3 posA, MyVector3 posB, MyVector3 handle)
{
//Create a curve which is the data structure used in the following calculations
BezierQuadratic bezierQuadratic = new BezierQuadratic(posA, posB, handle);
//Step 1. Calculate the length of the entire curve
//This is needed to so we know how long we should walk each step
float lengthNaive = InterpolationHelpMethods.GetLength_Naive(bezierQuadratic, steps: 20, tEnd: 1f);
float lengthExact = InterpolationHelpMethods.GetLength_SimpsonsRule(bezierQuadratic, tStart: 0f, tEnd: 1f);
//Debug.Log("Naive length: " + lengthNaive + " Exact length: " + lengthExact);
//Step 2. Convert the t's to be percentage along the curve
//Save the accurate t at each position on the curve
List <float> accurateTs = new List <float>();
int steps = 5;
//Important not to confuse this with the step size we use to iterate t
//This step size is distance in m
float length = lengthNaive;
float lengthStepSize = length / (float)steps;
float stepSize = 1f / (float)steps;
float t = 0f;
float distanceTravelled = 0f;
for (int i = 0; i < steps + 1; i++)
{
//MyVector3 inaccuratePos = bezierCubic.GetInterpolatedValue(t);
//Calculate t to get to this distance
//Method 1
//float accurateT = InterpolationHelpMethods.Find_t_FromDistance_Iterative(bezierQuadratic, distanceTravelled, length);
//Method 2
float accurateT = InterpolationHelpMethods.Find_t_FromDistance_Lookup(bezierQuadratic, distanceTravelled, accumulatedDistances: null);
accurateTs.Add(accurateT);
//Test that the derivative calculations are working
//float dEst = InterpolationHelpMethods.EstimateDerivative(bezierQuadratic, t);
//float dAct = bezierQuadratic.GetDerivative(t);
//Debug.Log("Estimated derivative: " + dEst + " Actual derivative: " + dAct);
//Debug.Log("Distance " + distanceTravelled);
//Move on to next iteration
distanceTravelled += lengthStepSize;
t += stepSize;
}
//Get the data we want from the curve
//Store the interpolated values so we later can display them
List <Vector3> actualPositions = new List <Vector3>();
//
List <Vector3> tangents = new List <Vector3>();
//Orientation, which includes the tangent and position
List <InterpolationTransform> orientations = new List <InterpolationTransform>();
for (int i = 0; i < accurateTs.Count; i++)
{
float accurateT = accurateTs[i];
MyVector3 actualPos = bezierQuadratic.GetPosition(accurateT);
actualPositions.Add(actualPos.ToVector3());
MyVector3 tangent = bezierQuadratic.GetTangent(accurateT);
tangents.Add(tangent.ToVector3());
//Orientation, which includes both position and tangent
InterpolationTransform orientation = InterpolationTransform.GetTransform_UpRef(bezierQuadratic, accurateT, MyVector3.Up);
orientations.Add(orientation);
}
//Display
//Unity doesnt have a built-in method to display an accurate Qudratic bezier, so we have to create our own
//DisplayInterpolation.DisplayBezierQuadratic(bezierQuadratic, Color.black);
DisplayInterpolation.DisplayCurve(bezierQuadratic, Color.black);
//DisplayInterpolation.DisplayCurve(actualPositions, useRandomColor: true);
DisplayInterpolation.DisplayCurve(actualPositions, Color.gray);
//Display the start and end values and the handle points
DisplayInterpolation.DisplayHandle(handle.ToVector3(), posA.ToVector3());
DisplayInterpolation.DisplayHandle(handle.ToVector3(), posB.ToVector3());
//Stuff on the curve
//DisplayInterpolation.DisplayDirections(actualPositions, tangents, 1f, Color.red);
DisplayInterpolation.DisplayOrientations(orientations, 1f);
}
