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);
}
}
