// 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();
}
