// Start is called before the first frame update void Start() { MeshBuilder meshBuilder = new MeshBuilder(); Vector3 upDir = Vector3.up * m_Heigth; Vector3 rightDir = Vector3.right * m_Width; Vector3 forwardDir = Vector3.forward * m_Length; Vector3 farCorner = (upDir + rightDir + forwardDir) / 2; Vector3 nearCorner = -farCorner; BuildQuadV2(meshBuilder, nearCorner, forwardDir, rightDir); BuildQuadV2(meshBuilder, nearCorner, rightDir, upDir); BuildQuadV2(meshBuilder, nearCorner, upDir, forwardDir); BuildQuadV2(meshBuilder, farCorner, -rightDir, -forwardDir); BuildQuadV2(meshBuilder, farCorner, -upDir, -rightDir); BuildQuadV2(meshBuilder, farCorner, -forwardDir, -upDir); Mesh mesh = meshBuilder.CreateMesh(); // Get meshFilter we working with. Create mesh in this object MeshFilter meshFilter = gameObject.GetComponent <MeshFilter>(); if (meshFilter != null) { // Finalize mesh and its creation meshFilter.mesh = meshBuilder.CreateMesh(); // Temporary auto-normals generator Unity function } }
//public virtual Mesh BuildMesh() { // return new Mesh(); //} public Mesh BuildMesh(GizmoMeshShape shape, GizmoType type) { // SIMPLE CUBE! MeshBuilder meshBuilder = new MeshBuilder(); if(shape == GizmoMeshShape.Cube) { meshBuilder = EditorGizmoMeshShapes.GetCubeMesh(meshBuilder); //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.back, Vector3.up); // LEFT //BuildQuad(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), Vector3.back, Vector3.right); // TOP //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), Vector3.left, Vector3.up); // BACK //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), Vector3.forward, Vector3.up); // RIGHT //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.right, Vector3.back); // BOTTOM if(type != GizmoType.none) { collider = this.gameObject.AddComponent<BoxCollider>(); collider.isTrigger = true; } if (gizmoMaterial == null) { gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo")); //gizmoMaterial.renderQueue = 4000; } GetComponent<MeshRenderer>().material = gizmoMaterial; } else if(shape == GizmoMeshShape.Arrow) { EditorGizmoMeshShapes.GetArrowMesh(meshBuilder); if (type != GizmoType.none) { MeshCollider meshCollider = this.gameObject.AddComponent<MeshCollider>(); meshCollider.sharedMesh = meshBuilder.CreateMesh(); collider = meshCollider; //collider.isTrigger = true; } if (gizmoMaterial == null) { gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo")); //gizmoMaterial.renderQueue = 4000; } GetComponent<MeshRenderer>().material = gizmoMaterial; } else if (shape == GizmoMeshShape.OmniArrow) { EditorGizmoMeshShapes.GetOmniArrowMesh(meshBuilder); if (type != GizmoType.none) { MeshCollider meshCollider = this.gameObject.AddComponent<MeshCollider>(); meshCollider.sharedMesh = meshBuilder.CreateMesh(); collider = meshCollider; } if (gizmoMaterial == null) { gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo")); //gizmoMaterial.renderQueue = 4000; } GetComponent<MeshRenderer>().material = gizmoMaterial; } else { Debug.Log("No Gizmo Shape!!!"); } return meshBuilder.CreateMesh(); }
GameObject GenerateObject(MeshBuilder meshBuilder, string objectName) { GameObject go; // Object to be created or modified Transform to = transform.FindDeepChild(objectName); // Verify if object already exists if (to == null) { go = new GameObject(objectName); go.AddComponent <MeshFilter> ().mesh = meshBuilder.CreateMesh(); go.AddComponent <MeshRenderer> ().material = trackMaterial; } else { go = to.gameObject; go.GetComponent <MeshFilter> ().mesh = meshBuilder.CreateMesh(); go.GetComponent <MeshRenderer> ().material = trackMaterial; } return(go); }
void GenerateGridMesh() { for (int i = 0; i <= SegmentCount; i++) { float z = Length * i; float v = (1.0f / SegmentCount * TilingY) * i; for (int j = 0; j <= SegmentCount; j++) { float x = Width * j; float u = (1.0f / SegmentCount * TilingX) * j; Vector3 offset = new Vector3(x, Random.Range(0f, Height), z); Vector2 uv = new Vector2(u, v); bool buildTriangles = i > 0 && j > 0; BuildQuadForGrid(offset, uv, buildTriangles, SegmentCount + 1); } } Mesh mesh = meshBuilder.CreateMesh(); mesh.RecalculateNormals(); MeshFilter filter = GetComponent <MeshFilter>(); filter.sharedMesh = mesh; GetComponent <Renderer>().material = MeshMaterial; }
void BuildMesh() { //If the MeshFilter exists, attach the new mesh to it. //Assuming the GameObject also has a renderer attached, our new mesh will now be visible in the scene. Mesh mesh = meshBuilder.CreateMesh(); filter = GetComponent <MeshFilter>(); meshCollider = GetComponent <MeshCollider>(); filter.sharedMesh = mesh; meshCollider.sharedMesh = mesh; }
//BuildQuad with vectors public static Mesh BuildQuad(MeshBuilder meshBuilder, Vector3 offset, Vector3 widthDir, Vector3 lengthDir) { Vector3 normal = Vector3.Cross(lengthDir, widthDir).normalized; meshBuilder.Vertices.Add(offset); meshBuilder.UVs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDir); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDir + widthDir); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + widthDir); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(normal); int baseIndex = meshBuilder.Vertices.Count - 4; meshBuilder.AddTriangle(baseIndex, baseIndex + 1, baseIndex + 2); meshBuilder.AddTriangle(baseIndex, baseIndex + 2, baseIndex + 3); Mesh _CreatedMesh = meshBuilder.CreateMesh(); _CreatedMesh.RecalculateNormals(); return _CreatedMesh; }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); ////one-segment cylinder (build two rings, one at the bottom and one at the top): //BuildRing(meshBuilder, m_RadialSegmentCount, Vector3.zero, m_Radius, 0.0f, false); //BuildRing(meshBuilder, m_RadialSegmentCount, Vector3.up * m_Height, m_Radius, 1.0f, true); //multi-segment cylinder: float heightInc = m_Height / m_HeightSegmentCount; for (int i = 0; i <= m_HeightSegmentCount; i++) { //centre position of this ring: Vector3 centrePos = Vector3.up * heightInc * i; //V coordinate is based on height: float v = (float)i / m_HeightSegmentCount; BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, m_Radius, v, i > 0); } ////caps: //BuildCap(meshBuilder, Vector3.zero, true); //BuildCap(meshBuilder, Vector3.up * m_Height, false); return meshBuilder.CreateMesh(); }
public void PathMoved() { if (pathFollower.currentTargetIndex > 0 && currentChunkRadius < ChunkRadius) { currentChunkRadius += ChunkRadiusIncreaseSize; } var nbPointsInSegment = RadialSegmentCount + 1; if (meshNbChunk > 1) { meshBuilder.Vertices.RemoveRange(meshBuilder.Vertices.Count - nbPointsInSegment, nbPointsInSegment); meshBuilder.UVs.RemoveRange(meshBuilder.Vertices.Count - nbPointsInSegment, nbPointsInSegment); meshBuilder.Triangles.RemoveRange(meshBuilder.Triangles.Count - (nbPointsInSegment * 6 - 6), nbPointsInSegment * 6 - 6); } BuildRing(meshBuilder, RadialSegmentCount, currentChunkRadius, meshNbChunk > 0); if (meshNbChunk > 0) { pathFollower.goCenter.transform.Translate(Vector3.forward * pathFollower.SizeStep * 4); BuildRing(meshBuilder, RadialSegmentCount, 0.0f, true); pathFollower.goCenter.transform.Translate(-Vector3.forward * pathFollower.SizeStep * 4); } Mesh mesh = meshBuilder.CreateMesh(); goMesh.GetComponent <MeshFilter>().mesh = mesh; // For collision // goMesh.GetComponent<MeshCollider>().sharedMesh = mesh; ++meshNbChunk; }
void Start() { int step = 1; int patchSize = 50; Vector3 startPosition = new Vector3(); for (int y = 0; y <= patchSize; y++) { for (int x = 0; x <= patchSize; x++) { Vector3 offset = startPosition + (Vector3.right * step * x) + (Vector3.up * step * y); bool buildTriangles = x > 0 && y > 0; Vector2 uv = new Vector2(); bool swapOrder = x % 2 == y % 2 ? true: false; ProceduralQuad.BuildQuadForGrid(_meshBuilder, offset, uv, buildTriangles, patchSize + 1, swapOrder); } } mesh = _meshBuilder.CreateMesh(); MeshProvider mp = new MeshProvider(32); mesh = mp.GetStandardMesh(); mesh1 = Instantiate(PlanetMeshPrefab) as GameObject; mesh2 = Instantiate(PlanetMeshPrefab) as GameObject; go = new GameObject(); go.AddComponent("MeshFilter"); go.AddComponent("MeshRenderer"); // go.transform.Translate (Vector3.right * 50); // mesh1.transform.Translate (Vector3.right * 100); }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //height segments need to be half m_RadialSegmentCount for the sphere to be even horizontally and vertically: int heightSegmentCount = m_RadialSegmentCount / 2; //the angle increment per height segment: float angleInc = Mathf.PI / heightSegmentCount; for (int i = 0; i <= heightSegmentCount; i++) { Vector3 centrePos = Vector3.zero; //calculate a height offset and radius based on a vertical circle calculation: centrePos.y = -Mathf.Cos(angleInc * i) * m_Radius; float radius = Mathf.Sin(angleInc * i) * m_Radius; float v = (float)i / heightSegmentCount; //build the ring: BuildRingForSphere(meshBuilder, m_RadialSegmentCount, centrePos, radius, v, i > 0); } return meshBuilder.CreateMesh(); }
public void TestWorldRenderer() { var game = new LocalGame(); var ent = new Engine.WorldRendering.Entity(); var mBuilder = new MeshBuilder(); mBuilder.AddSphere(12, 1); ent.Mesh = mBuilder.CreateMesh(); var time = 0f; game .AddSimulator(new BasicSimulator(delegate { time += TW.Graphics.Elapsed; ent.Mesh = mesh; ent.WorldMatrix = Matrix.Translation(Vector3.UnitX * time); })) .AddSimulator(new WorldRenderingSimulator()); game.Run(); }
// Update is called once per frame void Update() { MeshFilter meshFilter = this.GetComponent <MeshFilter>(); MeshBuilder meshBuilder = new MeshBuilder(subMeshSize); //Add Points //Adjust the angle of the triangle Vector3 top = new Vector3(0, pyramidSize, 0); Vector3 base0 = Quaternion.AngleAxis(0f, Vector3.up) * Vector3.forward * pyramidSize; Vector3 base1 = Quaternion.AngleAxis(240f, Vector3.up) * Vector3.forward * pyramidSize; Vector3 base2 = Quaternion.AngleAxis(120f, Vector3.up) * Vector3.forward * pyramidSize; //Build the triangles for our pyramid meshBuilder.BuildTriangle(base0, base1, base2, 0); meshBuilder.BuildTriangle(base1, base0, top, 1); meshBuilder.BuildTriangle(base2, top, base0, 2); meshBuilder.BuildTriangle(top, base2, base1, 3); meshFilter.mesh = meshBuilder.CreateMesh(); MeshRenderer meshRenderer = this.GetComponent <MeshRenderer>(); meshRenderer.materials = MaterialsList().ToArray(); }
private void Update() { var mb = new MeshBuilder(6); var prevShape = TranslateShape( path[path.Length - 1].transform.position, (path[0].transform.position - path[path.Length - 1].transform.position).normalized, pathShape.shape ); for (var i = 0; i < path.Length; ++i) { var nextShape = TranslateShape( path[i].transform.position, (path[(i + 1) % path.Length].transform.position - path[i].transform.position).normalized, pathShape.shape ); for (var j = 0; j < nextShape.Length - 1; ++j) { mb.BuildTriangle(prevShape[j], nextShape[j], nextShape[j + 1], 0); mb.BuildTriangle(prevShape[j + 1], prevShape[j], nextShape[j + 1], 0); } prevShape = nextShape; } _meshFilter.mesh = mb.CreateMesh(); }
public override Mesh BuildMesh() { MeshBuilder meshBuilder = new MeshBuilder(); float heightInc = m_Height / m_HeightSegmentCount; //calculate the slope of the cylinder based on the height and difference between radii: Vector2 slope = new Vector2(m_RadiusEnd - m_RadiusStart, m_Height); slope.Normalize(); //build the rings: for (int i = 0; i <= m_HeightSegmentCount; i++) { //centre position of this ring: Vector3 centrePos = Vector3.up * heightInc * i; //V coordinate is based on height: float v = (float)i / m_HeightSegmentCount; //interpolate between the radii: float radius = Mathf.Lerp(m_RadiusStart, m_RadiusEnd, (float)i / m_HeightSegmentCount); //build the ring: BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, radius, v, i > 0, Quaternion.identity, slope); } return(meshBuilder.CreateMesh()); }
public void BeginBuild(bool reverse = true) { meshBuilder = GetComponent<MeshBuilder>(); filter = GetComponent<MeshFilter>(); for (int i = 0; i <= xVal; i++)//xVal { float z = m_Length * i; float v = (1.0f / xVal) * i;//xVal for (int j = 0; j <= zVal; j++)//zVal { float x = m_Width * j; float u = (1.0f / zVal) * j;//zval Vector3 offset = new Vector3(x, 0, z); Vector2 uv = new Vector2(u, v); bool buildTriangles = i > 0 && j > 0; BuildQuadForGrid(meshBuilder, offset, uv, buildTriangles, zVal + 1);//zval } } if (filter != null) { filter.sharedMesh = meshBuilder.CreateMesh(reverse); //Debug.Log(filter.sharedMesh.vertexCount + " Vertices."); } }
public void BuildPlane() { MeshBuilder meshBuilder = new MeshBuilder(); //Set up the vertices and triangles: meshBuilder.Vertices.Add(new Vector3(0.0f, 0.0f, 0.0f)); meshBuilder.UVs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(0.0f, 0.0f, length)); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(width, 0.0f, length)); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(width, 0.0f, 0.0f)); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.AddTriangle(0, 1, 2); meshBuilder.AddTriangle(0, 2, 3); //Create the mesh: MeshFilter filter = GetComponent <MeshFilter>(); if (filter != null) { filter.sharedMesh = meshBuilder.CreateMesh(); } }
public override Mesh BuildMesh() { // SIMPLE PLANE! MeshBuilder meshBuilder = new MeshBuilder(); BuildQuad (meshBuilder, new Vector3(-0.5f, 0.0f, 0.5f), Vector3.back, Vector3.right); // TOP return meshBuilder.CreateMesh (); }
public void BeginBuild(bool reverse = true) { meshBuilder = GetComponent <MeshBuilder>(); filter = GetComponent <MeshFilter>(); for (int i = 0; i <= xVal; i++)//xVal { float z = m_Length * i; float v = (1.0f / xVal) * i; //xVal for (int j = 0; j <= zVal; j++) //zVal { float x = m_Width * j; float u = (1.0f / zVal) * j;//zval Vector3 offset = new Vector3(x, 0, z); Vector2 uv = new Vector2(u, v); bool buildTriangles = i > 0 && j > 0; BuildQuadForGrid(meshBuilder, offset, uv, buildTriangles, zVal + 1);//zval } } if (filter != null) { filter.sharedMesh = meshBuilder.CreateMesh(reverse); //Debug.Log(filter.sharedMesh.vertexCount + " Vertices."); } }
public void Generate(int chunkX, int chunkY, Map parent) { MeshFilter filter = this.gameObject.GetComponent<MeshFilter> (); if (filter == null) { filter = this.gameObject.AddComponent<MeshFilter> (); } MeshRenderer rend = this.gameObject.GetComponent<MeshRenderer> (); if (rend == null) { rend = this.gameObject.AddComponent<MeshRenderer> (); } rend.material = parent.mapMaterial; MeshBuilder meshBuilder = new MeshBuilder(); int startX = chunkX * 32; int startY = chunkY * 32; for (int i = startX; i < startX + 32; i++) { float xPos = TILE_SIZE * (i - startX); for (int j = startY; j < startY + 32; j++) { float yPos = TILE_SIZE * (j - startY); BuildTile(meshBuilder, new Vector3(xPos, 0, yPos), parent.getTile(i, j)); } } this.GetComponent<MeshFilter> ().sharedMesh = meshBuilder.CreateMesh (); this.transform.position = new Vector3(chunkX * Map.ChunkSize * TILE_SIZE, 0, chunkY * Map.ChunkSize * TILE_SIZE); }
public Mesh BuildLeaves() { PGTreeBase p = transform.parent.GetComponent("PGTreeBase") as PGTreeBase; PGTreeTrunkSimple trunk = transform.parent.GetComponentInChildren <PGTreeTrunkSimple>(); MeshBuilder meshBuilder = new MeshBuilder(); for (int i = 0; i < trunk.Leaves.Count - 1; i++) { for (int j = 0; j < p.m_leaves_per_branch; j++) { Vector3 offset = trunk.Leaves[i].position; Vector3 localOffset = new Vector3(0.0f, Mathf.Cos(p.m_stem_start_angle * Mathf.Deg2Rad), Mathf.Sin(p.m_stem_start_angle * Mathf.Deg2Rad)) * p.m_stem_length; Quaternion rotation = trunk.Leaves[i].rotation * Quaternion.Euler(0.0f, (360 * (float)j) / (float)p.m_leaves_per_branch, 0.0f); BuildLeaf(meshBuilder, offset, localOffset, rotation, p.m_leaf_length, p.m_leaf_width, p.m_leaf_length_rand, p.m_leaf_width_rand, p.m_leaf_length_segments, p.m_leaf_width_segments, p.m_leaf_bend, p.m_leaf_bend_rand, p.m_leaf_curl, p.m_leaf_curl_rand, p.m_leaf_twist, p.m_leaf_twist_rand, true, p.m_leaf_variation); //BuildLeaf(meshBuilder,offset,localOffset,rotation,p.m_leaf_length,p.m_leaf_width,p.m_leaf_length_rand,p.m_leaf_width_rand,p.m_leaf_length_segments,p.m_leaf_width_segments, // p.m_leaf_bend,p.m_leaf_bend_rand,p.m_leaf_curl,p.m_leaf_curl_rand,p.m_leaf_twist,p.m_leaf_twist_rand,true,p.m_leaf_variation); } } Mesh mesh = meshBuilder.CreateMesh(); mesh.RecalculateNormals(); return(mesh); }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //calculate directional vectors for all 3 dimensions of the cube: Vector3 upDir = Vector3.up * m_Height; Vector3 rightDir = Vector3.right * m_Width; Vector3 forwardDir = Vector3.forward * m_Length; //calculate the positions of two corners opposite each other on the cube: //positions that will place the pivot at the corner of the cube: Vector3 nearCorner = Vector3.zero; Vector3 farCorner = upDir + rightDir + forwardDir; ////positions that will place the pivot at the centre of the cube: //Vector3 farCorner = (upDir + rightDir + forwardDir) / 2; //Vector3 nearCorner = -farCorner; //build the 3 quads that originate from nearCorner: BuildQuad(meshBuilder, nearCorner, forwardDir, rightDir); BuildQuad(meshBuilder, nearCorner, rightDir, upDir); BuildQuad(meshBuilder, nearCorner, upDir, forwardDir); //build the 3 quads that originate from farCorner: BuildQuad(meshBuilder, farCorner, -rightDir, -forwardDir); BuildQuad(meshBuilder, farCorner, -upDir, -rightDir); BuildQuad(meshBuilder, farCorner, -forwardDir, -upDir); //initialise the Unity mesh and return it: return meshBuilder.CreateMesh(); }
public void TestOptimizeMeshManyParts() { var b = new MeshBuilder(); b.AddBox(new Vector3(0, 0, 0), new Vector3(1, 1, 1)); var partMesh = b.CreateMesh(); var unoptimized = new RAMMesh(); for (int i = 0; i < 1000; i++) { MeshBuilder.AppendMeshTo(partMesh, unoptimized, Matrix.Translation(i, 0, 0)); } var optimizer = new MeshOptimizer(); var watch = new Stopwatch(); watch.Start(); for (int i = 0; i < 10; i++) { var optimized = optimizer.CreateOptimized(unoptimized); Assert.AreEqual(1, optimized.GetCoreData().Parts.Count); } watch.Stop(); Console.WriteLine(watch.Elapsed.TotalMilliseconds / 10); }
public virtual void render() { m_meshBuilder = new MeshBuilder(); for (int i = 0; i <= m_segments_across; i++) { float z = (float)((m_height / m_segments_down) * i) - (float)(m_height) / 2.0f; float v = (1.0f / m_segments_across) * i; for (int j = 0; j <= m_segments_down; j++) { float x = (float)((m_width / m_segments_across) * j) - (float)(m_width) / 2.0f; float u = (1.0f / m_segments_down) * j; Vector3 offset = new Vector3(x, m_map.m_map[i * (m_segments_across + 1) + j], z); Vector2 uv = new Vector2(u, v); bool buildTriangles = i > 0 && j > 0; BuildQuadForGrid(m_meshBuilder, offset, uv, buildTriangles, m_segments_across + 1); } } // Create the mesh MeshFilter filter = GetComponent <MeshFilter>(); if (filter) { Mesh mesh = m_meshBuilder.CreateMesh(); mesh.RecalculateNormals(); filter.sharedMesh = mesh; } }
public void GenerateExtrusion() { MeshBuilder meshBuilder = new MeshBuilder(); meanPoint = Vector3.zero; for (int i = 0; i < clickedPoints.Count; i++) { meanPoint += clickedPoints[i]; } meanPoint = (1f / clickedPoints.Count) * meanPoint; int verticesCount = 0; int meanPointIndex = 0; extrusionLevel = 0.1f; Vector3 h = new Vector3(0f, 0.1f, 0f); meshBuilder.AddVertice(meanPoint + h); for (int i = 0; i < clickedPoints.Count; i++) { meshBuilder.AddVertice(clickedPoints[i] + h); meshBuilder.AddTriangle(i + 1, meanPointIndex, 1 + ((i + 1) % clickedPoints.Count)); } meshBuilder.AddVertice(meanPoint); meanPointIndex = meshBuilder.Vertices.Count; int a, b, c, d; for (int i = 0; i < clickedPoints.Count; i++) { meshBuilder.AddVertice(clickedPoints[i]); a = i + 1; b = 1 + ((i + 1) % clickedPoints.Count); c = clickedPoints.Count + i + 2;; d = clickedPoints.Count + 2 + ((i + 1) % clickedPoints.Count); meshBuilder.AddTriangle(c, meanPointIndex, d); meshBuilder.AddTriangle(a, d, c); meshBuilder.AddTriangle(a, b, d); } mesh = meshBuilder.CreateMesh(); GameObject go = new GameObject("MeshObject"); meshFilter = go.AddComponent <MeshFilter>(); MeshRenderer meshRenderer = go.AddComponent <MeshRenderer>(); meshFilter.mesh = mesh; meshRenderer.material = meshMaterial; editMesh = true; // clickedPoints.Clear(); }
public void Plane() { MeshFilter meshFilter = this.GetComponent <MeshFilter>(); MeshBuilder meshBuilder = new MeshBuilder(materialsList.Count); Vector3[,] points = new Vector3[width, height]; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { points[x, y] = new Vector3(cellSize * x, 0, cellSize * y); } } for (int x = 0; x < width - 1; x++) { for (int y = 0; y < height - 1; y++) { Vector3 br = points[x, y]; Vector3 bl = points[x + 1, y]; Vector3 tr = points[x, y + 1]; Vector3 tl = points[x + 1, y + 1]; meshBuilder.BuildTriangle(bl, tr, tl, materialUsed); meshBuilder.BuildTriangle(bl, br, tr, materialUsed); } } meshFilter.mesh = meshBuilder.CreateMesh(); MeshRenderer meshRenderer = this.GetComponent <MeshRenderer>(); meshRenderer.materials = materialsList.ToArray(); }
public static SkinnedMeshRenderer CreateRenderer(Animator animator) { //var bodyBones = (HumanBodyBones[])Enum.GetValues(typeof(HumanBodyBones)); var bones = animator.transform.Traverse().ToList(); var builder = new MeshBuilder(); foreach (var headTail in Bones) { var head = animator.GetBoneTransform(headTail.Head); var tail = animator.GetBoneTransform(headTail.Tail); if (head != null && tail != null) { builder.AddBone(head.position, tail.position, bones.IndexOf(head)); } } var mesh = builder.CreateMesh(); mesh.bindposes = bones.Select(x => x.worldToLocalMatrix * animator.transform.localToWorldMatrix).ToArray(); var renderer = animator.gameObject.AddComponent <SkinnedMeshRenderer>(); renderer.bones = bones.ToArray(); renderer.rootBone = animator.GetBoneTransform(HumanBodyBones.Hips); renderer.sharedMesh = mesh; var bounds = new Bounds(Vector3.zero, mesh.bounds.size); renderer.localBounds = bounds; return(renderer); }
void GenerateCubeMesh() { MeshBuilder meshBuilder = new MeshBuilder(); Vector3 upDir = Vector3.up * meshHeight; Vector3 rightDir = Vector3.right * meshWidth; Vector3 forwardDir = Vector3.forward * meshLength; Vector3 nearCorner = -0.5f * (upDir + rightDir + forwardDir); Vector3 farCorner = nearCorner + upDir + rightDir + forwardDir; BuildQuad(meshBuilder, nearCorner, forwardDir, rightDir, sizeX, sizeZ); BuildQuad(meshBuilder, nearCorner, rightDir, upDir, sizeX, sizeZ); BuildQuad(meshBuilder, nearCorner, upDir, forwardDir, sizeX, sizeZ); BuildQuad(meshBuilder, farCorner, -rightDir, -forwardDir, sizeX, sizeZ); BuildQuad(meshBuilder, farCorner, -upDir, -rightDir, sizeX, sizeZ); BuildQuad(meshBuilder, farCorner, -forwardDir, -upDir, sizeX, sizeZ); GetComponent <MeshFilter> ().mesh = meshBuilder.CreateMesh(); //Invoke ("Spherify", 3f); PrepareForVerticesAnimation(); }
public override IMesh GetMesh(IVoxelHandle handle) { if (handle.Data.DataValue < datavalOffset) { handle.Data.DataValue = datavalOffset; } var index = (int)Math.Floor((handle.Data.DataValue - datavalOffset) / (float)batchSize); if (index > 4) { index = 4; } IMesh tmp; datavalueMeshes.TryGetValue(index, out tmp); if (tmp == null) { tmp = UtilityMeshes.CreateBoxColored(Color.FromArgb(255, 86, 86, 86), new Vector3(0.5f, 0.05f, 0.5f)); } var meshBuilder = new MeshBuilder(); meshBuilder.AddMesh(tmp, Matrix.Identity); var groundMesh = GetDefaultGroundMesh(handle.Data.Height, Color.FromArgb(255, 86, 86, 86)); if (groundMesh == null) { return(tmp); } meshBuilder.AddMesh(groundMesh, Matrix.Translation(0, -0.9f, 0)); return(meshBuilder.CreateMesh()); }
void BuildPlane(MeshBuilder meshBuilder, Vector3 offset) { bool buildTriangles = false; float seg_length = m_length / m_length_segments; float seg_width = m_width / m_width_segments; for (int row = 0; row <= m_width_segments; row++) { float v = (float)row / (float)m_width_segments; for (int col = 0; col <= m_length_segments; col++) { float u = (float)col / (float)m_length_segments; buildTriangles = (row != 0 && col != 0) ? true : false; BuildQuadForGrid(meshBuilder, new Vector3(row * seg_width, Random.Range(0, 0.0f), col * seg_length) + offset, new Vector2(u, v), buildTriangles); } } MeshFilter filter = GetComponent <MeshFilter>(); if (filter != null) { Mesh mesh = meshBuilder.CreateMesh(); mesh.RecalculateNormals(); filter.sharedMesh = mesh; } }
public override Mesh BuildMesh() { MeshBuilder meshBuilder = new MeshBuilder(); float heightInc = m_Height / m_HeightSegmentCount; //calculate the slope of the cylinder based on the height and difference between radii: Vector2 slope = new Vector2(m_RadiusEnd - m_RadiusStart, m_Height); slope.Normalize(); //build the rings: for (int i = 0; i <= m_HeightSegmentCount; i++) { //centre position of this ring: Vector3 centrePos = Vector3.up * heightInc * i; //V coordinate is based on height: float v = (float)i / m_HeightSegmentCount; //interpolate between the radii: float radius = Mathf.Lerp(m_RadiusStart, m_RadiusEnd, (float)i / m_HeightSegmentCount); //build the ring: BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, radius, v, i > 0, Quaternion.identity, slope); } return meshBuilder.CreateMesh(); }
private void CreateCube() { MeshBuilder meshBuilder = new MeshBuilder(); Vector3 upDir = Vector3.up * height; Vector3 rightDir = Vector3.right * width; Vector3 forwardDir = Vector3.forward * length; Vector3 nearCorner = Vector3.zero; Vector3 farCorner = upDir + rightDir + forwardDir; CreateQuad(meshBuilder, nearCorner, forwardDir, rightDir); CreateQuad(meshBuilder, nearCorner, rightDir, upDir); CreateQuad(meshBuilder, nearCorner, upDir, forwardDir); CreateQuad(meshBuilder, farCorner, -rightDir, -forwardDir); CreateQuad(meshBuilder, farCorner, -upDir, -rightDir); CreateQuad(meshBuilder, farCorner, -forwardDir, -upDir); Mesh mesh = meshBuilder.CreateMesh(); MeshFilter filter = GetComponent <MeshFilter>(); if (filter != null) { filter.sharedMesh = mesh; } }
// Update is called once per frame void Update() { //1. initialise mesh filter MeshFilter meshFilter = this.GetComponent <MeshFilter>(); //2. initialise mesh builder MeshBuilder meshBuilder = new MeshBuilder(1); //3. build our triangle Vector3 p0 = new Vector3(size.x, size.y, -size.z); Vector3 p1 = new Vector3(-size.x, size.y, -size.z); Vector3 p2 = new Vector3(-size.x, size.y, size.z); meshBuilder.BuildTriangle(p0, p1, p2, 0); //4. mesh filter's mesh to the one generated by the mesh builder meshFilter.mesh = meshBuilder.CreateMesh(); //5. initialise mesh renderer and assign material list to the mesh renderer's materials list MeshRenderer meshRenderer = this.GetComponent <MeshRenderer>(); AddMaterials(); meshRenderer.materials = materialList.ToArray(); }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); ////one-segment cylinder (build two rings, one at the bottom and one at the top): //BuildRing(meshBuilder, m_RadialSegmentCount, Vector3.zero, m_Radius, 0.0f, false); //BuildRing(meshBuilder, m_RadialSegmentCount, Vector3.up * m_Height, m_Radius, 1.0f, true); //multi-segment cylinder: float heightInc = m_Height / m_HeightSegmentCount; for (int i = 0; i <= m_HeightSegmentCount; i++) { //centre position of this ring: Vector3 centrePos = Vector3.up * heightInc * i; //V coordinate is based on height: float v = (float)i / m_HeightSegmentCount; BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, m_Radius, v, i > 0); } ////caps: //BuildCap(meshBuilder, Vector3.zero, true); //BuildCap(meshBuilder, Vector3.up * m_Height, false); return(meshBuilder.CreateMesh()); }
// Use this for initialization void Start() { MeshBuilder meshBuilder = new MeshBuilder(); meshBuilder.vertices.Add(new Vector3(0.0f, 0.0f, 0.0f)); meshBuilder.uvs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.normals.Add(Vector3.up); meshBuilder.vertices.Add(new Vector3(0.0f, 0.0f, m_length)); meshBuilder.uvs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.normals.Add(Vector3.up); meshBuilder.vertices.Add(new Vector3(m_width, 0.0f, m_length)); meshBuilder.uvs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.normals.Add(Vector3.up); meshBuilder.vertices.Add(new Vector3(m_width, 0.0f, 0.0f)); meshBuilder.uvs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.normals.Add(Vector3.up); meshBuilder.addTriangle(0, 1, 2); meshBuilder.addTriangle(0, 2, 3); // Create the mesh MeshFilter filter = GetComponent <MeshFilter>(); if (filter != null) { Debug.Log("Mesh Filter found"); filter.sharedMesh = meshBuilder.CreateMesh(); } }
// Update is called once per frame void Update() { MeshFilter meshFilter = this.GetComponent <MeshFilter>(); MeshBuilder meshBuilder = new MeshBuilder(subMeshSize); Vector3[] prevShape = TranslateShape( path[path.Length - 1].transform.position, (path[0].transform.position - path[path.Length - 1].transform.position).normalized, pathShape ); for (int i = 0; i < path.Length; i++) { Vector3[] currentShape = TranslateShape( path[i].transform.position, (path[(i + 1) % path.Length].transform.position - path[i].transform.position).normalized, pathShape ); for (int j = 0; j < currentShape.Length - 1; j++) { meshBuilder.BuildTriangle(prevShape[j], currentShape[j], currentShape[j + 1], 0); meshBuilder.BuildTriangle(prevShape[j + 1], prevShape[j], currentShape[j + 1], 0); } prevShape = currentShape; } meshFilter.mesh = meshBuilder.CreateMesh(); }
// Update is called once per frame void Update() { MeshFilter meshFilter = this.GetComponent <MeshFilter>(); MeshBuilder mb = new MeshBuilder(6); //points for our plane Vector3[,] points = new Vector3[width, height]; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { points[x, y] = new Vector3(cellSize * x, Mathf.PingPong(x, 1), cellSize * y); } } int submesh = 0; for (int x = 0; x < width - 1; x++) { for (int y = 0; y < height - 1; y++) { Vector3 br = points[x, y]; Vector3 bl = points[x + 1, y]; Vector3 tr = points[x, y + 1]; Vector3 tl = points[x + 1, y + 1]; mb.BuildTriangle(bl, tr, tl, submesh % 6); mb.BuildTriangle(bl, br, tr, submesh % 6); } submesh++; } meshFilter.mesh = mb.CreateMesh(); }
private void CreateTerrain() { MeshBuilder meshBuilder = new MeshBuilder(); for (int i = 0; i <= segmentCount; i++) { float z = height * i; float v = (1f / segmentCount) * i; for (int j = 0; j <= segmentCount; j++) { float x = width * j; float u = (1f / segmentCount) * j; Vector3 offset = new Vector3(x, UnityEngine.Random.Range(0, depth), z); Vector2 uv = new Vector2(u, v); bool buildTriangles = i > 0 && j > 0; CreateQuadForGrid(meshBuilder, offset, uv, buildTriangles, segmentCount + 1); } } MeshFilter filter = GetComponent <MeshFilter>(); if (filter != null) { Mesh mesh = meshBuilder.CreateMesh(); mesh.RecalculateNormals(); filter.sharedMesh = mesh; } }
private void makeT() { //intialise mesh filter MeshFilter meshFilter = this.GetComponent <MeshFilter>(); //initialise mesh builder MeshBuilder meshBuilder = new MeshBuilder(2);// 1 when we 2 submesh count submesh count //build our triangle Vector3 p0 = new Vector3(size.x, size.y, -size.z); // we are moving in clockwise direction going the points Vector3 p1 = new Vector3(-size.x, size.y, -size.z); Vector3 p2 = new Vector3(-size.x, size.y, size.z); meshBuilder.BuildTriangle(p0, p1, p2, 0); meshBuilder.BuildTriangle(p0, p2, p1, 1); // adding the bottom/opposite part of the triangle so it can be viewed from the bottom also //assigned mesh filter's mesh to the one generated by the mesh builder meshFilter.mesh = meshBuilder.CreateMesh(); //initialise our mesh render and assign the material list to the mesh rendere's material list MeshRenderer meshRender = this.GetComponent <MeshRenderer>(); AddMaterials(); // running add metrials meshRender.materials = materialList.ToArray(); // setting the add material }
void BuildQuad(MeshBuilder meshBuilder, Vector3 offset) { meshBuilder.Vertices.Add(new Vector3(0.0f, 0.0f, 0.0f) + offset); meshBuilder.Normals.Add(Vector3.up); meshBuilder.UVs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Vertices.Add(new Vector3(0.0f, 0.0f, m_length) + offset); meshBuilder.Normals.Add(Vector3.up); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Vertices.Add(new Vector3(m_width, 0.0f, m_length) + offset); meshBuilder.Normals.Add(Vector3.up); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Vertices.Add(new Vector3(m_width, 0.0f, 0.0f) + offset); meshBuilder.Normals.Add(Vector3.up); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.AddTriangle(0, 1, 2); meshBuilder.AddTriangle(0, 2, 3); MeshFilter filter = GetComponent <MeshFilter>(); if (filter != null) { filter.sharedMesh = meshBuilder.CreateMesh(); } int baseIndex = meshBuilder.Vertices.Count - 4; meshBuilder.AddTriangle(baseIndex, baseIndex + 1, baseIndex + 2); meshBuilder.AddTriangle(baseIndex, baseIndex + 2, baseIndex + 3); }
public override Mesh BuildMesh() { // SIMPLE CUBE! MeshBuilder meshBuilder = new MeshBuilder(); // OG: /*BuildQuad (meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT BuildQuad (meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.back, Vector3.up); // LEFT BuildQuad (meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), Vector3.back, Vector3.right); // TOP BuildQuad (meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), Vector3.left, Vector3.up); // BACK BuildQuad (meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), Vector3.forward, Vector3.up); // RIGHT BuildQuad (meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.right, Vector3.back); // BOTTOM */ int m_HeightSegmentCount = 8; int m_RadialSegmentCount = 8; float m_Radius = 0.25f; float m_VerticalScale = 1f; Quaternion rotation = Quaternion.identity; Vector3 offset = new Vector3(0f, -0.25f, 0f); //the angle increment per height segment: float angleInc = Mathf.PI / m_HeightSegmentCount; //the vertical (scaled) radius of the sphere: float verticalRadius = m_Radius * m_VerticalScale; //build the rings: for (int i = 0; i <= m_HeightSegmentCount; i++) { Vector3 centrePos = Vector3.zero; //calculate a height offset and radius based on a vertical circle calculation: centrePos.y = -Mathf.Cos(angleInc * i); float radius = Mathf.Sin(angleInc * i); //calculate the slope of the shpere at this ring based on the height and radius: Vector2 slope = new Vector3(-centrePos.y / m_VerticalScale, radius); slope.Normalize(); //multiply the unit height by the vertical radius, and then add the radius to the height to make this sphere originate from its base rather than its centre: centrePos.y = centrePos.y * verticalRadius + verticalRadius; //scale the radius by the one stored in the partData: radius *= m_Radius; //calculate the final position of the ring centre: Vector3 finalRingCentre = rotation * centrePos + offset; //V coordinate: float v = (float)i / m_HeightSegmentCount; //build the ring: BuildRing(meshBuilder, m_RadialSegmentCount, finalRingCentre, radius, v, i > 0, rotation, slope); } return meshBuilder.CreateMesh (); }
// Use this for initialization void Start () { MeshBuilder meshBuilder = new MeshBuilder(); //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.back, Vector3.up); // LEFT //BuildQuad(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), Vector3.back, Vector3.right); // TOP //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), Vector3.left, Vector3.up); // BACK //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), Vector3.forward, Vector3.up); // RIGHT //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.right, Vector3.back); // BOTTOM this.GetComponent<MeshFilter>().sharedMesh = meshBuilder.CreateMesh(); }
public override Mesh BuildMesh() { MeshBuilder meshBuilder = new MeshBuilder(); BuildQuad (meshBuilder, new Vector3(-1f, -1f, 1f), Vector3.right*2f, Vector3.up*2f); // BACK BuildQuad (meshBuilder, new Vector3(1f, -1f, 1f), Vector3.back*2f, Vector3.up*2f); // RIGHT BuildQuad (meshBuilder, new Vector3(-1f, -1f, 1f), Vector3.back*2f, Vector3.right*2f); // BOTTOM BuildQuad (meshBuilder, new Vector3(1f, -1f, -1f), Vector3.left*2f, Vector3.up*2f); // FRONT BuildQuad (meshBuilder, new Vector3(-1f, -1f, -1f), Vector3.forward*2f, Vector3.up*2f); // LEFT BuildQuad (meshBuilder, new Vector3(-1f, 1f, 1f), Vector3.right*2f, Vector3.back*2f); // TOP return meshBuilder.CreateMesh (); }
//public virtual Mesh BuildMesh() { // return new Mesh(); //} public Mesh BuildMesh() { // SIMPLE CUBE! MeshBuilder meshBuilder = new MeshBuilder(); BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.back, Vector3.up); // LEFT BuildQuad(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), Vector3.back, Vector3.right); // TOP BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), Vector3.left, Vector3.up); // BACK BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), Vector3.forward, Vector3.up); // RIGHT BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.right, Vector3.back); // BOTTOM return meshBuilder.CreateMesh(); }
public override Mesh BuildMesh() { MeshBuilder builder = new MeshBuilder(); float length = 1f; float width = 10f; float height = 1f; Vector3 currentPos = Vector3.zero; Vector3 forward = Vector3.forward * length; Vector3 right = Vector3.right * width; Vector3 up = Vector3.up * height; Vector3 tempForward = forward; //Vector3 tempRight = right; int amount = 200; //int periodUp = 40; //int periodRight = 20; int periodUp = Random.Range(10,80); int periodRight = Random.Range(10, 80); float ampUp = Random.Range(0.1f, 5f); float ampRight = Random.Range(0.1f, 0.2f); float r = 1f; float randUp = Random.Range(-r, r); float randRight = Random.Range(-r, r); int range = 10; Quaternion rot = Quaternion.Euler(Random.Range(0, range), Random.Range(0, range), Random.Range(0, range)); for (int i = 0; i < amount; i++) { BuildQuadDouble(builder, currentPos, tempForward, right); currentPos += tempForward; //float sinefactUp = Mathf.Sin(((float)i / periodUp) * Mathf.PI * 2f) - 0.5f; //float sinefactRight = Mathf.Sin(((float)i / periodRight) * Mathf.PI * 2f) - 0.5f; //tempForward = forward + up * sinefactUp * ampUp + right * sinefactRight * ampRight; //float r = 1f; //float randUp = Random.Range(-r, r); //float randRight = Random.Range(-r, r); //tempForward = forward + up * randUp + right * randRight; tempForward = rot * tempForward; } return builder.CreateMesh(); }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //Loop through the rows: for (int i = 0; i <= m_SegmentCount; i++) { //incremented values for the Z position and V coordinate: float z = m_Length * i; float v = (1.0f / m_SegmentCount) * i; //Loop through the collumns: for (int j = 0; j <= m_SegmentCount; j++) { //incremented values for the X position and U coordinate: float x = m_Width * j; float u = (1.0f / m_SegmentCount) * j; //The position offset for this quad, with a random height between zero and m_MaxHeight: Vector3 offset = new Vector3(x, Random.Range(0.0f, m_Height), z); ////Build individual quads: //BuildQuad(meshBuilder, offset); //build quads that share vertices: Vector2 uv = new Vector2(u, v); bool buildTriangles = i > 0 && j > 0; BuildQuadForGrid(meshBuilder, offset, uv, buildTriangles, m_SegmentCount + 1); } } //create the Unity mesh: Mesh mesh = meshBuilder.CreateMesh(); //have the mesh calculate its own normals: mesh.RecalculateNormals(); //return the new mesh: return mesh; }
public override Mesh BuildMesh() { MeshBuilder meshBuilder = new MeshBuilder(); //store the current position and rotaion of the stem: Vector3 currentPosition; Quaternion currentRotation; //build the main stem: BuildStem(meshBuilder, out currentPosition, out currentRotation, m_StemData); BuildHead(meshBuilder, currentPosition, currentRotation, m_HeadData); //build the sepals: BuildLeafRing(meshBuilder, currentPosition, currentRotation, m_StemData.m_Radius, m_SepalData); //build the petals: BuildLeafRing(meshBuilder, currentPosition, currentRotation, m_StemData.m_Radius, m_PetalData); return meshBuilder.CreateMesh(); }
private Mesh caveMesh() { MeshBuilder meshBuilder = new MeshBuilder(); int pads = landingPadLocations.Count; float degreesPerPad = 360 / pads; IList<Vector2> wallCoords;//new List<Vector2>(); if (pads == 2) { Vector2 normal = 2 * landingPadLocations[0] - landingPadLocations[1]; wallCoords = wallForPad(landingPadLocations[0], normal, degreesPerPad); normal = 2 * landingPadLocations[1] - landingPadLocations[0]; foreach (var coord in wallForPad(landingPadLocations[1], normal, degreesPerPad)) { wallCoords.Add(coord); } //wallForPad(new Vector2(0,0), new Vector2(1,0), 180); //close off the cave wallCoords.Add(wallCoords[0]); } else { Debug.Log("Unsupported number of landing pads"); return null; } helper.BuildWall(meshBuilder, wallCoords); // new List<Vector2>() { // new Vector2(-10,-12), // new Vector2(-12,-6), // new Vector2(-10,0), // new Vector2(-12,6), // new Vector2(-2,12) // }); Mesh mesh = meshBuilder.CreateMesh(); mesh.RecalculateNormals(); return mesh; }
//Initialisation: private void Start() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //Add the vertices: meshBuilder.Vertices.Add(new Vector3(0.0f, 0.0f, 0.0f)); meshBuilder.UVs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(0.0f, 0.0f, m_Length)); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(m_Width, 0.0f, m_Length)); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(m_Width, 0.0f, 0.0f)); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(Vector3.up); //Add the triangles: meshBuilder.AddTriangle(0, 1, 2); meshBuilder.AddTriangle(0, 2, 3); //Create the mesh: Mesh mesh = meshBuilder.CreateMesh(); //Look for a MeshFilter component attached to this GameObject: MeshFilter filter = GetComponent<MeshFilter>(); //If the MeshFilter exists, attach the new mesh to it. //Assuming the GameObject also has a renderer attached, our new mesh will now be visible in the scene. if (filter != null) { filter.sharedMesh = mesh; } }
public override Mesh BuildMesh() { MeshBuilder meshBuilder = new MeshBuilder(); //store the current position and rotaion of the stem: Quaternion currentRotation = Quaternion.identity; Vector3 currentOffset = Vector3.zero; //build the stem: //build a straight stem if m_StemBendAngle is zero: if (m_StemBendAngle == 0.0f) { //straight cylinder: float heightInc = m_StemHeight / m_StemHeightSegmentCount; for (int i = 0; i <= m_StemHeightSegmentCount; i++) { currentOffset = Vector3.up * heightInc * i; BuildRing(meshBuilder, m_StemRadialSegmentCount, currentOffset, m_StemRadius, (float)i / m_StemHeightSegmentCount, i > 0); } } else { //get the angle in radians: float stemBendRadians = m_StemBendAngle * Mathf.Deg2Rad; //the radius of our bend (vertical) circle: float stemBendRadius = m_StemHeight / stemBendRadians; //the angle increment per height segment (based on arc length): float angleInc = stemBendRadians / m_StemHeightSegmentCount; //calculate a start offset that will place the centre of the first ring (angle 0.0f) on the mesh origin: //(x = cos(0.0f) * bendRadius, y = sin(0.0f) * bendRadius) Vector3 startOffset = new Vector3(stemBendRadius, 0.0f, 0.0f); //build the rings: for (int i = 0; i <= m_StemHeightSegmentCount; i++) { //current normalised height value: float heightNormalised = (float)i / m_StemHeightSegmentCount; //unit position along the edge of the vertical circle: currentOffset = Vector3.zero; currentOffset.x = Mathf.Cos(angleInc * i); currentOffset.y = Mathf.Sin(angleInc * i); //rotation at that position on the circle: float zAngleDegrees = angleInc * i * Mathf.Rad2Deg; currentRotation = Quaternion.Euler(0.0f, 0.0f, zAngleDegrees); //multiply the unit postion by the radius: currentOffset *= stemBendRadius; //offset the position so that the base ring (at angle zero) centres around zero: currentOffset -= startOffset; //build the ring: BuildRing(meshBuilder, m_StemRadialSegmentCount, currentOffset, m_StemRadius, heightNormalised, i > 0, currentRotation); } } //build the cap: //positions of the cap peak and rim in the XY cross-section: Vector3 capPeak = new Vector3(0.0f, m_CapThickness, 0.0f); Vector3 capRim = new Vector3(m_CapRadius, -m_CapHeight + m_CapThickness, 0.0f); //Bézier handles to define the cap curve: Vector3 peakHandle = new Vector3(m_CapPeakHandleLength, 0.0f, 0.0f); float rimAngleRadians = m_CapRimHandleAngle * Mathf.Deg2Rad; Vector3 rimHandle = new Vector3(Mathf.Cos(rimAngleRadians), Mathf.Sin(rimAngleRadians), 0.0f); rimHandle *= m_CapRimHandleLength; //build the outer surface of the cap: BuildCap(meshBuilder, currentOffset, currentRotation, capRim, capPeak, capRim + rimHandle, capPeak + peakHandle); //build the gills: //adjust the Bézier handles for our inner curve: capPeak.y -= m_CapThickness; rimHandle = new Vector3(-rimHandle.y, rimHandle.x, 0.0f); //build the gills (inner surface of the cap) //note the reversal of the control points to make the mesh face inward instead of outward: BuildCap(meshBuilder, currentOffset, currentRotation, capPeak, capRim, capPeak + peakHandle, capRim + rimHandle); return meshBuilder.CreateMesh(); }
void GenerateQuadMesh() { MeshBuilder meshBuilder = new MeshBuilder (); float vx, vz; Vector3 offset; for (int z = 0; z < sizeZ; z++) { vz = meshLength * z; for (int x = 0; x < sizeX; x++) { vx = meshWidth * x; offset = new Vector3(vx, Random.Range (0f, meshHeight), vz); BuildQuad(meshBuilder, offset); } } GetComponent<MeshFilter> ().mesh = meshBuilder.CreateMesh (); }
void GenerateCubeMesh() { MeshBuilder meshBuilder = new MeshBuilder (); Vector3 upDir = Vector3.up * meshHeight; Vector3 rightDir = Vector3.right * meshWidth; Vector3 forwardDir = Vector3.forward * meshLength; Vector3 nearCorner = - 0.5f * (upDir + rightDir + forwardDir); Vector3 farCorner = nearCorner + upDir + rightDir + forwardDir; BuildQuad (meshBuilder, nearCorner, forwardDir, rightDir, sizeX, sizeZ); BuildQuad (meshBuilder, nearCorner, rightDir, upDir, sizeX, sizeZ); BuildQuad (meshBuilder, nearCorner, upDir, forwardDir, sizeX, sizeZ); BuildQuad (meshBuilder, farCorner, -rightDir, -forwardDir, sizeX, sizeZ); BuildQuad (meshBuilder, farCorner, -upDir, -rightDir, sizeX, sizeZ); BuildQuad (meshBuilder, farCorner, -forwardDir, -upDir, sizeX, sizeZ); GetComponent<MeshFilter> ().mesh = meshBuilder.CreateMesh (); //Invoke ("Spherify", 3f); PrepareForVerticesAnimation (); }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //build the walls: //calculate directional vectors for the walls: Vector3 upDir = Vector3.up * m_Height; Vector3 rightDir = Vector3.right * m_Width; Vector3 forwardDir = Vector3.forward * m_Length; Vector3 farCorner = upDir + rightDir + forwardDir; Vector3 nearCorner = Vector3.zero; //shift the pivot to centre bottom: Vector3 pivotOffset = (rightDir + forwardDir) * 0.5f; farCorner -= pivotOffset; nearCorner -= pivotOffset; //build the quads for the walls: BuildQuad(meshBuilder, nearCorner, rightDir, upDir); BuildQuad(meshBuilder, nearCorner, upDir, forwardDir); BuildQuad(meshBuilder, farCorner, -upDir, -rightDir); BuildQuad(meshBuilder, farCorner, -forwardDir, -upDir); //build the roof: //calculate the position of the roof peak at the near end of the house: Vector3 roofPeak = Vector3.up * (m_Height + m_RoofHeight) + rightDir * 0.5f - pivotOffset; //calculate the positions at the tops of the walls at the same end of the house: Vector3 wallTopLeft = upDir - pivotOffset; Vector3 wallTopRight = upDir + rightDir - pivotOffset; //build triangles at the tops of the walls: BuildTriangle(meshBuilder, wallTopLeft, roofPeak, wallTopRight); BuildTriangle(meshBuilder, wallTopLeft + forwardDir, wallTopRight + forwardDir, roofPeak + forwardDir); //calculate the directions from the roof peak to the sides of the house: Vector3 dirFromPeakLeft = wallTopLeft - roofPeak; Vector3 dirFromPeakRight = wallTopRight - roofPeak; //extend the directions by a length of m_RoofOverhangSide: dirFromPeakLeft += dirFromPeakLeft.normalized * m_RoofOverhangSide; dirFromPeakRight += dirFromPeakRight.normalized * m_RoofOverhangSide; //offset the roofpeak position to put it at the beginning of the front overhang: roofPeak -= Vector3.forward * m_RoofOverhangFront; //extend the forward directional vecter ot make it long enough for and overhang at either end: forwardDir += Vector3.forward * m_RoofOverhangFront * 2.0f; //shift the roof slightly upward to stop it intersecting the top of the walls: roofPeak += Vector3.up * m_RoofBias; //build the quads for the roof: BuildQuad(meshBuilder, roofPeak, forwardDir, dirFromPeakLeft); BuildQuad(meshBuilder, roofPeak, dirFromPeakRight, forwardDir); BuildQuad(meshBuilder, roofPeak, dirFromPeakLeft, forwardDir); BuildQuad(meshBuilder, roofPeak, forwardDir, dirFromPeakRight); //initialise the Unity mesh and return it: return meshBuilder.CreateMesh(); }
void GenerateMesh() { float start_time = Time.time; NoiseGenerator gen = new NoiseGenerator(); noise = gen.generateNoise(width,width,100); MeshBuilder builder = new MeshBuilder(); Vector3 offset = new Vector3(0, 0, 0); for(int x = 0;x< width;x++){ for(int z=0;z< width;z++){ offset.z+= spacing; offset.y = noise[x * width + z] * Random.Range(-3,3); bool tri = x > 0 && z > 0; BuildQuadForGrid(builder,offset,new Vector2((1f/width)*x,(1f/width)*z),tri,width); } offset.x+= spacing; offset.z = 0; } if (terrainMesh != null) { Mesh mesh = builder.CreateMesh(); mesh.RecalculateNormals(); terrainMesh.sharedMesh = mesh; } float diff = Time.time - start_time; Debug.Log("ProceduralTerrain was generated in " + diff + " seconds."); }
// Use this for initialization void Start() { MeshBuilder meshBuilder = new MeshBuilder(); meshBuilder.Vertices.Add(new Vector3(-1f,-1f,-1f)); // 0 meshBuilder.Vertices.Add(new Vector3(-1f,-1f, 1f)); // 1 meshBuilder.Vertices.Add(new Vector3(-1f, 1f,-1f)); // 2 meshBuilder.Vertices.Add(new Vector3(-1f, 1f, 1f)); // 3 meshBuilder.Vertices.Add(new Vector3( 1f,-1f,-1f)); // 4 meshBuilder.Vertices.Add(new Vector3( 1f,-1f, 1f)); // 5 meshBuilder.Vertices.Add(new Vector3( 1f, 1f,-1f)); // 6 meshBuilder.Vertices.Add(new Vector3( 1f, 1f, 1f)); // 7 float phi = (1f + Mathf.Sqrt(5f))/2f; meshBuilder.Vertices.Add(new Vector3(0f, -1f/phi, -phi)); // 8 meshBuilder.Vertices.Add(new Vector3(0f, -1f/phi, phi)); // 9 meshBuilder.Vertices.Add(new Vector3(0f, 1f/phi, -phi)); // 10 meshBuilder.Vertices.Add(new Vector3(0f, 1f/phi, phi)); // 11 meshBuilder.Vertices.Add(new Vector3(-1f/phi, -phi, 0f)); // 12 meshBuilder.Vertices.Add(new Vector3(-1f/phi, phi, 0f)); // 13 meshBuilder.Vertices.Add(new Vector3( 1f/phi, -phi, 0f)); // 14 meshBuilder.Vertices.Add(new Vector3( 1f/phi, phi, 0f)); // 15 meshBuilder.Vertices.Add(new Vector3(-phi, 0f, -1f/phi)); // 16 meshBuilder.Vertices.Add(new Vector3( phi, 0f, -1f/phi)); // 17 meshBuilder.Vertices.Add(new Vector3(-phi, 0f, 1f/phi)); // 18 meshBuilder.Vertices.Add(new Vector3( phi, 0f, 1f/phi)); // 19 vertices = meshBuilder.Vertices; AddDodecahedronFace(meshBuilder, 7, 19, 17, 6, 15); AddDodecahedronFace(meshBuilder, 6, 17, 4, 8, 10); AddDodecahedronFace(meshBuilder, 15, 6, 10, 2, 13); AddDodecahedronFace(meshBuilder, 2, 10, 8, 0, 16); AddDodecahedronFace(meshBuilder, 13, 2, 16, 18, 3); AddDodecahedronFace(meshBuilder, 7, 15, 13, 3, 11); AddDodecahedronFace(meshBuilder, 4, 17, 19, 5, 14); AddDodecahedronFace(meshBuilder, 0, 8, 4, 14, 12); AddDodecahedronFace(meshBuilder, 18, 16, 0, 12, 1); AddDodecahedronFace(meshBuilder, 11, 3, 18, 1, 9); AddDodecahedronFace(meshBuilder, 19, 7, 11, 9, 5); AddDodecahedronFace(meshBuilder, 5, 9, 1, 12, 14); AddInternalCubeFace(meshBuilder, 2, 6, 4, 0); AddInternalCubeFace(meshBuilder, 6, 7, 5, 4); AddInternalCubeFace(meshBuilder, 7, 3, 1, 5); AddInternalCubeFace(meshBuilder, 3, 2, 0, 1); AddInternalCubeFace(meshBuilder, 3, 7, 6, 2); AddInternalCubeFace(meshBuilder, 5, 1, 0, 4); Mesh mesh = GetComponent<MeshFilter> ().mesh = meshBuilder.CreateMesh (); mesh.RecalculateBounds (); mesh.RecalculateNormals (); }
public Mesh BuildNewMesh(BrainNEAT brain) { if(sourceCritter == null) { Debug.Log("BuildNewMesh(BrainNEAT brain) SOURCE CRITTER NULL!!!"); } else { SetNeuronSegmentPositions(brain); } if (nodeVertexList == null) { nodeVertexList = new List<List<int>>(); } else { nodeVertexList.Clear(); } if (connectionVertexList == null) { connectionVertexList = new List<List<int>>(); } else { connectionVertexList.Clear(); } if(nodePositionsList == null) { nodePositionsList = new List<Vector3>(); } else { nodePositionsList.Clear(); } if(bezierCurveList == null) { bezierCurveList = new List<BezierCurve>(); } else { bezierCurveList.Clear(); } if(hiddenNodeIndicesList == null) { hiddenNodeIndicesList = new List<int>(); // keep track of hidden nodes for later use } else { hiddenNodeIndicesList.Clear(); } meshBuilder = new MeshBuilder(); //Debug.Log("PRE ERROR: brain: " + brain.ToString()); //neuronRadius = 1.4f / Mathf.Max((float)brain.inputNeuronList.Count, (float)brain.outputNeuronList.Count); //Vector3 offset = new Vector3(neuronRadius * 0.5f, neuronRadius * 0.5f, 0f); int currentInputIndex = 0; int currentOutputIndex = 0; for(int i = 0; i < brain.neuronList.Count; i++) { // go through all nodes and place them in proper spot float xpos = 0f; float ypos = 0f; float zpos = 0f; //float size = Mathf.Min((neuronRadius * brain.neuronList[i].currentValue[0] * 0.2f + 0.02f), 2.0f); float size = Mathf.Max(Mathf.Min((Mathf.Abs(brain.neuronList[i].currentValue[0])) * neuronRadiusMaxValue, neuronRadiusMax), neuronRadiusMin); if (brain.neuronList[i].nodeType == GeneNodeNEAT.GeneNodeType.In) { xpos = (float)(currentInputIndex + 1) / (float)(brain.inputNeuronList.Count + 1) - 0.5f; ypos = 0f; zpos = UnityEngine.Random.Range(-0.5f, 0.5f); currentInputIndex++; BuildNodeSphere(meshBuilder, new Vector3(xpos, ypos, zpos), size, GetColorFromNeuron(brain.neuronList[i])); } else if(brain.neuronList[i].nodeType == GeneNodeNEAT.GeneNodeType.Hid) { xpos = 0.0f; // UnityEngine.Random.Range(neuronRadius, 1f - neuronRadius); //0.5f; ypos = 0.0f; // UnityEngine.Random.Range(neuronRadius, 1f - neuronRadius); //0.5f; zpos = UnityEngine.Random.Range(-0.5f, 0.5f); hiddenNodeIndicesList.Add(i); //BuildNode(meshBuilder, new Vector3(xpos, ypos, 0f), new Vector3(radius, 0f, 0f), new Vector3(0f, radius, 0f), GetColorFromValue(brain.neuronList[i].currentValue[0])); } else { // output xpos = (float)(currentOutputIndex + 1) / (float)(brain.outputNeuronList.Count + 1) - 0.5f; ypos = 1f - neuronRadiusMax; zpos = UnityEngine.Random.Range(-0.5f, 0.5f); currentOutputIndex++; BuildNodeSphere(meshBuilder, new Vector3(xpos, ypos, zpos), size, GetColorFromNeuron(brain.neuronList[i])); } nodePositionsList.Add(new Vector3(xpos, ypos, zpos)); } // position HiddenNodes!! // BUILD hidden nodes: for (int h = 0; h < hiddenNodeIndicesList.Count; h++) { float size = Mathf.Max(Mathf.Min((Mathf.Abs(brain.neuronList[hiddenNodeIndicesList[h]].currentValue[0])) * neuronRadiusMaxValue, neuronRadiusMax), neuronRadiusMin); BuildNodeSphere(meshBuilder, new Vector3(nodePositionsList[hiddenNodeIndicesList[h]].x, nodePositionsList[hiddenNodeIndicesList[h]].y, nodePositionsList[hiddenNodeIndicesList[h]].z), size, GetColorFromNeuron(brain.neuronList[hiddenNodeIndicesList[h]])); } // CONNECTIONS! //connectionWidth = Mathf.Max(neuronRadius * 0.1f, 0.01f); //Debug.Log("BuildNew BrainMesh: numConnections: " + brain.connectionList.Count); for(int c = 0; c < brain.connectionList.Count; c++) { BezierCurve connectionBezier = new BezierCurve(); connectionBezier.points[0] = nodePositionsList[brain.connectionList[c].fromNodeID]; connectionBezier.points[1] = Vector3.Lerp(nodePositionsList[brain.connectionList[c].fromNodeID], nodePositionsList[brain.connectionList[c].toNodeID], 0.333f); connectionBezier.points[2] = Vector3.Lerp(nodePositionsList[brain.connectionList[c].fromNodeID], nodePositionsList[brain.connectionList[c].toNodeID], 0.667f); connectionBezier.points[3] = nodePositionsList[brain.connectionList[c].toNodeID]; bezierCurveList.Add(connectionBezier); float startWidth = Mathf.Max(Mathf.Min((Mathf.Abs(brain.neuronList[brain.connectionList[c].fromNodeID].currentValue[0]) * connectionWidthMax * 0.4f), connectionWidthMax), connectionWidthMin); float endWidth = Mathf.Max(Mathf.Min((Mathf.Abs(brain.neuronList[brain.connectionList[c].toNodeID].currentValue[0])) * connectionWidthMax * 0.4f, connectionWidthMax), connectionWidthMin); BuildLinkBezier(meshBuilder, connectionBezier, startWidth, endWidth, GetColorFromNeuron(brain.neuronList[brain.connectionList[c].fromNodeID]), GetColorFromNeuron(brain.neuronList[brain.connectionList[c].toNodeID])); //Debug.Log("BuildNew BrainMesh: from: " + nodePositionsList[brain.connectionList[c].fromNodeID].ToString() + ", to: " + nodePositionsList[brain.connectionList[c].toNodeID].ToString()); } //MoveHiddenNodes(brain, 1); return meshBuilder.CreateMesh(); }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //our bend code breaks if m_BendAngle is zero: if (m_BendAngle == 0.0f) { //straight cylinder: float heightInc = m_Height / m_HeightSegmentCount; for (int i = 0; i <= m_HeightSegmentCount; i++) { Vector3 centrePos = Vector3.up * heightInc * i; float v = (float)i / m_HeightSegmentCount; BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, m_Radius, v, i > 0); } } else { //bent cylinder: //get the angle in radians: float bendAngleRadians = m_BendAngle * Mathf.Deg2Rad; //the radius of our bend (vertical) circle: float bendRadius = m_Height / bendAngleRadians; //the angle increment per height segment (based on arc length): float angleInc = bendAngleRadians / m_HeightSegmentCount; //calculate a start offset that will place the centre of the first ring (angle 0.0f) on the mesh origin: //(x = cos(0.0f) * bendRadius, y = sin(0.0f) * bendRadius) Vector3 startOffset = new Vector3(bendRadius, 0.0f, 0.0f); //build the rings: for (int i = 0; i <= m_HeightSegmentCount; i++) { //unit position along the edge of the vertical circle: Vector3 centrePos = Vector3.zero; centrePos.x = Mathf.Cos(angleInc * i); centrePos.y = Mathf.Sin(angleInc * i); //rotation at that position on the circle: float zAngleDegrees = angleInc * i * Mathf.Rad2Deg; Quaternion rotation = Quaternion.Euler(0.0f, 0.0f, zAngleDegrees); //multiply the unit postion by the radius: centrePos *= bendRadius; //offset the position so that the base ring (at angle zero) centres around zero: centrePos -= startOffset; //V coordinate is based on height: float v = (float)i / m_HeightSegmentCount; //build the ring: BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, m_Radius, v, i > 0, rotation); } } return meshBuilder.CreateMesh(); }
private void GenerateWayMesh(IList<MapWay> wayList) { IList<Color32> colours = new List<Color32> (); //Create MeshBuilder MeshBuilder meshBuilder = new MeshBuilder(); int currentTriangleCount = 0; foreach (MapWay mapway in wayList) { if (OnlyDrawHighways){ if (!mapway._tags.ContainsKey("highway")){ continue; } } MapNode to = null; MapNode from = null; //Color randomCol = new Color (Random.Range (0.00f, 1.00f),Random.Range (0.00f, 1.00f),Random.Range (0.00f, 1.00f)); for (int i=0; i < mapway._nodesInWay.Count; i++){ //Get nodes to = _mapController.GetMapNodeById(mapway._nodesInWay[i]._id); if (to == null){ continue; } if (from == null){ from = to; continue; } //Debug.DrawLine(from.LocationInUnits, to.LocationInUnits, randomCol, 2000, false); //Draw Mesh Vector3 newVec = to.LocationInUnits - from.LocationInUnits; Vector3 newVector = Vector3.Cross (newVec, Vector3.down); newVector.Normalize (); Vector3 c = RoadWidth * newVector + to.LocationInUnits; Vector3 d = -RoadWidth * newVector + to.LocationInUnits; Vector3 e = RoadWidth * newVector + from.LocationInUnits; Vector3 f = -RoadWidth * newVector + from.LocationInUnits; //MeshBuilder from http://jayelinda.com/ meshBuilder.Vertices.Add(e); meshBuilder.UVs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(f); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(d); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(c); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); //Don't edit colours here- do it in the GenerateMeshColours function below! byte needColor; Color32 vertexColor; if (NeedToColour == Needs.Food) { needColor = (byte)((from.NeedAmounts[Needs.Food] + from.NearbyNeedAmounts[Needs.Food]) * 255); vertexColor = new Color32(needColor, 0, 0, 255); } else { needColor = (byte)((from.NeedAmounts[Needs.Water] + from.NearbyNeedAmounts[Needs.Water]) * 255); vertexColor = new Color32(0, 0, needColor, 255); } colours.Add (vertexColor); colours.Add (vertexColor); //Other side if (NeedToColour == Needs.Food) { needColor = (byte)((to.NeedAmounts[Needs.Food] + to.NearbyNeedAmounts[Needs.Food]) * 255); vertexColor = new Color32(needColor, 0, 0, 255); } else { needColor = (byte)((to.NeedAmounts[Needs.Water] + to.NearbyNeedAmounts[Needs.Water]) * 255); vertexColor = new Color32(0, 0, needColor, 255); } colours.Add (vertexColor); colours.Add (vertexColor); //Add the triangles: meshBuilder.AddTriangle(currentTriangleCount, currentTriangleCount+1, currentTriangleCount+2); meshBuilder.AddTriangle(currentTriangleCount, currentTriangleCount+2, currentTriangleCount+3); currentTriangleCount+=4; from = to; } } //Create the mesh: Mesh mesh = meshBuilder.CreateMesh(); _wayMesh = mesh; _wayColours = colours; GenerateNeedMeshColours (wayList); }
void recreateMesh(int width, int length) { this.lastLength = length; this.lastWidth = width; MeshBuilder meshBuilder = new MeshBuilder(); //Set up the vertices and triangles: meshBuilder.Vertices.Add(new Vector3(-width / 2, 0.0f, -length / 2)); meshBuilder.UVs.Add(new Vector2(width / 2, 0.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(-width / 2, 0.0f, length / 2)); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(width / 2, 0.0f, length / 2)); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.Vertices.Add(new Vector3(width / 2, 0.0f, -length / 2)); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(Vector3.up); meshBuilder.AddTriangle(0, 1, 2); meshBuilder.AddTriangle(0, 2, 3); //Create the mesh: Mesh myMesh = meshBuilder.CreateMesh(); myMesh.name = "TestMesh"; this.GetComponent<MeshFilter>().sharedMesh = myMesh; this.GetComponent<MeshCollider>().sharedMesh = myMesh; }
GameObject GenerateObject(MeshBuilder meshBuilder, string objectName) { GameObject go; // Object to be created or modified Transform to = transform.FindDeepChild(objectName); // Verify if object already exists if (to == null) { go = new GameObject (objectName); go.AddComponent<MeshFilter> ().mesh = meshBuilder.CreateMesh (); go.AddComponent<MeshRenderer> ().material = trackMaterial; } else { go = to.gameObject; go.GetComponent<MeshFilter> ().mesh = meshBuilder.CreateMesh (); go.GetComponent<MeshRenderer> ().material = trackMaterial; } return go; }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //some variables to hold values needed by the loop: Vector3 prevCrossPosition = Vector3.zero; Quaternion prevRotation = Quaternion.identity; //interate over all the posts in this fence: for (int i = 0; i <= m_SectionCount; i++) { //calculate the position and rotation of this post: Vector3 offset = Vector3.right * m_DistBetweenPosts * i; float xAngle = Random.Range(-m_PostTiltAngle, m_PostTiltAngle); float zAngle = Random.Range(-m_PostTiltAngle, m_PostTiltAngle); Quaternion rotation = Quaternion.Euler(xAngle, 0.0f, zAngle); //Any level-specific position offsets (eg. the height of the terrain at this position) should be applied here. //build the post: BuildPost(meshBuilder, offset, rotation); //build the crosspiece: //start with the post position: Vector3 crossPosition = offset; //offset to the back of the post: crossPosition += rotation * (Vector3.back * m_PostWidth * 0.5f); //calculate 2 random Y offsets (one for each end of the crosspiece): float randomYStart = Random.Range(-m_CrossPieceYVariation, m_CrossPieceYVariation); float randomYEnd = Random.Range(-m_CrossPieceYVariation, m_CrossPieceYVariation); //calculate Y offsets for the start and end positions: Vector3 crossYOffsetStart = prevRotation * Vector3.up * (m_CrossPieceY + randomYStart); Vector3 crossYOffsetEnd = rotation * Vector3.up * (m_CrossPieceY + randomYEnd); //if this is not the first section (ie. if there is a previous post to join to), build the crosspiece: if (i != 0) BuildCrossPiece(meshBuilder, prevCrossPosition + crossYOffsetStart, crossPosition + crossYOffsetEnd); //store the position and rotation for use by the next section: prevCrossPosition = crossPosition; prevRotation = rotation; } //initialise the Unity mesh and return it: return meshBuilder.CreateMesh(); }