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