void Move()
{
var curveX = new CatmullRomCurve(points.Select(vec => vec.x).ToArray());
var curveY = new CatmullRomCurve(points.Select(vec => vec.y).ToArray());
StartCoroutine(Move(curveX, curveY));
}
List <TreeSegment> BuildSegments(TreeData data, float fromRadius, float toRadius, Vector3 normal, Vector3 binormal)
{
var segments = new List <TreeSegment>();
var points = new List <Vector3>();
var length = (to - from).magnitude;
var bend = length * (normal * data.RandomBendDegree + binormal * data.RandomBendDegree);
points.Add(from);
points.Add(Vector3.Lerp(from, to, 0.25f) + bend);
points.Add(Vector3.Lerp(from, to, 0.75f) + bend);
points.Add(to);
var curve = new CatmullRomCurve(points);
var frames = curve.ComputeFrenetFrames(data.heightSegments, normal, binormal, false);
for (int i = 0, n = frames.Count; i < n; i++)
{
var u = 1f * i / (n - 1);
var radius = Mathf.Lerp(fromRadius, toRadius, u);
var position = curve.GetPointAt(u);
var segment = new TreeSegment(frames[i], position, radius);
segments.Add(segment);
}
return(segments);
}
/// <summary>
/// Calculate the catmull-rom segments. Also estimates the curve's length.
/// </summary>
/// <param name="N">The number sample points used to estimate each segment's length.</param>
public override void CalculateSegments(int N = 100)
{
lastSampleSize = N;
segmentCount = (points.Length - 1);
lengths = new float[segmentCount];
segments = new CatmullRomCurve[segmentCount];
startHandle = 2 * points[0] - points[1];
endHandle = 2 * points[segmentCount] - points[segmentCount - 1];
Length = 0;
for (var i = 0; i < segmentCount; i++)
{
segments[i] = new CatmullRomCurve(
i == 0 ? startHandle : points[i - 1],
points[i],
points[i + 1],
(i + 1) == segmentCount ? endHandle : points[i + 2],
Alpha
);
Length += segments[i].EstimateLength(N);
lengths[i] = Length;
}
}
void OnEnable()
{
style.fontStyle = FontStyle.Bold;
style.normal.textColor = Color.white;
_target = (Curve)target;
_curve = _target.GetWorldSpaceCurve();
Undo.undoRedoPerformed += OnUndo;
}
private void BuildEye(float openAmount)
{
var count = 32;
var left = new Vector2(-100, 0);
var right = -left;
var basePull = new Vector2(0, openAmount);
var curves = new CatmullRomCurve[6];
// top curve
var topPull = basePull - lookOffset * 5 * openAmount;
curves[0] = CatmullRomCurve.Create(count,
topPull,
left,
right,
topPull);
// bottom curve
var bottomPull = -basePull - lookOffset * 2 * openAmount;
curves[1] = CatmullRomCurve.Create(count,
bottomPull,
left,
right,
bottomPull);
CatmullRomCurve BuildIrisSegment(float progress, Vector2 pull)
{
var start = curves[0].GetPointAlong(progress);
var end = curves[1].GetPointAlong(progress);
return(CatmullRomCurve.Create(count,
pull,
start,
end,
pull));
}
var progressForIris = 0.4f * (this.aimTimer / 20 + 1);
var pullFactor = (1 + this.aimTimer);
curves[2] = BuildIrisSegment(Math.Clamp(progressForIris + lookOffset.X, 0.2f, 0.8f), right * pullFactor);
curves[3] = BuildIrisSegment(Math.Clamp(1 - progressForIris + lookOffset.X, 0.2f, 0.8f), left * pullFactor);
this.eyeCurves = curves;
}
IEnumerator Move(CatmullRomCurve curveX, CatmullRomCurve curveY)
{
float time = 0;
transform.position = new Vector3(curveX.Calc(0).position, curveY.Calc(0).position, 0);
transform.rotation = Quaternion.LookRotation(
new Vector3(curveX.Calc(0).velocity, curveY.Calc(0).velocity, 0)
);
yield return(null);
while ((time += Time.deltaTime) <= 10)
{
transform.position = new Vector3(curveX.Calc(time / 10).position, curveY.Calc(time / 10).position, 0);
transform.rotation = Quaternion.LookRotation(
new Vector3(curveX.Calc(time / 10).velocity, curveY.Calc(time / 10).velocity, 0)
);
yield return(null);
}
}
private void GenerateTube()
{
var controls = new List <Vector3>()
{
new Vector3(0, 0, 0),
new Vector3(0, 0, grabDistance)
};
var curve = new CatmullRomCurve(controls);
// Build tubular mesh with Curve
int tubularSegments = 40;
float radius = 0.001f;
int radialSegments = 20;
bool closed = false; // closed curve or not
var mesh = Tubular.Tubular.Build(curve, tubularSegments, radius, radialSegments, closed);
// visualize mesh
var filter = GetComponent <MeshFilter>();
filter.sharedMesh = mesh;
}
public override void OnInspectorGUI()
{
_target.pathColor = EditorGUILayout.ColorField("Path Color", _target.pathColor);
_target.isLocal = EditorGUILayout.Toggle("Is Local", _target.isLocal);
_target.smoothAmount = EditorGUILayout.IntSlider("Smooth Amount", _target.smoothAmount, 1, 20);
int newCount = EditorGUILayout.IntField("Node Count", _target.nodes.Count);
//add node?
if (newCount > _target.nodes.Count)
{
for (int i = 0; i < newCount - _target.nodes.Count; i++)
{
_target.nodes.Add(Vector3.zero);
}
}
//remove node?
if (newCount < _target.nodes.Count)
{
if (EditorUtility.DisplayDialog("Remove path node?", "Shortening the node list will permanently destroy parts of your path. This operation cannot be undone.", "OK", "Cancel"))
{
int removeCount = _target.nodes.Count - newCount;
_target.nodes.RemoveRange(_target.nodes.Count - removeCount, removeCount);
}
}
//node display:
for (int i = 0; i < _target.nodes.Count; i++)
{
_target.nodes[i] = EditorGUILayout.Vector3Field("Node " + (i + 1), _target.nodes[i]);
}
if (GUI.changed)
{
_curve = _target.GetWorldSpaceCurve();
EditorUtility.SetDirty(_target);
}
}
public override void Draw(SpriteBatch spriteBatch)
{
var curve = CatmullRomCurve.Create(25,
transform.ChildAt(0).transform.Position,
transform.ChildAt(1).transform.Position,
transform.ChildAt(2).transform.Position,
transform.ChildAt(3).transform.Position);
for (int i = 0; i < curve.Count - 1; i++)
{
if (this.time > i && this.time < i + 1)
{
spriteBatch.DrawCircle(new CircleF(curve.points[i], 5f), 3, Color.White, 1f, transform.Depth);
}
}
if (time > curve.Count)
{
time = 0;
}
curve.Draw(spriteBatch, Vector2.Zero, transform.Depth, 1f);
}
public void SetCurve(CatmullRomCurve pCurve)
{
_curve = pCurve;
}
public void SetCurve(CatmullRomCurve pCurve, float pProgress)
{
_curve = pCurve;
_progress = pProgress;
transform.localPosition = _curve.GetPointOnPath(pProgress);
}
public CatmullRomCurveVector3(Vector3[] points)
{
curveX = new CatmullRomCurve(points.Select(point => point.x).ToArray());
curveY = new CatmullRomCurve(points.Select(point => point.y).ToArray());
curveZ = new CatmullRomCurve(points.Select(point => point.z).ToArray());
}
public void UpdateToWorldSpaceCurve(CatmullRomCurve pCurveToUpdate)
{
pCurveToUpdate.SetPassThroughPoints(GetWorldPassThroughPoints());
}
public void UpdateToLocalSpaceCurve(Transform pTransform, CatmullRomCurve pCurveToUpdate)
{
pCurveToUpdate.SetPassThroughPoints(GetLocalPassThroughPoints(pTransform));
}
void OnSceneGUI()
{
if (_target.enabled)
{
if (_target.nodes.Count > 0)
{
bool dirty = false;
//allow path adjustment undo:
Undo.RecordObject(_target, "Adjust Curve");
//node handle display:
Vector3 newWorldPosition;
Vector3 oldWorldPosition;
for (int i = 0; i < _target.nodes.Count; i++)
{
if (_target.isLocal)
{
oldWorldPosition = _target.transform.TransformPoint(_target.nodes[i]);
}
else
{
oldWorldPosition = _target.nodes[i];
}
if (i == 0)
{
Handles.Label(oldWorldPosition, "Begin", style);
}
if (i == _target.nodes.Count - 1)
{
Handles.Label(oldWorldPosition, "End", style);
}
newWorldPosition = Handles.PositionHandle(oldWorldPosition, Quaternion.identity);
if (newWorldPosition != oldWorldPosition)
{
dirty = true;
}
if (_target.isLocal)
{
_target.nodes[i] = _target.transform.InverseTransformPoint(newWorldPosition);
}
else
{
_target.nodes[i] = newWorldPosition;
}
}
if (dirty)
{
_curve = _target.GetWorldSpaceCurve();
}
Vector3 prevPt = _curve.GetPointOnPath(0);
Handles.color = _target.pathColor;
int numLines = _target.nodes.Count * _target.smoothAmount;
for (int i = 1; i <= numLines; i++)
{
float pm = (float)i / numLines;
Vector3 currPt = _curve.GetPointOnPath(pm);
Handles.DrawLine(currPt, prevPt);
prevPt = currPt;
}
}
}
}
void OnUndo()
{
_curve = _target.GetWorldSpaceCurve();
}
