void Update()
{
//clean memory and skip this frame
if (shouldClean)
{
shouldClean = false;
BezierCurves.CleanMemory();
return;
}
//if there are 3 childrens, calculate quadratic curves
if (transform.childCount == 3)
{
lerpBezierPos = BezierCurves.Quadratic(
transform.GetChild(0).position,
transform.GetChild(1).position,
transform.GetChild(2).position,
t
);
bezierPoints = BezierCurves.QuadraticPointsList(
transform.GetChild(0).position,
transform.GetChild(1).position,
transform.GetChild(2).position,
pointsNumber
);
}
//if there are 4 childrens, calculate cubic curves
else if (transform.childCount == 4)
{
lerpBezierPos = BezierCurves.Cubic(
transform.GetChild(0).position,
transform.GetChild(1).position,
transform.GetChild(2).position,
transform.GetChild(3).position,
t
);
bezierPoints = BezierCurves.CubicPointsList(
transform.GetChild(0).position,
transform.GetChild(1).position,
transform.GetChild(2).position,
transform.GetChild(3).position,
pointsNumber
);
}
//else if the are more than 4, calculate generic curves
else if (transform.childCount > 4)
{
controlPoints = new List <Vector3>();
for (int i = 0; i < transform.childCount; i++)
{
controlPoints.Add(transform.GetChild(i).position);
}
lerpBezierPos = BezierCurves.Generic(controlPoints, t);
bezierPoints = BezierCurves.GenericPointsList(controlPoints, pointsNumber);
}
}
private void OnEnable()
{
creator = target as BezierCurves;
if (creator.curve == null)
{
creator.curve = new Curve();
}
curve = creator.curve;
curve.StartCurve(Vector2.zero);
}
private List <Vector3> GetPoints()
{
List <Vector3> points = new List <Vector3>();
Vector3 destination;
switch (m_pointerType)
{
case (pointerType.Target):
m_pointerDest = CheckRaycastForward(layerMaskHover);
destination = CheckRaycastDownward(m_pointerDest);
switch (m_laserType)
{
case (laserType.Laser):
points = BezierCurves.DetermineLinearCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, 0);
break;
case (laserType.Parabolic):
points = BezierCurves.DetermineQuadraticCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, destination, 0);
break;
}
break;
case (pointerType.Teleport):
m_pointerDest = (m_grabber != null && m_grabber.grabbedObject != null) ? CheckRaycastForward(combinedLayerMask) : CheckRaycastForward(layerMaskLocomotion);
destination = CheckRaycastDownward(m_pointerDest);
switch (m_laserType)
{
case (laserType.Laser):
points = BezierCurves.DetermineLinearCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, 0);
if (m_LineRenderer.enabled)
{
m_locomotionPosition = m_pointerDest;
}
break;
case (laserType.Parabolic):
points = BezierCurves.DetermineQuadraticCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, destination, 0);
if (m_LineRenderer.enabled)
{
m_locomotionPosition = destination;
}
break;
}
break;
case (pointerType.Set_Target):
destination = (m_raycastTarget != null) ? m_raycastTarget.transform.position : m_raycastOrigin.position;
points = BezierCurves.DetermineLinearCurve(m_numPoints, m_raycastOrigin.position, destination, 0);
break;
}
return(points);
}
private void Update()
{
//if (!m_trulyOn || !m_LR.enabled) return; // End early if the line isn't even enabled
if (!m_trulyOn || pointerState == PointerState.Off)
{
return;
}
Vector3 forwardPosition = FindForwardRaycast();
Vector3 bottomPosition = FindBottomRaycast(forwardPosition);
m_positions = new List <Vector3>();
if (pointerState == PointerState.On)
{
m_LR.positionCount = numPositions + 1;
if (m_lineType == LineType.BezierCurve)
{
m_positions = BezierCurves.DetermineQuadraticCurve(numPositions, transform.position, forwardPosition, bottomPosition);
}
else
{
m_positions = BezierCurves.DetermineLinearCurve(numPositions, transform.position, forwardPosition);
}
m_LR.SetPositions(m_positions.ToArray());
m_LR.enabled = true;
if (m_LR.materials.Length == 0)
{
return;
}
Color m = defaultColor;
if (m_lineType == LineType.BezierCurve)
{
if (m_downwardRaycastTarget != null)
{
m = hitColor;
}
}
else
{
if (m_forwardRaycastTarget != null)
{
m = hitColor;
}
}
m_LR.materials[0].SetColor("_Color", m);
}
else
{
m_LR.enabled = false;
}
}
public Vector3 GetWorldPoint(int curveIndex, float t)
{
if (curveIndex < curves.Count)
{
return(transform.TransformPoint(BezierCurves.GetPoint(curves[curveIndex].points, t)));
}
else
{
Debug.LogError("curveIndex out of bounds! (" + curveIndex + ", number of curves in spline = "
+ curves.Count + ". Returning Vector3.zero");
return(Vector3.zero);
}
}
void Start()
{
MeshFilter mf = GetComponent <MeshFilter>();
Mesh mesh = mf.mesh;
Points = new Vector3[]
{
Transform1.position,
Transform2.position,
Transform3.position,
Transform4.position,
};
if (_noPointsYet)
{
Normals = new Vector2[]
{
new Vector2(0, 0),
new Vector2(1, 0),
new Vector2(2, 0),
new Vector2(3, 0),
};
Shape = new Vector2[]
{
new Vector2(0, 0),
new Vector2(0, 1),
new Vector2(0, 2),
new Vector2(0, 3),
};
_noPointsYet = false;
}
_curve = new BezierCurves(Points);
OrientedPoint[] oPoints = _curve.GeneratePath(NumberOfSubdivisions).ToArray();
float[] uv = new float[]
{
0.0f,
1,
0,
1
};
ExtrudeShape extrudeShape = new ExtrudeShape(Shape, Normals, uv);
_curve.Extrude(mesh, extrudeShape, oPoints);
}
public void throwMe(Vector3 loc)
{
gameObject.GetComponent <AudioSource>().Play();
StartCoroutine(spin());
bezier = Instantiate((GameObject)Resources.Load("Prefabs/Giraffe Curve", typeof(GameObject)));
curve = bezier.GetComponent <BezierCurves>();
curve.controlPoints[0].transform.position = gameObject.transform.position;
curve.controlPoints[2].transform.position = loc;
float y = Mathf.Max(curve.controlPoints[0].transform.position.y, curve.controlPoints[2].transform.position.y) + 5;
float x = (curve.controlPoints[0].transform.position.x + curve.controlPoints[2].transform.position.x) / 2;
curve.controlPoints[1].transform.position = new Vector3(x, y, 0);
curve.lockedObject = gameObject;
curve.animateIt(2);
StartCoroutine(finishThrow());
}
/// <summary>
/// Returns a position on the spline at the given percentage.
/// </summary>
public Vector3 GetPosition(float percentage, bool normalized = true)
{
if (normalized)
{
percentage = Reparam(percentage);
}
//evaluate curve:
CurveDetail curveDetail = GetCurve(percentage);
//avoid an error in editor usage where this index can be -1:
if (curveDetail.currentCurve < 0)
{
return(Vector3.zero);
}
SplineAnchor startAnchor = Anchors[curveDetail.currentCurve];
SplineAnchor endAnchor = Anchors[curveDetail.currentCurve + 1];
return(BezierCurves.GetPoint(startAnchor.Anchor.position, endAnchor.Anchor.position, startAnchor.OutTangent.position, endAnchor.InTangent.position, curveDetail.currentCurvePercentage, true, 100));
}
private void OnValidate()
{
if (points == null || points.Count < 3)
{
return;
}
nodes.Clear();
switch (type)
{
case CurvesTpye.Bezier:
nodes.AddRange(BezierCurves.FetchCurves(ratio, points.ToArray()));
break;
case CurvesTpye.Spline:
nodes.AddRange(SplineCurves.FetchCurves(ratio, points.ToArray()));
break;
case CurvesTpye.Spline2:
nodes.AddRange(spline.FetchCurves(ratio, points.ToArray()));
break;
}
}
public Vector3 GetDir(int curveIndex, float t)
{
return(BezierCurves.GetFirstDeriv(curves[curveIndex].points, t));
}
public Vector3 GetDir(float t)
{
return(BezierCurves.GetFirstDeriv(points, t));
}
public Vector3 GetWorldPoint(float t)
{
return(transform.TransformPoint(BezierCurves.GetPoint(points, t)));
}
public Vector3 GetPoint(float t)
{
return(BezierCurves.GetPoint(points, t));
}
/// In this function, we 1) perform the necessary raycasts to get our pointer's target, and 2) generate the necessary points to generate the pointer's line renderers
private List <Vector3> GetPoints()
{
List <Vector3> points = new List <Vector3>();
Vector3 destination;
// The end destination of our pointer and the lines the line renderer will render with is dependent on the type of pointer we're using.
switch (m_pointerType)
{
case (pointerType.Target):
// If we're a targeting/selection pointer, we default to simply raycasting forward, then raycasting downward.
m_pointerDest = CheckRaycastForward(layerMaskHover);
destination = CheckRaycastDownward(m_pointerDest);
// Based on our laser type, the line renderer will generate points to create either a curve or straight line.
switch (m_laserType)
{
case (laserType.Laser):
points = BezierCurves.DetermineLinearCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, 0);
break;
case (laserType.Parabolic):
points = BezierCurves.DetermineQuadraticCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, destination, 0);
break;
}
break;
case (pointerType.Teleport):
// Our pointer will only get a destination based on if we're grabbing anything in the hand. This is because an object being held in the hand can block the pointer, which is inconducive if we want to teleport elsewhere.
m_pointerDest = (m_grabber != null && m_grabber.grabbedObject != null) ? CheckRaycastForward(combinedLayerMask) : CheckRaycastForward(layerMaskLocomotion);
destination = CheckRaycastDownward(m_pointerDest);
// Based on our laser type, the line renderer will generate points to create either a curve or straight line.
switch (m_laserType)
{
case (laserType.Laser):
points = BezierCurves.DetermineLinearCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, 0);
if (m_LineRenderer.enabled)
{
m_locomotionPosition = m_pointerDest;
}
break;
case (laserType.Parabolic):
points = BezierCurves.DetermineQuadraticCurve(m_numPoints, m_raycastOrigin.position, m_pointerDest, destination, 0);
if (m_LineRenderer.enabled)
{
m_locomotionPosition = destination;
}
break;
}
break;
case (pointerType.Set_Target):
// In this case, we have a target pre-selected already. Our pointer destination is merely either that target's position, or nothing (aka the origin point, which will not generate a line)
destination = (m_raycastTarget != null) ? m_raycastTarget.transform.position : m_raycastOrigin.position;
// The line renderer's points, in this case, is always going to be a linear line.
points = BezierCurves.DetermineLinearCurve(m_numPoints, m_raycastOrigin.position, destination, 0);
break;
}
// We return the points we've generated.
return(points);
}
