void AddDashPoint(Vector3 position, Vector3 normal)
{
//Prevent double points
//foreach (DashPoint point in dashPoints)
//{
// if (Vector3.Distance(point.position, position) < 0.5f && normal == point.normal)
// return;
//}
DashPoint dashPoint = new DashPoint(position, normal);
FocusParticles.Instance.MoveToPoint(dashPoint);
dashPoints.Add(dashPoint);
lineRenderer.positionCount = dashPoints.Count + 1;
lineRenderer.SetPosition(0, transform.position);
for (int i = 1; i < lineRenderer.positionCount; i++)
{
lineRenderer.SetPosition(i, dashPoints[i - 1].position);
}
lineRenderer.widthCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(.1f, .5f), new Keyframe(.9f, .5f), new Keyframe(1, 0));
//lineRenderer.colorGradient = Color.Lerp(Color.white, Color.black, dashPoints.Count / 24);
//float alpha = 1.0f;
//lineRenderer.colorGradient.SetKeys(//TODO: figure out amount of dashpoints
// new GradientColorKey[] { new GradientColorKey(Color.green, 0.0f), new GradientColorKey(Color.Lerp(Color.green, Color.red, dashPoints.Count / 8), 1.0f) },
// new GradientAlphaKey[] { new GradientAlphaKey(alpha, 0.0f), new GradientAlphaKey(alpha, 1.0f) }
// );
}
IEnumerator MoveRoutine(DashPoint dashPoint)
{
Vector3 fromPosition = transform.position;
Vector3 fromNormal = transform.up;
for (float t = 0; t < transitionDuration; t += Time.unscaledDeltaTime)
{
transform.position = Vector3.Lerp(fromPosition, dashPoint.position + dashPoint.normal * 0.5f, t / transitionDuration);
//transform.up = Vector3.Lerp(fromNormal, dashPoint.normal, t / transitionDuration);
yield return(new WaitForFixedUpdate());
}
}
/// <summary>
/// Triangulates a road surface bordered on at least one side by dashed road markings
/// </summary>
/// <param name="index"></param>
void LoftWithDashedRoadMarking(int index)
{
var surfaceEntity = SurfaceEntities[index];
var surface = Surfaces[surfaceEntity];
var profile = Profiles[surface.Profile];
var lateralProfileBuffer = ProfileSampleBuffers[surface.Profile]
.Reinterpret <float2>().AsNativeArray()
.GetSubArray(surface.StartIndex, surface.SampleCount);
var leftLateralPoint = new float3(lateralProfileBuffer[0].x, 0f, 0f);
var rightLateralPoint = new float3(lateralProfileBuffer[lateralProfileBuffer.Length - 1].x, 0f, 0f);
var loftPath = LoftPathBuffers[profile.Road].Reinterpret <RigidTransform>().AsNativeArray();
NativeArray <RigidTransform> leftSamples, rightSamples;
NativeArray <DashPoint> leftDashPoints, rightDashPoints;
if (surface.LeftLaneMarking != Entity.Null &&
!Utilities.GeometryUtility.ApproximatelyEqual(RoadMarkings[surface.LeftLaneMarking].SeparationDistance, 0f))
{
var leftMarkingWidth = RoadMarkings[surface.LeftLaneMarking].Width;
leftLateralPoint.x += leftMarkingWidth / 2f;
var roadMarkingSamples = RoadMarkingSampleBuffers[surface.LeftLaneMarking]
.Reinterpret <RigidTransform>().AsNativeArray();
leftSamples = Utilities.SplineUtility.OffsetSpline(roadMarkingSamples, leftLateralPoint, Allocator.Temp);
leftDashPoints = new NativeArray <DashPoint>(DashPointBuffers[surface.LeftLaneMarking].AsNativeArray(), Allocator.Temp);
}
else
{
if (surface.LeftLaneMarking != Entity.Null)
{
leftLateralPoint.x += RoadMarkings[surface.LeftLaneMarking].Width / 2f;
}
leftSamples = Utilities.SplineUtility.OffsetSpline(loftPath, leftLateralPoint, Allocator.Temp);
leftDashPoints = new NativeArray <DashPoint>(leftSamples.Length, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
for (var i = 0; i < leftDashPoints.Length; i++)
{
leftDashPoints[i] = new DashPoint {
Distance = i
};
}
}
if (surface.RightLaneMarking != Entity.Null &&
!Utilities.GeometryUtility.ApproximatelyEqual(RoadMarkings[surface.RightLaneMarking].SeparationDistance, 0f))
{
var rightMarkingWidth = RoadMarkings[surface.RightLaneMarking].Width;
rightLateralPoint.x -= rightMarkingWidth / 2f;
var roadMarkingSamples = RoadMarkingSampleBuffers[surface.RightLaneMarking]
.Reinterpret <RigidTransform>().AsNativeArray();
rightSamples = Utilities.SplineUtility.OffsetSpline(roadMarkingSamples, rightLateralPoint, Allocator.Temp);
rightDashPoints = new NativeArray <DashPoint>(DashPointBuffers[surface.RightLaneMarking].AsNativeArray(), Allocator.Temp);
}
else
{
if (surface.RightLaneMarking != Entity.Null)
{
rightLateralPoint.x -= RoadMarkings[surface.RightLaneMarking].Width / 2f;
}
rightSamples = Utilities.SplineUtility.OffsetSpline(loftPath, rightLateralPoint, Allocator.Temp);
rightDashPoints = new NativeArray <DashPoint>(rightSamples.Length, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
for (var i = 0; i < rightDashPoints.Length; i++)
{
rightDashPoints[i] = new DashPoint {
Distance = i
};
}
}
var vertexBuffer = CombinedVertexBuffers[surfaceEntity];
var numVertices = leftSamples.Length + rightSamples.Length;
vertexBuffer.ResizeUninitialized(numVertices);
var vertexArray = vertexBuffer.AsNativeArray();
for (var i = 0; i < leftSamples.Length; i++)
{
vertexArray[i] = new CombinedVertex
{
Vertex = leftSamples[i].pos,
Normal = math.mul(leftSamples[i].rot, new float3(0f, 1f, 0f)),
Uv = leftSamples[i].pos.xz
};
}
for (int i = 0, j = leftSamples.Length; i < rightSamples.Length; i++, j++)
{
vertexArray[j] = new CombinedVertex
{
Vertex = rightSamples[i].pos,
Normal = math.mul(rightSamples[i].rot, new float3(0f, 1f, 0f)),
Uv = rightSamples[i].pos.xz
};
}
var triangleBuffer = TriangleBuffers[surfaceEntity].Reinterpret <int>();
triangleBuffer.ResizeUninitialized(3 * (numVertices - 2));
var triangleArray = triangleBuffer.AsNativeArray();
var numLeftSamples = leftSamples.Length;
for (int i = 1, leftStartIdx = 0, rightStartIdx = 0, triangleIdx = 0; i < loftPath.Length; i++)
{
var nextLeftIdx = leftStartIdx + 1;
var nextRightIdx = rightStartIdx + 1;
while (!Utilities.GeometryUtility.ApproximatelyEqual(leftDashPoints[nextLeftIdx].Distance, i))
{
nextLeftIdx++;
}
while (!Utilities.GeometryUtility.ApproximatelyEqual(rightDashPoints[nextRightIdx].Distance, i))
{
nextRightIdx++;
}
for (var j = leftStartIdx; j < nextLeftIdx; j++)
{
triangleArray[triangleIdx++] = rightStartIdx + numLeftSamples;
triangleArray[triangleIdx++] = j;
triangleArray[triangleIdx++] = j + 1;
}
for (var j = rightStartIdx; j < nextRightIdx; j++)
{
triangleArray[triangleIdx++] = nextLeftIdx;
triangleArray[triangleIdx++] = numLeftSamples + j + 1;
triangleArray[triangleIdx++] = numLeftSamples + j;
}
leftStartIdx = nextLeftIdx;
rightStartIdx = nextRightIdx;
}
var subMeshBuffer = SubMeshBuffers[surfaceEntity];
subMeshBuffer.Add(new SubMesh
{
Material = RoadMaterial.RoadSurface,
VertexStartIndex = 0,
VertexCount = vertexArray.Length,
TriangleStartIndex = 0,
TriangleCount = triangleArray.Length
});
leftSamples.Dispose();
leftDashPoints.Dispose();
rightSamples.Dispose();
rightDashPoints.Dispose();
}
public void MoveToPoint(DashPoint dashPoint)
{
StopAllCoroutines();
coroutine = MoveRoutine(dashPoint);
StartCoroutine(coroutine);
}
void DashSamples(
NativeArray <RigidTransform> samples,
RoadMarking marking,
out NativeList <RigidTransform> dashSamples,
out NativeList <DashPoint> dashPoints)
{
var sampleDistances = SplineUtility.SplineDistanceArray(samples, Allocator.Temp);
var totalDist = sampleDistances[sampleDistances.Length - 1];
marking.BeginningOffset %= marking.DashLength;
var patternDist = marking.DashLength + marking.SeparationDistance;
var numPatterns = (int)(totalDist / patternDist) + 2;
var patternPoints = new NativeArray <DashPoint>(numPatterns * 2, Allocator.Temp);
var accumulatedDist = marking.BeginningOffset;
for (var i = 0; i < patternPoints.Length;)
{
patternPoints[i++] = new DashPoint
{
Distance = accumulatedDist,
Cap = DashCap.Start
};
accumulatedDist += marking.DashLength;
patternPoints[i++] = new DashPoint
{
Distance = accumulatedDist,
Cap = DashCap.End
};
accumulatedDist += marking.SeparationDistance;
}
dashSamples = new NativeList <RigidTransform>(patternPoints.Length + sampleDistances.Length, Allocator.Temp);
dashPoints = new NativeList <DashPoint>(patternPoints.Length + sampleDistances.Length, Allocator.Temp);
dashSamples.Add(samples[0]);
dashPoints.Add(new DashPoint
{
Distance = 0f,
Cap = DashCap.End
});
for (int i = 1, j = 0; i < samples.Length; i++)
{
var prevSample = samples[i - 1];
var nextSample = samples[i];
var prevDist = sampleDistances[i - 1];
var nextDist = sampleDistances[i];
var betweenDist = nextDist - prevDist;
while (patternPoints[j].Distance < nextDist)
{
var t = (patternPoints[j].Distance - prevDist) / betweenDist;
dashSamples.Add(SplineUtility.LerpTransform(prevSample, nextSample, t));
dashPoints.Add(new DashPoint
{
Distance = i - 1 + t,
Cap = patternPoints[j].Cap
});
j++;
}
dashSamples.Add(nextSample);
dashPoints.Add(new DashPoint
{
Distance = i,
Cap = dashPoints[dashPoints.Length - 1].Cap
});
}
sampleDistances.Dispose();
patternPoints.Dispose();
}
