public List <OrientedPoint> Connect(OrientedPoint start, OrientedPoint end)
{
List <OrientedPoint> path = new List <OrientedPoint>();
int length = 13;
for (int i = 0; i < length; i++)
{
// Non-normalized path
path.Add(BezierCubic(start, end, (i / (float)(length - 1))));
// Add current point to previous neighbor list
if (i > 0)
{
path[i - 1].neighbors.Add(path[i]);
path[i].neighbors.Add(path[i - 1]);
}
}
// Update first and last neighbors
start.neighbors.Add(path.First());
path.Last().neighbors.Add(end);
end.neighbors.Add(path.Last());
// Update Public
pointsPath = path;
return(path);
}
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);
}
void GenerateRoads(Road left, Road right, OrientedPoint seed, int interval, bool majorFlag)
{
// Function for generating left and right roads from a candidate point
// Assumes existing gameobjects with Road.cs component attached
// Generate the roads
left.GenerateRoad(seed, _length, majorFlag, false);
right.GenerateRoad(seed, _length, majorFlag, true);
// Update neighbors in the newly generated roads and their seed points
if (left.path.Any())
{
seed.neighbors.Add(left.path.First());
left.path.First().neighbors.Add(seed);
AddCandidatesToQueue(left.path, interval);
}
if (right.path.Any())
{
seed.neighbors.Add(right.path.First());
right.path.First().neighbors.Add(seed);
AddCandidatesToQueue(right.path, interval);
}
}
public Area(Vector2Int _size, List <Cell> _cells, Street _s, OrientedPoint _center)
{
m_Size = _size;
m_Cells = _cells;
m_Street = _s;
m_OP = _center;
}
bool CheckProximity(OrientedPoint origin, OrientedPoint comparison, float threshold, float theta)
{
// Check if the points are too close, if yes, add them as neighbors to eachother and returns true
// Angle between origin orientation and the point
// Check for zero look-rotation
if (comparison.position - origin.position == Vector3.zero)
{
return(false);
}
Quaternion rotationToTarget = Quaternion.LookRotation(comparison.position - origin.position, Vector3.up);
// Search in a 120 degree cone forwards
float dist = CalcDistance(origin, comparison);
if (dist >= 3 && dist <= threshold && Quaternion.Angle(origin.rotation, rotationToTarget) <= theta)
{
// Debug.Log("Points " + origin.position + " and " + comparison.position + " too close. (Distance " + CalcDistance(origin, comparison) + ")");
return(true);
}
else
{
return(false);
}
}
public void GenerateRoad(OrientedPoint seed, int length, bool major, bool rev)
{
// Inherit some variables from parents
float offset = GetComponentInParent <RoadNetwork>()._offset;
int interval = GetComponentInParent <RoadNetwork>()._interval;
int scale = GetComponentInParent <CityGenerator>().scale;
List <OrientedPoint>[,] roadPoints = GetComponentInParent <RoadNetwork>().roadPoints;
field = new Field();
path = field.Trace(field.SampleOrthogonal, scale, offset, major, transform.position + seed.position, rev, length, roadPoints);
if (path.Count == 0)
{
return;
}
// Update neighbor of first point in path
path[0].neighbors.Add(seed);
Extrude(path);
// Pass road path to parent and round to chunk
foreach (OrientedPoint point in path)
{
int indX = ((int)(point.position.x / 10) + roadPoints.GetLength(0) / 2);
int indZ = ((int)(point.position.z / 10) + roadPoints.GetLength(1) / 2);
GetComponentInParent <RoadNetwork>().roadPoints[indX, indZ].Add(point);
}
}
private void GeneratePitch()
{
if (mMesh == null)
{
mMesh = new Mesh();
mMesh.name = "Road Segment";
m_MeshFilter.sharedMesh = mMesh;
}
mMesh.Clear(); //clear existing data
int vCount = VertexCount;
List <Vector3> vertices = new List <Vector3> ();
List <Vector3> normals = new List <Vector3> ();
List <Vector2> uvs = new List <Vector2> ();
for (int i = 0; i < m_CurveDetailLevel + 1; i++)
{
float t = i / (float)m_CurveDetailLevel;
OrientedPoint bezierPoint = GetBezierOrientation(t);
Vector3 localLeftVector = bezierPoint.LocalToWorld(-Vector3.right * (m_CurveThickness * 0.1f)); //(bezierPoint.position) + (Vector3.left * m_RoadThickness * 0.5f);
Vector3 localRightVector = bezierPoint.LocalToWorld(Vector3.right * (m_CurveThickness * 0.1f)); //(bezierPoint.position) + (Vector3.right * (m_CurveThickness * 0.1f));
vertices.Add(localLeftVector);
normals.Add(-Vector3.up); // in localspace
vertices.Add(localRightVector);
normals.Add(-Vector3.up); // in localspace
Gizmos.DrawSphere(localLeftVector, 0.005f);
Gizmos.DrawSphere(localRightVector, 0.005f);
uvs.Add(new Vector2(1, t));
uvs.Add(new Vector2(0, t));
}
List <int> triangleIndices = new List <int> ();
for (int i = 0; i < m_CurveDetailLevel; i++)
{
int rootIndex = i * 2;
int rtInner = rootIndex + 1;
int rtOuterNext = (rootIndex + 2);
int rtInnerNext = (rootIndex + 3);
triangleIndices.Add(rootIndex);
triangleIndices.Add(rtOuterNext);
triangleIndices.Add(rtInnerNext);
triangleIndices.Add(rootIndex);
triangleIndices.Add(rtInnerNext);
triangleIndices.Add(rtInner);
}
mMesh.SetVertices(vertices);
mMesh.SetTriangles(triangleIndices, 0);
mMesh.SetNormals(normals);
mMesh.SetUVs(0, uvs);
}
public OrientedPoint[] GeneratePath()
{
BezierSpline bezierSpline = GetComponent <BezierSpline> ();
if (bezierSpline == null)
{
Debug.Log("No bezier spline curve assigned to the game object");
return(null);
}
int numPoints = (int)Mathf.Ceil(bezierSpline.GetSplineLenght() / pathIncrementSize);
float realIncrementSize = bezierSpline.GetSplineLenght() / numPoints;
OrientedPoint[] path = new OrientedPoint[numPoints + 1];
for (int i = 0; i < numPoints; i++)
{
Vector3 bezierPoint = bezierSpline.GetPointFromParametricValue(i * realIncrementSize);
Vector3 bound_bezierPoint = Vector3.zero;
Vector3 direction_bound = Vector3.zero;
Vector3 direction_startToMid = Vector3.zero;
if (adaptHeightToTerrain)
{
float height = tCE.WorldToTerrainHeight(new Vector2(bezierPoint.x, bezierPoint.z));
float weight = 1;
for (int j = 0; j < 4; j++)
{
int bound_i = i + j - 2;
if (bound_i >= numPoints)
{
bound_i -= numPoints;
}
else if (bound_i < 0)
{
bound_i += numPoints;
}
Vector3 bezierPoint2 = bezierSpline.GetPointFromParametricValue(bound_i * realIncrementSize);
height += tCE.WorldToTerrainHeight(new Vector2(bezierPoint2.x, bezierPoint2.z));
weight += 1;
}
height = height / weight;
// The code above is for smoothing the road. It's not great but should work for now.
bezierPoint.y = height + verticalHeightOffset;
}
path [i].position = bezierPoint;
path [i].rotation = bezierSpline.GetOrientationFromParametricValue(i * realIncrementSize);
path [i].cumulDistance = i * realIncrementSize;
}
path[numPoints] = path[0];
//// This is how I closed the gap. I also increased the variable path's size by 1.
//// Problem it causes the texture to act wierd at the start.
return(path);
}
public OrientedPoint PathOrientedPoint(float t)
{
OrientedPoint op = LocalPathOrientedPoint(t);
op.position = transform.TransformPoint(op.position);
return(op);
}
internal float GetWidth(int segPos, float tPos)
{
OrientedPoint left = GetWallPos(segPos, tPos, lWallPoints);
OrientedPoint right = GetWallPos(segPos, tPos, rWallPoints);
return(Vector3.Distance(left.position, right.position) - 1.0f - (0.68f * 2.0f));
}
private void EnsureSizePart(TGridLineModel model, Size availableSize, Orientation orientation, bool expandCross)
{
var horizontal = orientation.IsHorizontal();
var orientedSize = new OrientedSize(orientation, availableSize);
var currentOrientedSize = new OrientedSize(orientation, _size);
var gridLines = model.GridLines;
var sortedDefinitions = gridLines.SortedLines;
var fillSize = orientedSize.Direct + MaxGridStep;
var lineSize = orientedSize.Indirect + (expandCross ? MaxGridStep : 0);
var lineCount = horizontal ? _lineCountX : _lineCountY;
if (lineSize.IsGreaterThan(currentOrientedSize.Indirect))
{
for (var i = 0; i < sortedDefinitions.Count; i++)
{
var pathFigureCollection = _pathFigures[i].Figures;
var iLine = 0;
foreach (var figure in pathFigureCollection)
{
var line = (LineSegment)figure.Segments[0];
var lineOrientation = figure.StartPoint.X.Equals(line.Point.X) ? Orientation.Horizontal : Orientation.Vertical;
if (orientation != lineOrientation)
{
continue;
}
var orientedPoint = new OrientedPoint(orientation, figure.StartPoint);
var iStep = gridLines.GetSortedDefinitionIndex(iLine);
var lineDefinition = sortedDefinitions[iStep];
UpdateLineFigure(figure, lineDefinition, orientation, orientedPoint.Direct, orientedPoint.Indirect, lineSize);
iLine++;
}
}
}
for (var offset = lineCount * GridStep; offset < fillSize; offset += GridStep)
{
var snapOffset = offset.LayoutRound(orientation, RoundingMode.MidPointFromZero) + 0.5;
var iStep = gridLines.GetSortedDefinitionIndex(lineCount);
var lineDefinition = sortedDefinitions[iStep];
var pathFigureCollection = _pathFigures[iStep].Figures;
pathFigureCollection.Add(CreateLineFigure(lineDefinition, orientation, snapOffset, 0, lineSize));
lineCount++;
}
if (horizontal)
{
_lineCountX = lineCount;
}
else
{
_lineCountY = lineCount;
}
}
public OrientedPoint BezierCubic(OrientedPoint start, OrientedPoint end, float t)
{
// Calculate control points, a for the start, b for the end
OrientedPoint a = new OrientedPoint(
start.position + (start.rotation * Vector3.forward * 20),
start.rotation,
start.magnitude,
new List <OrientedPoint>()
);
OrientedPoint b = new OrientedPoint(
end.position + (end.rotation * Vector3.back * 20),
end.rotation * Quaternion.LookRotation(Vector3.back),
end.magnitude,
new List <OrientedPoint>()
);
// Square bezier between points start - a - b
OrientedPoint ab = BezierSquare(start, a, b, t);
// Square bezier between points a - b - end
OrientedPoint bc = BezierSquare(a, b, end, t);
// Lerp between points ab - bc to produce the final point in the bezier curve
return(LerpOrientedPoint(ab, bc, t));
}
private void GenerateRoad()
{
if (mMesh == null)
{
mMesh = new Mesh();
mMesh.name = "RoadSegment";
m_MeshFilter.sharedMesh = mMesh;
}
mMesh.Clear();
//vertices
List <Vector3> allVertsAlongRoad = new List <Vector3> ();
List <Vector3> allNormals = new List <Vector3> ();
for (int ring = 0; ring < m_VerticalSliceCount; ring++)
{
float t = ring / (m_VerticalSliceCount - 1f);
OrientedPoint op = GetBezierOrientation(t);
for (int i = 0; i < m_Shape2D.vertices.Length; i++)
{
allVertsAlongRoad.Add(op.LocalToWorld(m_Shape2D.vertices[i].points));
allNormals.Add(op.LocalToWorldVec(m_Shape2D.vertices[i].normals));
//allNormals.Add (m_Shape2D.vertices[i].normals);//without rotation
}
}
//Trianlges
List <int> allTriangles = new List <int> ();
for (int ring = 0; ring < m_VerticalSliceCount - 1; ring++)
{
int rootIndex = ring * m_Shape2D.GetVertexCount();
int rootIndexForward = (ring + 1) * m_Shape2D.GetVertexCount();
for (int line = 0; line < m_Shape2D.GetLineCount(); line += 2)
{
int lineA = m_Shape2D.lineIndices[line];
int lineB = m_Shape2D.lineIndices[line + 1];
int currentA = rootIndex + lineA;
int currentB = rootIndex + lineB;
int nextA = rootIndexForward + lineA;
int nextB = rootIndexForward + lineB;
allTriangles.Add(currentA);
allTriangles.Add(nextA);
allTriangles.Add(nextB);
allTriangles.Add(nextB);
allTriangles.Add(currentB);
allTriangles.Add(currentA);
}
}
mMesh.SetVertices(allVertsAlongRoad);
mMesh.SetTriangles(allTriangles, 0);
mMesh.SetNormals(allNormals);
}
public int length; // = 5000; // Global max length for each road generated
public void GenerateRoadNetwork(OrientedPoint startingSeed, int iter, int length, int interval)
{
// Reference to parent
CityGenerator parent = gameObject.GetComponentInParent <CityGenerator>();
_interval = parent.interval;
_offset = parent.offset;
_length = parent.length;
_iter = parent.length;
ctr = _iter;
// Create and initialize new lookup matrix (chunks)
roadPoints = new List <OrientedPoint> [500, 500];
for (int x = 0; x < roadPoints.GetLength(0); x++)
{
for (int z = 0; z < roadPoints.GetLength(1); z++)
{
roadPoints[x, z] = new List <OrientedPoint>();
}
}
// Clear the queue before new generation starts
seeds.Clear();
// Function structure
GameObject mainRoad = new GameObject("Main Road");
mainRoad.AddComponent <Road>().transform.parent = this.transform;
Road road = mainRoad.GetComponent <Road>();
// Generate the first road from the starting point
road.GenerateRoad(startingSeed, length, true, false);
// Extract seeds from the road and add to queue
AddCandidatesToQueue(road.path, interval);
while (seeds.Count != 0 && iter > 0)
{
OrientedPoint roadSeed = seeds.Dequeue();
GameObject leftRoad = GenerateChildRoad();
GameObject rightRoad = GenerateChildRoad();
// Generate the subroads with alternating major flag
// Flip the major flag for the next road
bool major = !roadSeed.major;
Road left = leftRoad.GetComponent <Road>();
Road right = rightRoad.GetComponent <Road>();
// Generate roads in either direction from seed
GenerateRoads(left, right, roadSeed, interval, major);
iter--;
ctr--;
}
}
/// <summary>
/// Create all the vertices for the mesh
/// </summary>
private void CreateTrackVertices()
{
ProTwoDShape pTwoDShape = CreateTwoDShape(MeshToExtrude);
//Create an array of OrientedPoint
OrientedPoint[] oPoints = new OrientedPoint[_spline.SmoothNumPoints];
//Assign each oPoint
for (int i = 0; i < oPoints.Length; i++)
{
//Get the point before current point
Vector3 lastPoint = _spline.AllSmoothPoints[((i - 1) + oPoints.Length) % oPoints.Length];
//Get current point
Vector3 currentPoint = _spline.AllSmoothPoints[i];
//Get the next point
Vector3 nextPoint = _spline.AllSmoothPoints[((i + 1) + oPoints.Length) % oPoints.Length];
//Get the direction from currentPoint to lastPoint
Vector3 lc = currentPoint - lastPoint;
//Get the direction from nextPoint to currentPoint
Vector3 cn = nextPoint - currentPoint;
//Avgrage the start and end points for each curve
//Set the points direction. This direction is the forward vector
Vector3 dir = (lc + cn) * 0.5f;
dir.Normalize();
//Get the right Vector
dir = Vector3.Cross(dir, Vector3.up).normalized;
//new the oPoint
oPoints[i] = new OrientedPoint(_spline.AllSmoothPoints[i],
Quaternion.LookRotation(dir, Vector3.up));
}
//Generate all the center points on the mesh
//This will also set the forward rotation
//and UV for each point
for (int i = 0; i < oPoints.Length; i++)
{
for (int j = 0; j < pTwoDShape.Vertices.Count; j++)
{
//get the forward vector
Vector3 fwd = oPoints[i].Rotation * Vector3.forward;
//get the position
Vector3 pos = oPoints[i].Position + (pTwoDShape.Vertices[j].x * fwd);
pos.y = oPoints[i].Position.y + pTwoDShape.Vertices[j].y;
//add the new vertex to the proMesh.Vertices list
proMesh.Vertices.Add(pos);
//Setup the uv coords for this vertex
float x = (float)j / (pTwoDShape.Vertices.Count - 1);
float y = (float)i / oPoints.Length;
Vector2 uv = new Vector2(x, y);
proMesh.Uvs.Add(uv);
}
}
}
public OrientedPoint LerpOrientedPoint(OrientedPoint a, OrientedPoint b, float t)
{
return(new OrientedPoint(
Vector3.Lerp(a.position, b.position, t),
Quaternion.Slerp(a.rotation, b.rotation, t),
a.magnitude + (b.magnitude - a.magnitude) * t,
new List <OrientedPoint>()
));
}
OrientedPoint[] createOrientedPoints(Vector3[] points, Quaternion[] quats)
{
OrientedPoint[] orientedPoint = new OrientedPoint[points.GetLength(0)];
for (int i = 0; i < orientedPoint.GetLength(0); i++)
{
orientedPoint[i] = new OrientedPoint(points[i], quats[i]);
}
return(orientedPoint);
}
float GetNoiseVal(OrientedPoint point, int scale)
{
int offset = 12500;
System.Func <float, float, float> f = Mathf.PerlinNoise;
float x_0 = (point.position.x + offset) / scale;
float z_0 = (point.position.z + offset) / scale;
// Return values from 0-2
return(f(x_0, z_0));
}
public void OnDrawGizmos()
{
for (int i = 0; i < 4; i++)
{
Gizmos.DrawSphere(GetPos(i), 0.1f);
}
Handles.DrawBezier(GetPos(0), GetPos(3), GetPos(1), GetPos(2), Color.white, EditorGUIUtility.whiteTexture, 1);
OrientedPoint bezPoint = GetBezierPoint(_t);
Handles.PositionHandle(bezPoint.pos, bezPoint.rot);
}
public void GenerateMesh()
{
// Set path
mesh = new Mesh();
Array.Resize(ref path, step + 1);
for (int i = 0; i <= step; i++)
{
path[i] = new OrientedPoint(bezierSpline.GetPoint((float)i / step), bezierSpline.GetOrientation3D((float)i / step));
}
ExtrudeMesh();
}
// Use this for initialization
void Start()
{
Mesh mesh = new Mesh();
CatmullRomSpline spline = new CatmullRomSpline();
Vector3[] pos = new Vector3[points.Count];
Quaternion[] rot = new Quaternion[points.Count];
for (int i = 0; i < points.Count; i++)
{
pos[i] = points[i].transform.position;
rot[i] = points[i].transform.rotation;
}
Vector3 tangent;
for (int i = 0; i < points.Count; i++)
{
tangent = Vector3.Cross(spline.GetTangent(i, pos), Vector3.forward);
if (tangent.magnitude == 0)
{
tangent = Vector3.Cross(spline.GetTangent(i, pos), Vector3.up);
}
points[i].transform.rotation = Quaternion.Euler(tangent);
}
OrientedPoint[] oPoints = new OrientedPoint[(int)(1 / resolution)];
for (float i = 0f; i < 1.0f; i += resolution)
{
if (i != 0f || i != 1f)
{
oPoints[(int)i * 10].position = spline.GetPoint(i, pos);
tangent = Vector3.Cross(spline.GetTangent(i, pos), Vector3.forward);
if (tangent.magnitude == 0)
{
tangent = Vector3.Cross(spline.GetTangent(i, pos), Vector3.up);
}
oPoints[(int)i * 10].rotation = Quaternion.Euler(tangent);
}
}
Vector2[] verts = { new Vector2(0, 0), new Vector2(1, 0) };
Vector2[] normals = { new Vector2(0, 1), new Vector2(0, 1) };
int[] lines = { 0, 1 };
Shape shape = new Shape(verts, normals, lines);
Extrude extrusao = new Extrude(ref mesh, shape, oPoints);
this.GetComponent <MeshFilter>().sharedMesh = mesh;
}
// Update is called once per frame
protected void Update()
{
closest = path.GetProjectionAndTangent(transform.position);
p = closest.Pos + closest.Dir * 2;
target = path.GetProjectionAndTangent(p);
SetSpeed(Vector3.SqrMagnitude(target.Pos - p));
character.Move(target.Pos - transform.position, false, false);
EndCheck();
}
public static IEnumerable <OrientedPoint> GeneratePath(Vector3 start, Vector3 end, Vector3 tanPoint1, Vector3 tanPoint2, float subDivisions)
{
float step = 1.0f / subDivisions;
for (float f = 0; f < 1; f += step)
{
OrientedPoint p = GetOrientedPoint(start, end, tanPoint1, tanPoint2, f);
yield return(p);
}
//yield return GetOrientedPoint(start, end, tanPoint1, tanPoint2, 1);
}
void GenerateMesh()
{
mesh.Clear();
// Vertices
List <Vector3> verts = new List <Vector3>();
List <Vector3> normals = new List <Vector3>();
for (int ring = 0; ring < edgeRingCount; ring++)
{
float t = ring / (edgeRingCount - 1f);
OrientedPoint op = GetBezierOP(t);
for (int i = 0; i < shape2D.VertexCount; i++)
{
verts.Add(op.LocalToWorldPos(shape2D.vertices[i].point));
normals.Add(op.LocalToWorldVec(shape2D.vertices[i].normal));
}
}
// Triangles
List <int> triIndices = new List <int>();
for (int ring = 0; ring < edgeRingCount - 1; ring++)
{
int rootIndex = ring * shape2D.VertexCount;
int rootIndexNext = (ring + 1) * shape2D.VertexCount;
for (int line = 0; line < shape2D.LineCount; line += 2)
{
int lineIndexA = shape2D.lineIndices[line];
int lineIndexB = shape2D.lineIndices[line + 1];
int currentA = rootIndex + lineIndexA;
int currentB = rootIndex + lineIndexB;
int nextA = rootIndexNext + lineIndexA;
int nextB = rootIndexNext + lineIndexB;
triIndices.Add(currentA);
triIndices.Add(nextA);
triIndices.Add(nextB);
triIndices.Add(currentA);
triIndices.Add(nextB);
triIndices.Add(currentB);
}
}
mesh.SetVertices(verts);
mesh.SetNormals(normals);
mesh.SetTriangles(triIndices, 0);
}
public OrientedPoint GetOrientedPointAtDistance(float d)
{
int i = GetStretchAtDistance(ref d);
Stretch st = GetNStretch(i);
OrientedPoint p = st.GetOrientedPointAtDistance(d);
if (!IsStretchNForward(i))
{
p = new OrientedPoint(p.Pos, -p.Dir);
}
return(p);
}
public void AddNewPoints(OrientedPoint[] pointsToAdd)
{
int pointsLength = (points != null) ? points.Length : 0;
OrientedPoint[] newPoints = new OrientedPoint[pointsLength + pointsToAdd.Length];
for (int i = 0; i < newPoints.Length; i++)
{
newPoints[i] = (i < pointsLength) ? points[i] : pointsToAdd[i - pointsLength];
}
points = newPoints;
}
public static void Extrude(Mesh mesh, Shape shape, OrientedPoint[] path)
{
int vertsInShape = shape.points.Length;
int segments = path.Length - 1;
int edgeLoops = path.Length;
int vertCount = edgeLoops * vertsInShape;
int triCount = segments * (vertsInShape - 1) * 2;
int triIndexCount = triCount * 3;
int[] triangleIndices = new int[triIndexCount];
Vector3[] vertices = new Vector3[vertCount];
Vector3[] normals = new Vector3[vertCount];
Vector2[] uvs = new Vector2[vertCount];
mesh.Clear();
for (int i = 0; i < path.Length; i++)
{
int offset = i * vertsInShape;
for (int j = 0; j < vertsInShape; j++)
{
int id = offset + j;
vertices[id] = path[i].LocalToWorld(shape.points[j]);
normals[id] = path[i].LocalToWorldDirection(shape.normals[j]);
uvs[id] = new Vector2(shape.uCoords[j], i / ((float)edgeLoops));
}
}
int ti = 0;
for (int i = 0; i < segments; i++)
{
int offset = i * vertsInShape;
for (int l = 0; l < shape.lines.Length; l += 2)
{
int a = offset + shape.lines[l] + vertsInShape;
int b = offset + shape.lines[l];
int c = offset + shape.lines[l + 1];
int d = offset + shape.lines[l + 1] + vertsInShape;
triangleIndices[ti] = a; ti++;
triangleIndices[ti] = b; ti++;
triangleIndices[ti] = c; ti++;
triangleIndices[ti] = c; ti++;
triangleIndices[ti] = d; ti++;
triangleIndices[ti] = a; ti++;
}
}
mesh.vertices = vertices;
mesh.normals = normals;
mesh.triangles = triangleIndices;
mesh.uv = uvs;
}
public OrientedPoint BezierSquare(OrientedPoint start, OrientedPoint controlPoint, OrientedPoint end, float t)
{
// Lerp between points start - b - end
OrientedPoint ab = LerpOrientedPoint(start, controlPoint, t);
OrientedPoint bc = LerpOrientedPoint(controlPoint, end, t);
OrientedPoint d = LerpOrientedPoint(ab, bc, t);
// Since we want the tangent and not the Lerped rotation between the points, we update
// the rotation to reflect this.
d.rotation = Quaternion.LookRotation(bc.position - ab.position);
return(d);
}
bool CheckBounds(OrientedPoint point, int mapSize)
{
if (point.magnitude <= 0.1 ||
point.position.x > mapSize ||
point.position.z > mapSize ||
point.position.x < -mapSize ||
point.position.z < -mapSize)
{
// Debug.Log("Bounds check failed, returning...");
return(true);
}
else
{
return(false);
}
}
public OrientedPoint[] CalculateEvenlySpaceOrientedPoints(float spacing, float resolution = 1.0f)
{
List <OrientedPoint> spacedPoints = new List <OrientedPoint>();
spacedPoints.Add(new OrientedPoint(points[0]));
var previousPoint = new OrientedPoint(points[0]);
float distanceFromPrevious = 0f;
for (int segIndex = 0; segIndex < NumSegments; ++segIndex)
{
Vector3[] p = GetPointsInSegment(segIndex);
float controlNetLength = Vector3.Distance(p[0], p[1]) + Vector3.Distance(p[1], p[2]) + Vector3.Distance(p[2], p[3]);
float estimatedCurveLEngth = Vector3.Distance(p[0], p[3]) + (controlNetLength * 0.5f);
int divisions = (int)estimatedCurveLEngth * (int)resolution * 10;
var pointStart = Bezier.EvaluateCubicOriented(p[0], p[1], p[2], p[3], 0.0f);
spacedPoints.Add(pointStart);
previousPoint = pointStart;
float t = 0f;
while (t < 1f)
{
t += 1f / divisions;
var poc = Bezier.EvaluateCubicOriented(p[0], p[1], p[2], p[3], t);
distanceFromPrevious += Vector3.Distance(previousPoint.position, poc.position);
while (distanceFromPrevious >= spacing)
{
float overShoot = distanceFromPrevious - spacing;
Vector3 newPoint = poc.position + (previousPoint.position - poc.position).normalized * overShoot;
float deltaLen = (newPoint - previousPoint.position).magnitude;
float percent = overShoot / deltaLen;
Quaternion newOritentation = Quaternion.Slerp(previousPoint.orientation, poc.orientation, percent);
spacedPoints.Add(new OrientedPoint(newPoint, newOritentation));
distanceFromPrevious = overShoot;
previousPoint = new OrientedPoint(newPoint);
}
previousPoint = poc;
}
var pointFinal = Bezier.EvaluateCubicOriented(p[0], p[1], p[2], p[3], 1.0f);
spacedPoints.Add(pointFinal);
previousPoint = pointFinal;
}
return(spacedPoints.ToArray());
}
public void CalculateSplinePoints()
{
SplinePoints.Clear();
float step = 1.0f / (InterpolationSteps - 1);
for (int i = 0; i < InterpolationSteps; ++i)
{
var t = i * step;
var point = CalculateSplinePoint(t);
var normal = CalculateNormal(t);
OrientedPoint p = new OrientedPoint(point, normal);
SplinePoints.Add(p);
}
}
public void RegenerateMesh()
{
Mesh mesh = new Mesh();
Vector3[] pts = {
(curve.a.localPosition),
(curve.b.localPosition),
(curve.c.localPosition),
(curve.d.localPosition)
};
OrientedPoint[] path = new OrientedPoint[numDivs + 1];
for (int i = 0; i < numDivs + 1; i++)
{
OrientedPoint p;
float t = ((float)i / (float)numDivs);
p.position = BezierCurve.GetPoint(pts, t);
p.rotation = BezierCurve.GetOrientation3D(pts, (float)i / (float)numDivs, -Vector3.Lerp(curve.a.transform.up, curve.c.transform.up, t));
path[i] = p;
}
Shape.Extrude(mesh, profileShape, path);
mesh.RecalculateNormals();
meshFilter.sharedMesh = mesh;
if (generateCollider)
{
MeshCollider mc = GetComponent<MeshCollider>();
if (mc == null)
{
mc = gameObject.AddComponent<MeshCollider>();
}
mc.sharedMesh = mesh;
}
Debug.Log("Mesh regenerated with vertex count: " + mesh.vertexCount);
}
/// <summary>
/// Re extrudes the profile shape along the stored spline generating a new mesh and updating the colliders
/// </summary>
public void RegenerateMesh()
{
Mesh mesh = new Mesh();
Vector3[] pts = {
transform.InverseTransformPoint(a.position),
transform.InverseTransformPoint(b.position),
transform.InverseTransformPoint(c.position),
transform.InverseTransformPoint(d.position)
};
//Debug.Log(name + " " + a.InverseTransformPoint(b.position));
OrientedPoint[] path = new OrientedPoint[numDivs + 1];
for (int i = 0; i < numDivs+ 1; i++)
{
OrientedPoint p;
float t = ((float)i / (float)numDivs);
p.position = GetPoint(pts, t);
p.rotation = GetOrientation3D(pts, (float)i / (float)numDivs, -Vector3.Lerp(a.transform.up, c.transform.up, t));
path[i] = p;
}
Shape.Extrude(mesh, profileShape, path);
mesh.RecalculateNormals();
if(isCollider)
{
ReverseNormals(mesh);
}
//Debug.Log("Mesh regenerated " + mesh.vertexCount);
GetComponent<MeshFilter>().sharedMesh = mesh;
MeshCollider mc = GetComponent<MeshCollider>();
if(mc == null)
{
mc = gameObject.AddComponent<MeshCollider>();
}
mc.sharedMesh = mesh;
}
OrientedPoint[] createOP(int size)
{
OrientedPoint[] ops = new OrientedPoint[size];
return ops;
}
