public OrientedPoint GetWallPos(int segPos, float t, List <Vector3> wallPoints) { Vector3 p0; Vector3 p1; Vector3 m0; Vector3 m1; p0 = wallPoints[segPos]; p1 = wallPoints[segPos + 1]; if (segPos == 0) { m0 = p1 - p0; } else { m0 = 0.5f * (p1 - wallPoints[segPos - 1]); } if (segPos < Points.Count - 2) { m1 = 0.5f * (wallPoints[(segPos + 2) % wallPoints.Count] - p0); } else { m1 = p1 - p0; } return(CatmullRom.GetOrientedPoint(p0, p1, m0, m1, t)); }
/// <summary> Fills the ref-argument VectorHand with interpolated data /// between the 4 other VectorHands, by t (unclamped), and return true. /// If either a, b, c or d is null, the ref-argument VectorHand is also set to /// null, and the method returns false. /// An exception is thrown if the interpolation arguments a and b don't /// have the same chirality. /// </summary> public bool FillSplined(VectorHand a, VectorHand b, VectorHand c, VectorHand d, float t) { if (a == null || b == null || c == null || d == null) { return(false); } if (b.isLeft != c.isLeft) { throw new System.Exception("VectorHands must be interpolated with the " + "same chirality."); } isLeft = a.isLeft; palmPos = CatmullRom.ToCHS( a.palmPos, b.palmPos, c.palmPos, d.palmPos, false).PositionAt(t); palmRot = Quaternion.SlerpUnclamped(b.palmRot, c.palmRot, t); //Quaternion splines are not as robust //CatmullRom.ToQuaternionCHS( // a.palmRot, b.palmRot, c.palmRot, d.palmRot, false).RotationAt(t); for (int i = 0; i < jointPositions.Length; i++) { jointPositions[i] = CatmullRom.ToCHS( a.jointPositions[i], b.jointPositions[i], c.jointPositions[i], d.jointPositions[i], false).PositionAt(t); } return(true); }
public OrientedPoint[] GetWallPath(List <Vector3> pts) { OrientedPoint[] path = new OrientedPoint[0]; for (int i = 0; i < pts.Count - 1; i++) { Vector3 p0, p1, m0, m1; p0 = pts[i]; p1 = pts[i + 1]; // m0 if (i == 0) { m0 = p1 - p0; } else { m0 = 0.5f * (p1 - pts[i - 1]); } // m1 if (i < pts.Count - 2) { m1 = 0.5f * (pts[(i + 2) % Points.Count] - p0); } else { m1 = p1 - p0; } OrientedPoint[] pathSegment = CatmullRom.GeneratePath(p0, p1, m0, m1, CurveResolution).ToArray <OrientedPoint>(); path = path.Concat(pathSegment).ToArray <OrientedPoint>(); } return(path); }
// Use this for initialization void Start() { catmullRom = GetComponent <CatmullRom>(); //controlPoint = GameObject.FindGameObjectsWithTag("ControlPoint"); MakeMesh(); }
// ------------------ void Start() { //trail = transform.GetComponentInChildren<TrailRenderer>(); controlPoints = new Transform[pointHolder.childCount]; for (int i = 0; i < controlPoints.Length; i++) { controlPoints[i] = pointHolder.GetChild(i); } if (showControlPoints) { for (int i = 0; i < controlPoints.Length; i++) { controlPoints[i].GetChild(0).localScale = new Vector3(.05f, .05f, .05f); } } else { for (int i = 0; i < controlPoints.Length; i++) { controlPoints[i].GetChild(0).localScale = new Vector3(.0f, .0f, .0f); } } if (spline == null && controlPoints.Length > 2) { spline = new CatmullRom(controlPoints, resolution); } }
public override void PaintTrajectory() { Vector3[] controlPoints = new Vector3[pointList.Count]; for (int i = 0; controlPoints.Length > i; i++) { controlPoints[i] = pointList[i].TransformVector.GetVector3(); } try { if (spline != null) { spline.Update(controlPoints); spline.Update(resolution, closedLoop); } else { spline = new CatmullRom(controlPoints, resolution, closedLoop); } splineVectors = spline.GetPoints(); trajectory.gameObject.GetComponent <LineRenderer>().positionCount = splineVectors.Length; trajectory.gameObject.GetComponent <LineRenderer>().SetPositions(splineVectors); } catch { print("Exeption PaintTrajectory()"); } }
/** *<summary> * Calculates an interpolation value and returns the interpolated point along a Catmull-Rom spline defined by four points *</summary> */ Vector3 findNextPlaceOnPath() { interpolator += Time.deltaTime * heuristicIteratorIncrement; //Ensures a that interpolating b/w two points starts at 0 if (didPathingResetLastFrame) { interpolator = 0; didPathingResetLastFrame = false; } //Ensures a that interpolating b/w two points ends at 1 if (interpolator >= 1) { interpolator = 1; } //Calculate the position along the spline Vector2 nextPos = CatmullRom.returnCatmullRom(interpolator, pathKeyPoints[index0], pathKeyPoints[index1], pathKeyPoints[index2], pathKeyPoints[index3]); //Update the pathing indices when interpolator finishes a 0-1 cycle if (interpolator >= 1) { incrementPathingIndex(); } return(new Vector3(nextPos.x, yOffset, nextPos.y)); }
void Start() { if (spline == null) { spline = new CatmullRom(controlPoints, resolution, closedLoop); } }
public bool FillSplined(Pose a, Pose b, Pose c, Pose d, float t) { position = CatmullRom.ToCHS(a.position, b.position, c.position, d.position, centripetal: false).PositionAt(t); rotation = Quaternion.SlerpUnclamped(b.rotation, c.rotation, t); return(true); }
public static void SetSpawnTransform(Transform car, float dist, int height) { int point = 0; dist = Mathf.Repeat(dist, Instance.TotalLength); while (Instance._distances[point] < dist) { ++point; } if (dist == 0) { ++point; } Instance.calculatePandM(--point); float t = Mathf.InverseLerp(Instance._distances[point], Instance._distances[point + 1], dist); Vector3 tangent; float percentThrough = t; Vector3 position = CatmullRom.Interpolate(Instance.p0, Instance.p1, Instance.m0, Instance.m1, t, out tangent); Vector3 normal = Vector3.Lerp(Instance._points[point].Up, Instance._points[(point + 1) % Instance._points.Capacity].Up, percentThrough); float center = Mathf.Lerp(Instance._points[point].Centre, Instance._points[(point + 1) % Instance._points.Capacity].Centre, percentThrough); float width = Mathf.Lerp(Instance._points[point].Width, Instance._points[(point + 1) % Instance._points.Capacity].Width, percentThrough); car.position = position + Vector3.Cross(tangent, normal).normalized *width *center + height * Vector3.up; car.up = normal; car.forward = tangent; }
// Use this for initialization void Start() { rom = this.gameObject.GetComponent <CatmullRom> (); targetPos = this.transform.position; pathfind = new AStar(this.transform.position.y); PlayerList.AddToPlayers(this); }
public static void GetOffsetFromPathSegment(Path path, float curvePos, out Vector3 up, out Vector3 left) { quaternion direction = CatmullRom.DirectionToRotationWorldUp(path.GetTangent(curvePos)); up = math.mul(direction, new float3(0, 1, 0)) * (path.height / 2.0f); left = math.mul(direction, new float3(1, 0, 0)) * (path.width / 2.0f); }
public static List <Vector3> PathSmoothing(List <Vector3> path, int level) { //Interpolation with the Catmull-Rom spline CatmullRom catmullRomInstance = new CatmullRom(path, SpaceGraph.GetLevelSideLength(level)); return(catmullRomInstance.GetSplineCall()); }
/** * Method to get position based on spline segment (Points[segPos]-Points[segPos+1]) and * t value. **/ public OrientedPoint GetPos(int segPos, float t) { Vector3 p0; Vector3 p1; Vector3 m0; Vector3 m1; p0 = Points[segPos].transform.position; p1 = Points[segPos + 1].transform.position; if (segPos == 0) { m0 = p1 - p0; } else { m0 = 0.5f * (p1 - Points[segPos - 1].transform.position); } if (segPos < Points.Count - 2) { m1 = 0.5f * (Points[(segPos + 2) % Points.Count].transform.position - p0); } else { m1 = p1 - p0; } return(CatmullRom.GetOrientedPoint(p0, p1, m0, m1, t)); }
void Update() { if (spline != null) { spline.Update(controlPoints); spline.Update(resolution); spline.DrawSpline(Color.white); if (drawNormal) { spline.DrawNormals(normalExtrusion, Color.red); } if (drawTangent) { spline.DrawTangents(tangentExtrusion, Color.cyan); } } else { spline = new CatmullRom(controlPoints, resolution); } if (globalTime <= 1) { globalTime += Time.deltaTime * UpdateProgress(); } else { globalTime = .001f; } UpdatePosition(globalTime); }
public List <Vector3> MakeSpline(List <Vector3> controlPoints, bool closedLoop) { ControlPoints = controlPoints; List <Vector3> points = new List <Vector3>(); //All points of the spline int closedAdjustment = closedLoop ? 0 : 1; // First for loop goes through each individual control point and connects it to the next, so 0-1, 1-2, 2-3 and so on for (int i = 0; i < controlPoints.Count - closedAdjustment; i++) { //The 4 points on my catmull spline Vector3 point1, point2, point3, point4; //The two points to interpolate between point2 = controlPoints[i]; point3 = (closedLoop == true && i == controlPoints.Count - 1) ? controlPoints[0] : controlPoints[i + 1]; //The first handle/anchor thingy if (i == 0 && !closedLoop) { //If its the first point, make the point up point1 = point3 - point2; } else { //This will loop back round point1 = controlPoints[((i - 1) + controlPoints.Count) % controlPoints.Count]; } //The second handle/anchor thingy if (i >= controlPoints.Count - 2 && !closedLoop) { //If we're on the last point, make it up point4 = point3 - point2; } else { point4 = controlPoints[(i + 2) % controlPoints.Count]; } float pointStep = 1.0f / CurveResolution; if (i == controlPoints.Count - 1 && closedLoop) { pointStep = 1.0f / (CurveResolution - 1); } // Second loop actually creates the spline for this particular segment for (int j = 0; j < CurveResolution; j++) { float t = j * pointStep; Vector3 position = CatmullRom.GetCatmullRomPosition(point1, point2, point3, point4, t, out var tangent, alpha); points.Add(position); } } return(SplitCurveEvenly(points)); }
private float3 GetTangent(int index, float fractionAlongPath) { float3 p0, p1, p2, p3; GetSplineSectionInternal(index, out p0, out p1, out p2, out p3); return(CatmullRom.GetTangent(p0, p1, p2, p3, fractionAlongPath)); }
public float ComputeArcLength(int index, int subdivs) { float3 p0, p1, p2, p3; GetSplineSectionInternal(index, out p0, out p1, out p2, out p3); return(CatmullRom.ComputeArcLength(p0, p1, p2, p3, subdivs)); }
private float3 GetWorldPosition(int index, float fractionAlongPath) { float3 p0, p1, p2, p3; GetSplineSectionInternal(index, out p0, out p1, out p2, out p3); return(CatmullRom.GetPosition(p0, p1, p2, p3, fractionAlongPath) + new float3(transform.position)); }
// ------------------ void Start() { if (spline == null) { spline = new CatmullRom(controlPoints, resolution); } UpdateLinePoints(); }
private void ConstructMesh() { trackMesh.Clear(); List <Vector2> texCoords = new List <Vector2> (); List <int> indices = new List <int> (); meshCoords = new List <Vector3> (); CatmullRom CRS = new CatmullRom(diffCoords); int diffCoordsSize = CRS.pts.Count; float step = 1.0f / (diffCoordsSize * smoothness); float iterator = 0.0f; List <Vector3> outerCoords = new List <Vector3> (); List <Vector3> innerCoords = new List <Vector3> (); for (int i = 0; i < diffCoordsSize * smoothness; i++) { outerCoords.Add(CRS.DisplaceBy(trackWidth, iterator, step)); innerCoords.Add(CRS.Interpolate(iterator)); iterator += step; } WeldOverlappingSections(outerCoords, innerCoords); for (int i = 0; i < diffCoordsSize * smoothness; i++) { meshCoords.Add(innerCoords [i]); meshCoords.Add(outerCoords [i]); meshCoords.Add(innerCoords [i]); meshCoords.Add(outerCoords [i]); texCoords.Add(new Vector2(0, 0)); texCoords.Add(new Vector2(1, 0)); texCoords.Add(new Vector2(0, 1)); texCoords.Add(new Vector2(1, 1)); } int meshCount = meshCoords.Count; for (int i = 0; i < meshCount; i++) { // Tri 1 indices.Add(i % meshCount); indices.Add((i + 2) % meshCount); indices.Add((i + 1) % meshCount); // Tri 2 indices.Add((i + 2) % meshCount); indices.Add((i + 3) % meshCount); indices.Add((i + 1) % meshCount); } trackMesh.vertices = meshCoords.ToArray(); trackMesh.uv = texCoords.ToArray(); trackMesh.RecalculateNormals(); trackMesh.Optimize(); trackMesh.SetIndices(indices.ToArray(), MeshTopology.LineStrip, 0); }
// ------------------ void Start() { if (spline == null) { spline = new CatmullRom(controlPoints, resolution); } lastPosition = transform.position; }
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); }
// Start is called before the first frame update void Start() { _points = new Vector3[_gameObjects.Length]; for (int i = 0; i < _gameObjects.Length; i++) { _points[i] = _gameObjects[i].transform.position; } _catmull = new CatmullRom(_points, resolution, false); Debug.Log(_catmull.GetPoints().Length); }
public void CreatePath(Vector3 point) { for (var i = 0; i < 4; ++i) { var go = Instantiate(_controlPointPrefab, point, Quaternion.identity); go.transform.SetParent(transform); _controlPoints.Add(go.transform); } _catmullRom = new CatmullRom(_controlPoints.ToArray(), _resolution, false); }
private void Awake() { if (instance != null) { Destroy(gameObject); Debug.LogError("multiple instances of catmull"); } instance = this; lr = GetComponent <LineRenderer>(); meshCollider = colliderChild.GetComponent <MeshCollider>(); mesh = new Mesh(); }
void Start() { cave = FindObjectOfType <CaveSystem>(); cave.Initialize(transform); cave.OnReset(); frame = new Frame(transform); spline = new CatmullRom(splineResolution); controlPoints = new Queue <Vector3>(controlPointCount); controlPoints.Enqueue(frame.origin); maxIndex = splineResolution * 3 - 1; }
public void Generate() { if (lWallPoints.Count == 0 || rWallPoints.Count == 0) { GenerateWallPoints(); } int startGen = GameManager.segmentPos - 2; int endGen = GameManager.segmentPos + 8; if (startGen < 0) { startGen = 0; } if (endGen > Points.Count) { endGen = Points.Count; } if (endGen < 0) { endGen = 0; } List <Vector3> pointsforLeftMesh = lWallPoints.GetRange(startGen, endGen - startGen); List <Vector3> pointsforRightMesh = rWallPoints.GetRange(startGen, endGen - startGen); MeshFilter meshFilter = walls[0].GetComponent <MeshFilter>(); MeshCollider meshCollider = walls[0].GetComponent <MeshCollider>(); if (meshFilter.sharedMesh == null) { meshFilter.sharedMesh = new Mesh(); } Mesh mesh = new Mesh(); CatmullRom.Extrude(mesh, shape, GetWallPath(pointsforLeftMesh)); meshFilter.sharedMesh = mesh; meshCollider.sharedMesh = mesh; meshFilter = walls[1].GetComponent <MeshFilter>(); meshCollider = walls[1].GetComponent <MeshCollider>(); if (meshFilter.sharedMesh == null) { meshFilter.sharedMesh = new Mesh(); } mesh = new Mesh(); CatmullRom.Extrude(mesh, shape, GetWallPath(pointsforRightMesh)); meshFilter.sharedMesh = mesh; meshCollider.sharedMesh = mesh; }
public void Execute(Entity entity, int index, ref Spawner thisSpawner) { if (thisSpawner.delaySpawn > 0) { thisSpawner.delaySpawn--; } else { RoadSection rs = RoadSections[thisSpawner.RoadIndex]; Interlocked.Increment(ref vehicleUID); float backOfVehiclePos = thisSpawner.Time - rs.vehicleHalfLen; float frontOfVehiclePos = thisSpawner.Time + rs.vehicleHalfLen; int occupationIndexStart = math.max(0, (int)(math.floor(backOfVehiclePos * rs.occupationLimit))); int occupationIndexEnd = math.min(rs.occupationLimit - 1, (int)(math.floor(frontOfVehiclePos * rs.occupationLimit))); if (!Occupied(occupationIndexStart, occupationIndexEnd, thisSpawner.RoadIndex, thisSpawner.LaneIndex)) { int vehiclePoolIndex = GetSpawnVehicleIndex(ref thisSpawner.random, thisSpawner.poolSpawn); float speedMult = VehiclePool[vehiclePoolIndex].VehicleSpeed; float speedRangeSelected = thisSpawner.random.NextFloat(0.0f, 1.0f); float initialSpeed = 0.0f; var vehicleEntity = EntityCommandBuffer.Instantiate(index, VehiclePool[vehiclePoolIndex].VehiclePrefab); EntityCommandBuffer.SetComponent(index, vehicleEntity, new VehiclePathing { vehicleId = vehicleUID, RoadIndex = thisSpawner.RoadIndex, LaneIndex = (byte)thisSpawner.LaneIndex, WantedLaneIndex = (byte)thisSpawner.LaneIndex, speed = initialSpeed, speedRangeSelected = speedRangeSelected, speedMult = speedMult, targetSpeed = initialSpeed, curvePos = thisSpawner.Time, random = new Unity.Mathematics.Random(thisSpawner.random.NextUInt(1, uint.MaxValue)) }); var heading = CatmullRom.GetTangent(rs.p0, rs.p1, rs.p2, rs.p3, 0.0f); EntityCommandBuffer.SetComponent(index, vehicleEntity, new VehicleTargetPosition { IdealPosition = thisSpawner.Position }); EntityCommandBuffer.SetComponent(index, vehicleEntity, new VehiclePhysicsState { Position = thisSpawner.Position, Heading = heading, SpeedMult = speedMult }); } var speedInverse = 1.0f / thisSpawner.minSpeed; thisSpawner.delaySpawn = (int)Constants.VehicleLength + thisSpawner.random.NextInt((int)(speedInverse * 10.0f), (int)(speedInverse * 120.0f)); } }
public void calculateMovementCurve(Connector triggeredFrom, bool pressed) { // calculate curve triggeredFrom.positionCurve.Clear(); if (pressed && triggeredFrom.pressedAction == ConnectorActionEnum.JUMP_TO_RAIL) { triggeredFrom.positionCurve.Add(playerObject.transform.position); Rail destination = triggeredFrom.pressedToRail; Vector3 destinationPos = Vector3.Lerp(destination.transform.position, destination.endPosition, (triggeredFrom.endTime - destination.startTime) / (destination.endTime - destination.startTime)); if (triggeredFrom.additionalPressedPositionCurve.Count > 0) { foreach (Vector3 additionalPos in triggeredFrom.additionalPressedPositionCurve) { triggeredFrom.positionCurve.Add(additionalPos); } } else { if (destinationPos.y >= playerObject.transform.position.y) { triggeredFrom.positionCurve.Add(new Vector3(destinationPos.x - ((destinationPos.x - playerObject.transform.position.x) / 2.25f), destinationPos.y + 0.5f)); } else { triggeredFrom.positionCurve.Add(new Vector3(destinationPos.x - ((destinationPos.x - playerObject.transform.position.x) / 3), playerObject.transform.position.y + 0.25f)); } } triggeredFrom.positionCurve.Add(destinationPos); spline = new CatmullRom(triggeredFrom.positionCurve.ToArray(), 16, false); } else if (!pressed && triggeredFrom.unpressedAction == ConnectorActionEnum.JUMP_TO_RAIL) { triggeredFrom.positionCurve.Add(playerObject.transform.position); Rail destination = triggeredFrom.unpressedToRail; float endTime = triggeredFrom.unpressedEndTime > 0 ? triggeredFrom.unpressedEndTime : triggeredFrom.endTime; Vector3 destinationPos = Vector3.Lerp(destination.transform.position, destination.endPosition, (endTime - destination.startTime) / (destination.endTime - destination.startTime)); if (triggeredFrom.additionalUnpressedPositionCurve.Count > 0) { foreach (Vector3 additionalPos in triggeredFrom.additionalUnpressedPositionCurve) { triggeredFrom.positionCurve.Add(additionalPos); } } else { triggeredFrom.positionCurve.Add(new Vector3(destinationPos.x - ((destinationPos.x - playerObject.transform.position.x) / 3), playerObject.transform.position.y - ((playerObject.transform.position.y - destinationPos.y) / 6))); } triggeredFrom.positionCurve.Add(destinationPos); spline = new CatmullRom(triggeredFrom.positionCurve.ToArray(), 16, false); } }