private void RenderSegments() { Vertex[] vertices = { new Vertex(new Vector3(-.0125f, -.0025f, 0), Vector3.down, 0), new Vertex(new Vector3(.0125f, -.0025f, 0), Vector3.down, 1), new Vertex(new Vector3(.0125f, -.0025f, 0), Vector3.right, 1), new Vertex(new Vector3(.0125f, .0025f, 0), Vector3.right, 1), new Vertex(new Vector3(.0125f, .0025f, 0), Vector3.up, 1), new Vertex(new Vector3(-.0125f, .0025f, 0), Vector3.up, 0), new Vertex(new Vector3(-.0125f, .0025f, 0), Vector3.left, 0), new Vertex(new Vector3(-.0125f, -.0025f, 0), Vector3.left, 0) }; int[] lines = new int[] { 0, 1, 2, 3, 4, 5, 6, 7 }; ExtrudeShape shape = new ExtrudeShape(vertices, lines); for (int i = 0; i < segments.Count; i++) { RenderSegment(segments[i], shape, paths[i]); } }
public void GenerateMesh(ExtrudeShape shape, float detail) { List <OrientationPoint> path = new List <OrientationPoint>(); int refPointCount = Mathf.FloorToInt(ControlPointCount * detail); for (int i = 0; i < refPointCount; i++) { float t = (float)i / refPointCount; Vector3 generatePointRef = GetPoint(t); Quaternion rotation = Quaternion.LookRotation(GetDirection(t), Vector3.up); path.Add(new OrientationPoint(generatePointRef, rotation)); if (i == 1) { path.Add(new OrientationPoint(generatePointRef, rotation)); } } if (Loop) { path.Add(path[0]); } GetComponent <MeshFilter>().sharedMesh = TrackGenerator.Extrude(shape, path.ToArray()); }
public void Load() { if (File.Exists(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve")) { ClearCurve(); BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Open(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve", FileMode.Open); BifurcationData data = (BifurcationData)bf.Deserialize(file); file.Close(); if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } for (int i = 0; i < data.nodesData.Length; ++i) { // Create Nodes Node node = CreateNode(transform.position, transform.rotation); node.Load(data.nodesData[i]); } planeX = data.planeX; // Create Splines CreateSpline(nodes[0], nodes[1]).ExtrudeSide(meshes[0], extrudeShape, "right", planeX); CreateSpline(nodes[0], nodes[2]).ExtrudeSide(meshes[1], extrudeShape, "left", planeX); } else { //Debug.Assert(true, "Data file not found"); Create(); } }
public static void Extrude(Mesh mesh, ExtrudeShape shape, OrientedPoint[] path) { int vertsInShape = shape.verts.Length; int segments = path.Length - 1; int edgeLoops = path.Length; int vertCount = vertsInShape * edgeLoops; int triCount = shape.Lines.Length * segments * 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]; // Generate all of the vertices and normals for (int i = 0; i < path.Length; i++) { int offset = i * vertsInShape; for (int j = 0; j < vertsInShape; j++) { int id = offset + j; Vector3 vert = path[i].LocalToWorld(shape.verts[j]); if (shape.verts[j].y == -10) { vert.y = -2000; } vertices[id] = vert; normals[id] = path[i].LocalToWorldDirection(shape.normals[j]); uvs[id] = new Vector2(shape.uCoords[j], path[i].vCoordinate); } } // Generate all of the triangles 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]; int b = offset + shape.Lines[l] + vertsInShape; int c = offset + shape.Lines[l + 1] + vertsInShape; int d = offset + shape.Lines[l + 1]; triangleIndices[ti++] = a; triangleIndices[ti++] = b; triangleIndices[ti++] = c; triangleIndices[ti++] = c; triangleIndices[ti++] = d; triangleIndices[ti++] = a; } } mesh.Clear(); mesh.vertices = vertices; mesh.normals = normals; mesh.uv = uvs; mesh.triangles = triangleIndices; }
public Mesh UpdateMesh(List <Vector2> points) { this.points = points; this.mesh = ExtrudeShape.Generate(this.points, this.depth); this.volume = MeshVolume.Calculate(mesh); this.mass = (defaultMass + this.volume * 100.0f); return(this.mesh); }
private void RenderSegment(GameObject segment, ExtrudeShape shape, OrientedPoint[] path) { // TODO: use the shape from the previous segment to make segments continuous // TODO: use sampling to fix texture stretching MeshFilter mf = segment.GetComponent <MeshFilter>(); Mesh mesh = mf.mesh; Extrude(mesh, shape, path); }
Mesh Extrude(ExtrudeShape shape, OrientedPoint[] path) { Mesh mesh = new Mesh(); int vertsInShape = shape.vertxs.GetLength(0); int segments = path.GetLength(0) - 1; int edgeLoops = path.GetLength(0); int vertCount = vertsInShape * edgeLoops; int triCount = shape.lines.GetLength(0) * segments; int triIndexCount = triCount * 3; int[] triangleIndices = new int[triIndexCount]; Vector3[] vertices = new Vector3[vertCount]; Vector3[] normals = new Vector3[vertCount]; Vector2[] uvs = new Vector2[vertCount]; // Generate all of the vertices and normals 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.vertxs[j]); normals[id] = path[i].LocalToWorldDirection(shape.normals[j]); uvs[id] = new Vector2(shape.uCoords[j], i / ((float)edgeLoops)); } } // Generate all of the triangles int ti = 0; for (int i = 0; i < segments; i++) { int offset = i * vertsInShape; for (int l = 0; l < shape.lines.GetLength(0); 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.Clear(); mesh.vertices = vertices; mesh.normals = normals; mesh.uv = uvs; mesh.triangles = triangleIndices; return(mesh); }
public void Extrude() { if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } splines[0].ExtrudeSide(meshes[0], extrudeShape, "right", planeX); splines[1].ExtrudeSide(meshes[1], extrudeShape, "left", planeX); }
public void Extrude() { if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } for (int i = 0; i < splines.Count; ++i) { splines[i].Extrude(meshes[i], extrudeShape); } }
private void Extrude(Mesh mesh, ExtrudeShape shape, OrientedPoint[] path) { int vertsInShape = shape.vert2Ds.Length; int segments = path.Length - 1; int edgeLoops = path.Length; int vertCount = vertsInShape * edgeLoops; int triCount = shape.lines.Length * segments; int triIndexCount = triCount * 3; int[] triangleIndices = new int[triIndexCount]; Vector3[] vertices = new Vector3[vertCount]; Vector3[] normals = new Vector3[vertCount]; Vector2[] uvs = new Vector2[vertCount]; 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.vert2Ds[j].point); normals[id] = path[i].LocalToWorldDirection(shape.vert2Ds[j].normal); uvs[id] = new Vector2(shape.vert2Ds[j].uCoord, i / ((float)edgeLoops)); } } int ti = 0; int[] lines = shape.lines; for (int i = 0; i < segments; i++) { int offset = i * vertsInShape; for (int l = 0; l < lines.Length; l += 2) { int a = offset + lines[l] + vertsInShape; int b = offset + lines[l]; int c = offset + lines[l + 1]; int d = offset + 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.Clear(); mesh.vertices = vertices; mesh.triangles = triangleIndices; mesh.normals = normals; mesh.uv = uvs; }
public void RenderRoad(Path path) { transform.position = Vector3.zero; Vector3[] points = path.CalculateEvenlySpacedPoints(spacing); int textureRepeat = Mathf.RoundToInt(tiling * points.Length * spacing * .05f); GetComponent <MeshRenderer>().material.mainTextureScale = new Vector3(1, textureRepeat); Quaternion[] quats = getNormal(points); Vector3[] shapRoad = sortVects3(roadMesh.vertices); ExtrudeShape extrudeShape = new ExtrudeShape(shapRoad, roadHeight, roadWidth); GetComponent <MeshFilter>().mesh = Extrude(extrudeShape, createOrientedPoints(points, quats)); }
void Start() { MeshFilter mf = GetComponent <MeshFilter>(); Mesh mesh = mf.mesh; Points = new Vector3[] { Transform1.position, Transform2.position, Transform3.position, Transform4.position, }; if (_noPointsYet) { Normals = new Vector2[] { new Vector2(0, 0), new Vector2(1, 0), new Vector2(2, 0), new Vector2(3, 0), }; Shape = new Vector2[] { new Vector2(0, 0), new Vector2(0, 1), new Vector2(0, 2), new Vector2(0, 3), }; _noPointsYet = false; } _curve = new BezierCurves(Points); OrientedPoint[] oPoints = _curve.GeneratePath(NumberOfSubdivisions).ToArray(); float[] uv = new float[] { 0.0f, 1, 0, 1 }; ExtrudeShape extrudeShape = new ExtrudeShape(Shape, Normals, uv); _curve.Extrude(mesh, extrudeShape, oPoints); }
public void Load() { if (File.Exists(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve")) { ClearCurve(); BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Open(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve", FileMode.Open); CurveData data = (CurveData)bf.Deserialize(file); file.Close(); if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } Node previousNode = null; for (int i = 0; i < data.nodesData.Length; ++i) { // Create Node Node node = CreateNode(transform.position, transform.rotation); node.Load(data.nodesData[i]); // If not the first, create a spline with the previous one if (previousNode != null) { BezierSpline spline = CreateSpline(previousNode, node); spline.SetData(data.splinesData[i - 1]); spline.Extrude(meshes[i - 1], extrudeShape); } previousNode = node; } this.closed = data.closed; if (closed) { BezierSpline spline = CreateSpline(nodes[nodes.Count - 1], nodes[0]); spline.Extrude(meshes[meshes.Count - 1], extrudeShape); } this.invisible = data.invisible; } else { Debug.Assert(true, "Data file not found"); } }
private void OnSceneGUI() { extrudeShape = target as ExtrudeShape; handleTransform = extrudeShape.transform; handleRotation = Tools.pivotRotation == PivotRotation.Local ? handleTransform.rotation : Quaternion.identity; Vector3 p0 = ShowPoint(0); for (int i = 0; i < extrudeShape.verts.Length - 1; i++) { Vector3 p1 = ShowPoint(i + 1); Handles.DrawLine(p0, p1); Repaint(); p0 = p1; } }
void GenerateCurve() { bc = new BezierCurve(points); ExtrudeShape es = new ExtrudeShape(); //Vertices for extrusion shape es.verts = new Vector2[] { new Vector2(-2, 0), new Vector2(-1.1f, 0.9f), new Vector2(0, 1), new Vector2(1.1f, 0.9f), new Vector2(2, 0) }; es.normals = new Vector2[] { Vector2.up, Vector2.up, Vector2.up, Vector2.up, Vector2.up }; es.uCoords = new float[] { 0, 0, 0, 0, 0 }; bc.Extrude(GetComponent <MeshFilter>().sharedMesh, es, bc.GeneratePath((float)divisions).ToArray()); /* * bc.Extrude(GetComponent<MeshFilter>().sharedMesh, es, new OrientedPoint[]{ * new OrientedPoint(new Vector3(0,0,0),Quaternion.identity, 0), * new OrientedPoint(new Vector3(0,5,10),Quaternion.identity, 1), * new OrientedPoint(new Vector3(0,15,20),Quaternion.identity, 2), * new OrientedPoint(new Vector3(0,20,25),Quaternion.identity, 3) * }); */ }
public override void Extrude() { if (invisible) { for (int i = 0; i < splines.Count; ++i) { splines[i].gameObject.GetComponent <MeshCollider>().sharedMesh = null; splines[i].gameObject.GetComponent <MeshFilter>().sharedMesh = null; } return; } if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } for (int i = 0; i < splines.Count; ++i) { splines[i].Extrude(meshes[i], extrudeShape); } }
void MakeShape() { shape = new ExtrudeShape(); shape.verts = new Vector2[] { new Vector2(0, -10), new Vector2(0, 10), new Vector2(0, 10), new Vector2(0, 10), new Vector2(1, 10), new Vector2(1, -10), new Vector2(1, -10), new Vector2(0, -10) }; shape.normals = new Vector2[] { new Vector2(1, 0), new Vector2(1, 0), new Vector2(0, 1), new Vector2(0, 1), new Vector2(-1, 0), new Vector2(-1, 0), new Vector2(0, -1), new Vector2(0, -1) }; shape.uCoords = new float[] { 0, 1, 1, 1, 0, 1, 1, 1 }; }
public static void Extrude(ref Mesh mesh, ExtrudeShape shape, OrientedPoint[] path) { int vertsInShape = shape.verts.Length; int segments = path.Length - 1; int edgeLoops = path.Length; int vertCount = vertsInShape * edgeLoops; int triCount = shape.Lines.Length * segments; int triIndexCount = triCount * 3; //Debug.Log(string.Format("VertsInShape:{0}\nsegments:{1}\nedgeLoops:{2}\nvertCount:{3}\ntriCount:{4}\ntriIndexCount:{5}", // vertsInShape, segments, edgeLoops, vertCount, triCount, triIndexCount)); int[] triangleIndices = new int[triIndexCount]; Vector3[] vertices = new Vector3[vertCount]; Vector3[] normals = new Vector3[vertCount]; Vector2[] uvs = new Vector2[vertCount]; // Generate all of the vertices and normals for (int i = 0; i < path.Length; i++) { int offset = i * vertsInShape; string debug = string.Format("pathPoint:{0}\noffset:{1}\n", i, offset); for (int j = 0; j < vertsInShape; j++) { int id = offset + j; vertices[id] = path[i].LocalToWorld(shape.verts[j]); //vertices[id] = shape.verts[j]; normals[id] = path[i].LocalToWorldDirection(shape.normals[j]); //normals[id] = shape.normals[j]; uvs[id] = new Vector2(shape.uCoords[j], path[i].vCoordinate); debug += string.Format("id:{0}\nvert:{1}\nnormals:{2}\nuv:{3}\n", id, vertices[id], normals[id], uvs[id]); } //Debug.Log(debug); } //Generation 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]; int b = offset + shape.Lines[l] + vertsInShape; int c = offset + shape.Lines[l + 1] + vertsInShape; int d = offset + shape.Lines[l + 1]; triangleIndices[ti++] = a; triangleIndices[ti++] = b; triangleIndices[ti++] = c; triangleIndices[ti++] = c; triangleIndices[ti++] = d; triangleIndices[ti++] = a; } } mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangleIndices; mesh.normals = normals; mesh.uv = uvs; string debugs = "Final Verts\n"; for (int i = 0; i < mesh.vertices.Length; i++) { debugs += string.Format("vert {0}: {1}\n", i, mesh.vertices[i]); } //Debug.Log(debugs); }
public void GenerateMesh() { mf = GetComponent <MeshFilter>(); mf.mesh = null; if (mf.sharedMesh == null) { mf.sharedMesh = new Mesh(); } mesh = mf.sharedMesh; s = Parent._Spline; if (shape == null) { shape = new ExtrudeShape(); } shape.verts = verts.ToArray(); shape.normals = new Vector2[GetVertCount()]; shape.uCoords = new float[GetVertCount()]; float uLength = 0; float[] pointPos = new float[GetVertCount()]; pointPos[0] = 0; for (int i = 1; i < verts.Count; i++) { uLength += Vector2.Distance(verts[i - 1], verts[i]); pointPos[i] = uLength; } for (int i = 0; i < GetVertCount(); i++) { shape.uCoords[i] = pointPos[i] / uLength; float dx, dy; Vector2 normal; if (i == 0) { dx = shape.verts[1].x - shape.verts[0].x; dy = shape.verts[1].y - shape.verts[0].y; normal = new Vector2(dy, -dx); shape.normals[i] = BezierUtil.Cross(new Vector2(dx, dy), normal) > 0 ? normal : new Vector2(-dy, dx); } else if (i == GetVertCount() - 1) { dx = shape.verts[0].x - shape.verts[i].x; dy = shape.verts[0].y - shape.verts[i].y; normal = new Vector2(dy, -dx); } else { dx = shape.verts[i + 1].x - shape.verts[i].x; dy = shape.verts[i + 1].y - shape.verts[i].y; normal = new Vector2(dy, -dx); } normal = BezierUtil.Cross(new Vector2(dy, dx), normal) > 0 ? normal : new Vector2(-dy, dx); shape.normals[i] = normal.normalized; //print(string.Format("{0}:{1}", i, normal.normalized)); } float[] samples = BezierUtil.GenerateSamples(s.curvePoints.ToArray()); if (s != null) { OrientedPoint[] op = new OrientedPoint[s.curvePoints.Count]; string debug = ""; for (int i = 0; i < op.Length; i++) { //op[i] = BezierUtil.GetOrientedPoint(s.curvePoints.ToArray(), ((float)i / (float)op.Length), samples); op[i] = new OrientedPoint(s.curvePoints[i], Quaternion.identity, samples.Sample(((float)i / (float)op.Length))); //debug += " " + op[i].vCoordinate; } //Debug.Log(debug); BezierUtil.Extrude(ref mesh, shape, op); //mesh.RecalculateNormals(); } else { Debug.Log("no s"); } }
public override void Extrude() { if (invisible) { for (int i = 0; i < splines.Count; ++i) { splines[i].gameObject.GetComponent<MeshCollider>().sharedMesh = null; splines[i].gameObject.GetComponent<MeshFilter>().sharedMesh = null; } return; } if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } for (int i = 0; i < splines.Count; ++i) { splines[i].Extrude(meshes[i], extrudeShape); } }
public void Load() { if(File.Exists(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve")) { ClearCurve(); BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Open(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve", FileMode.Open); CurveData data = (CurveData)bf.Deserialize(file); file.Close(); if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } Node previousNode = null; for (int i = 0; i < data.nodesData.Length; ++i) { // Create Node Node node = CreateNode(transform.position, transform.rotation); node.Load(data.nodesData[i]); // If not the first, create a spline with the previous one if (previousNode != null) { BezierSpline spline = CreateSpline(previousNode, node); spline.SetData(data.splinesData[i - 1]); spline.Extrude(meshes[i - 1], extrudeShape); } previousNode = node; } this.closed = data.closed; if(closed) { BezierSpline spline = CreateSpline(nodes[nodes.Count-1], nodes[0]); spline.Extrude(meshes[meshes.Count-1], extrudeShape); } this.invisible = data.invisible; } else { Debug.Assert(true, "Data file not found"); } }
private void Extrude(Mesh mesh, ExtrudeShape shape, OrientedPoint[] path) { int vertsInShape = shape.verts.Length; int segments = path.Length - 1; int edgeLoops = path.Length; int vertCount = vertsInShape * edgeLoops; int triCount = shape.lines.Length * segments; int triIndexCount = triCount * 3; var triangleIndices = new int[triIndexCount]; var vertices = new Vector3[vertCount]; var normals = new Vector3[vertCount]; var uvs = new Vector2[vertCount]; float totalLength = 0; float distanceCovered = 0; for (int i = 0; i < path.Length - 1; i++) { var d = Vector3.Distance(path[i].position, path[i + 1].position); totalLength += d; } for (int i = 0; i < path.Length; i++) { int offset = i * vertsInShape; if (i > 0) { var d = Vector3.Distance(path[i].position, path[i - 1].position); distanceCovered += d; } float v = distanceCovered / totalLength; for (int j = 0; j < vertsInShape; j++) { int id = offset + j; vertices[id] = path[i].LocalToWorld(shape.verts[j].point); normals[id] = path[i].LocalToWorldDirection(shape.verts[j].normal); uvs[id] = new Vector2(shape.verts[j].uCoord, v); } } 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] = c; ti++; triangleIndices[ti] = b; ti++; triangleIndices[ti] = a; ti++; triangleIndices[ti] = a; ti++; triangleIndices[ti] = d; ti++; triangleIndices[ti] = c; ti++; } } mesh.Clear(); mesh.vertices = vertices; mesh.normals = normals; mesh.uv = uvs; mesh.triangles = triangleIndices; }
public void Load() { if (File.Exists(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve")) { ClearCurve(); BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Open(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + ".curve", FileMode.Open); BifurcationData data = (BifurcationData)bf.Deserialize(file); file.Close(); if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } for (int i = 0; i < data.nodesData.Length; ++i) { // Create Nodes Node node = CreateNode(transform.position, transform.rotation); node.Load(data.nodesData[i]); } planeX = data.planeX; // Create Splines CreateSpline(nodes[0], nodes[1]).ExtrudeSide(meshes[0], extrudeShape, "right", planeX); CreateSpline(nodes[0], nodes[2]).ExtrudeSide(meshes[1], extrudeShape, "left", planeX); splines[0].SetData(data.splinesData[0]); splines[1].SetData(data.splinesData[1]); } else { //Debug.Assert(true, "Data file not found"); //Create(); } }
public override void Extrude() { if (extrudeShape == null) { extrudeShape = new ExtrudeShape(); } splines[0].ExtrudeSide(meshes[0], extrudeShape, "right", planeX); splines[1].ExtrudeSide(meshes[1], extrudeShape, "left", planeX); }
/// <summary> /// Procedural generates a mesh from the edge spline /// Used to simulate roads /// </summary> private void OnGenerateMesh() { if (GUILayout.Button("Generate Mesh")) { Vector2[] verts = new Vector2[] { new Vector2(-0.5f, 0), new Vector2(0, 0), new Vector2(0.5f, 0) }; Vector2[] norms = new Vector2[] { Vector2.up, Vector2.up, Vector2.up }; float[] uCoords = new float[] { 0, 1, 0 }; ExtrudeShape shape = new ExtrudeShape(verts, norms, uCoords); foreach (Edge edge in map.EdgeList) { List <OrientedPoint> path = new List <OrientedPoint>(); MeshFilter mf = edge.gameObject.GetComponent <MeshFilter>(); if (mf.sharedMesh == null) { mf.sharedMesh = new Mesh(); } Mesh mesh = mf.sharedMesh; foreach (OrientedPoint p in edge.GeneratePath(1000f)) { path.Add(p); } edge.Extrude(mesh, shape, path.ToArray()); } } EditorGUILayout.Space(); if (GUILayout.Button("Clear Mesh")) { foreach (Edge edge in map.EdgeList) { MeshFilter mf = edge.gameObject.GetComponent <MeshFilter>(); if (mf.sharedMesh == null) { mf.sharedMesh = new Mesh(); } Mesh mesh = mf.sharedMesh; mesh.Clear(); } } }
public void ReDrawMesh() { Vector3[] points = new Vector3[] { p1, p2, p3, p4 }; BezierCurve curve = new BezierCurve(points, rotationP1, rotationP4); Mesh mesh = new Mesh(); ExtrudeShape shape = new ExtrudeShape(); float steps = 6; float width = 10f; float step = width / (steps - 1); float halfWidth = width / 2f; shape.verts = new Vector2[] { new Vector2(0 * step - halfWidth, 0), new Vector2(1 * step - halfWidth, 0), new Vector2(2 * step - halfWidth, 0), new Vector2(3 * step - halfWidth, 0), new Vector2(4 * step - halfWidth, 0), new Vector2(5 * step - halfWidth, 0), new Vector2(5 * step - halfWidth, -1), new Vector2(-halfWidth, -1), new Vector2(-halfWidth, 0) }; shape.normals = new Vector2[] { new Vector2(0, 1), new Vector2(0, 1), new Vector2(0, 1), new Vector2(0, 1), new Vector2(0, 1), new Vector2(0, 1), new Vector2(0, 1), new Vector2(0, 1), new Vector2(0, 1) }; shape.uCoords = new float[] { 0.03f, 0.20f, 0.40f, 0.60f, 0.80f, 0.97f, 0.95f, 0.97f, 0.95f }; m_path = curve.GeneratePath(segments).ToArray(); curve.Extrude(mesh, shape, m_path); MeshFilter mf = GetComponent <MeshFilter>(); mf.sharedMesh = mesh; }
public void ExtrudeSide(Mesh mesh, ExtrudeShape shape, string side, float planeX) { Vector3 position = new Vector3(planeX, 0, 0); Vector3 normal = new Vector3(1, 0, 0); Extrude(mesh, shape); mesh = gameObject.GetComponent <MeshFilter>().sharedMesh; int[] triangleIndices = mesh.GetIndices(0); //new int[triIndexCount]; Vector3[] vertices = mesh.vertices; Vector3[] normals = mesh.normals; List <Vector2> uvs = new List <Vector2>(); mesh.GetUVs(0, uvs); //new Vector2[vertCount]; List <Vector3> newVertices = new List <Vector3>(); List <Vector3> newNormals = new List <Vector3>(); List <Vector2> newUVs = new List <Vector2>(); List <int> newIndices = new List <int>(); // We will cut the mesh with a plane. // for each triangle (looking at indices) process if one vertex on the other side of the plane for (int i = 0; i < triangleIndices.Length; i = i + 3) { List <int> side1 = new List <int>(); List <int> side2 = new List <int>(); if (splineCoordsToNode(vertices[triangleIndices[i]]).x > planeX) { side2.Add(triangleIndices[i]); } else { side1.Add(triangleIndices[i]); } if (splineCoordsToNode(vertices[triangleIndices[i + 1]]).x > planeX) { side2.Add(triangleIndices[i + 1]); } else { side1.Add(triangleIndices[i + 1]); } if (splineCoordsToNode(vertices[triangleIndices[i + 2]]).x > planeX) { side2.Add(triangleIndices[i + 2]); } else { side1.Add(triangleIndices[i + 2]); } // Depending on the side evaluated determine wich vertices are in and which out List <int> inside; List <int> outside; if (side == "left") {// left inside = side1; outside = side2; } else {// right inside = side2; outside = side1; } // Cases if (inside.Count == 3) {// all vertices on the correct side continue; } else { // discard triangle triangleIndices[i] = triangleIndices[i + 1] = triangleIndices[i + 2] = 0; if (outside.Count == 2) {// case 1: 1 vertices in, 2 out. Create 2 more vertices and one tri. Vector3 v1 = Intersection(vertices[inside[0]], vertices[outside[0]], normal, position); Vector3 v2 = Intersection(vertices[inside[0]], vertices[outside[1]], normal, position); newVertices.Add(v1); newVertices.Add(v2); newNormals.Add(new Vector3(0, 1, 0)); newNormals.Add(new Vector3(0, 1, 0)); newUVs.Add(new Vector3(0, 0, 0)); newUVs.Add(new Vector3(0, 0, 0)); if (side == "right" || (vertices[outside[0]].z > vertices[outside[1]].z)) { newIndices.Add(inside[0]); newIndices.Add(vertices.Length + newVertices.IndexOf(v1)); newIndices.Add(vertices.Length + newVertices.IndexOf(v2)); } else { newIndices.Add(vertices.Length + newVertices.IndexOf(v1)); newIndices.Add(inside[0]); newIndices.Add(vertices.Length + newVertices.IndexOf(v2)); } } else if (outside.Count == 1) {// case 2: 2 vertices in, 1 out. create 2 more vertices and 2 tris. Vector3 v1 = Intersection(vertices[inside[0]], vertices[outside[0]], normal, position); Vector3 v2 = Intersection(vertices[inside[1]], vertices[outside[0]], normal, position); newVertices.Add(v1); newVertices.Add(v2); newNormals.Add(new Vector3(0, 1, 0)); newNormals.Add(new Vector3(0, 1, 0)); newUVs.Add(new Vector3(0, 0, 0)); newUVs.Add(new Vector3(0, 0, 0)); if (side == "right" || (vertices[inside[0]].z > vertices[inside[1]].z)) { newIndices.Add(inside[0]); newIndices.Add(vertices.Length + newVertices.IndexOf(v1)); newIndices.Add(vertices.Length + newVertices.IndexOf(v2)); newIndices.Add(inside[1]); newIndices.Add(inside[0]); newIndices.Add(vertices.Length + newVertices.IndexOf(v2)); } else { newIndices.Add(vertices.Length + newVertices.IndexOf(v1)); newIndices.Add(inside[0]); newIndices.Add(vertices.Length + newVertices.IndexOf(v2)); newIndices.Add(inside[0]); newIndices.Add(inside[1]); newIndices.Add(vertices.Length + newVertices.IndexOf(v2)); } } } } vertices = Concat <Vector3>(vertices, newVertices.ToArray()); normals = Concat <Vector3>(normals, newNormals.ToArray()); Vector2[] muvs = Concat <Vector2>(uvs.ToArray(), newUVs.ToArray()); triangleIndices = Concat <int>(triangleIndices, newIndices.ToArray()); mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangleIndices; mesh.normals = normals; mesh.uv = muvs; //mesh.RecalculateNormals(); gameObject.GetComponent <MeshFilter>().sharedMesh = mesh; gameObject.GetComponent <MeshCollider>().sharedMesh = mesh; }
void GenerateMesh() { ExtrudeShape shape = new ExtrudeShape(); Vertex2D[] verts = new Vertex2D[points.Length]; for (int i = 0; i < points.Length; ++i) { verts[i] = new Vertex2D(); verts[i].point = points[i].position; if (i == points.Length - 1) { Vector2 direction = points[i].position - points[i - 1].position; verts[i].normal = new Vector2(-direction.y, direction.x); } else { Vector2 direction = points[i + 1].position - points[i].position; verts[i].normal = new Vector2(-direction.y, direction.x); } verts[i].uCoord = 1.0f * i / (points.Length - 1); } int[] lines = new int[(points.Length - 1) * 2]; for (int i = 0; i < points.Length - 1; ++i) { lines[i * 2] = i; lines[i * 2 + 1] = i + 1; } shape.vert2Ds = verts; shape.lines = lines; Vector3[] controlPoints = { p0.position, p1.position, p2.position, p3.position, }; OrientedPoint[] path = new OrientedPoint[segmentCount + 1]; Vector3 lastPoint = Vector3.zero; for (int i = 0; i <= segmentCount; ++i) { float t = (float)i / segmentCount; Vector3 position = CubicBezier3D.GetPoint(controlPoints, t); Quaternion rotation = CubicBezier3D.GetOrientation3D(controlPoints, t, Vector3.up); path[i] = new OrientedPoint(position, rotation); Vector3 normal = CubicBezier3D.GetNormal3D(controlPoints, t, Vector3.up); //debug info // Debug.DrawLine(position, position + normal * 5, Color.blue); if (i != 0) { Debug.DrawLine(lastPoint, position, Color.green); } lastPoint = position; } arr = new float[2]; CalcLengthTableInto(arr, controlPoints); Extrude(mesh, shape, path); }
public void ExtrudeSideOld(Mesh mesh, ExtrudeShape shape, string side) { if (shape == null) { shape = new ExtrudeShape(); } int factor = 1; if (side == "left") { factor = -1; } float splineLength = GetLength(); shape.Initialize(1, curve.horizontalDivisions); int divisions = (int)(curve.divisionsPerCurve * splineLength / curve.trackWidth / 20); if (divisions < 1) { divisions = 1; } int vertsInShape = shape.verts.Length; List <int> triangleIndices = new List <int>(); //new int[triIndexCount]; List <Vector3> vertices = new List <Vector3>(); //new Vector3[vertCount]; List <Vector3> normals = new List <Vector3>(); //new Vector3[vertCount]; List <Vector2> uvs = new List <Vector2>(); //new Vector2[vertCount]; /* * Mesh generation code */ #region meshGeneration float divisionLength = 1.0f / (float)divisions; orientedPoints = new OrientedPoint[divisions + 1]; // Create vertices for (int i = 0; i <= divisions; ++i) {// for each edgeLoop float t = i * divisionLength; Vector3 up = Vector3.Lerp(startNode.transform.up, endNode.transform.up, t); float curvature = Mathf.Lerp(startNode.rightCurvature, endNode.rightCurvature, t); float width = (curve.trackWidth + Mathf.Lerp(startNode.trackWidthModifier, endNode.trackWidthModifier, t)) / 2; Matrix4x4 scale = Matrix4x4.Scale(new Vector3(width, width, width)); // Initialize oriented point orientedPoints[i].position = transform.InverseTransformPoint(GetPoint(t)); orientedPoints[i].rotation = Quaternion.Inverse(transform.rotation) * (GetOrientation(t, up)); orientedPoints[i].scale = scale; for (int j = 0; j < vertsInShape; ++j) {// for each vertex in the shape Vector2 vertex = Vector2.Lerp(shape.verts[j], shape.curvedVerts[j], curvature); vertex.x *= factor; Vector2 normal = Vector2.Lerp(shape.normals[j], shape.curvedNormals[j], curvature); vertices.Add(orientedPoints[i].LocalToWorld(vertex)); normals.Add(orientedPoints[i].LocalToWorldDirection(normal)); // u is based on the 2D shape, and v is based on the distance along the curve uvs.Add(new Vector2(shape.us[j], t * splineLength / width)); } } // Create triangles for (int j = 0; j < divisions; ++j) {// for each division in the curve int offset = shape.verts.Length * j; for (int k = 0; k < shape.lines.Length; k = k + 2) {//for each 2d line in the shape if (side == "right") { // triangle 1 triangleIndices.Add(shape.lines[k + 1] + offset); triangleIndices.Add(shape.lines[k] + offset); triangleIndices.Add(shape.lines[k] + offset + shape.verts.Length); // triangle 2 triangleIndices.Add(shape.lines[k + 1] + offset); triangleIndices.Add(shape.lines[k] + offset + shape.verts.Length); triangleIndices.Add(shape.lines[k + 1] + offset + shape.verts.Length); } else { // triangle 1 triangleIndices.Add(shape.lines[k] + offset); triangleIndices.Add(shape.lines[k + 1] + offset); triangleIndices.Add(shape.lines[k] + offset + shape.verts.Length); // triangle 2 triangleIndices.Add(shape.lines[k] + offset + shape.verts.Length); triangleIndices.Add(shape.lines[k + 1] + offset); triangleIndices.Add(shape.lines[k + 1] + offset + shape.verts.Length); } } } mesh.Clear(); mesh.vertices = vertices.ToArray(); mesh.triangles = triangleIndices.ToArray(); mesh.normals = normals.ToArray(); mesh.uv = uvs.ToArray(); #endregion mesh.RecalculateNormals(); gameObject.GetComponent <MeshFilter>().mesh = mesh; gameObject.GetComponent <MeshCollider>().sharedMesh = mesh; }
public override void OnInspectorGUI() { extrudeShape = target as ExtrudeShape; DrawDefaultInspector(); }