public Mesh GenerateCubes(float samplingRate, int cellSize, float scale)
{
this.samplingRate = samplingRate;
this.cellSize = cellSize;
this.scale = scale;
Positon pos = new Positon();
// TODO: calculate the value 41817
Dictionary <Vector3, int> hashedVertexes = new Dictionary <Vector3, int>(41817);
LinkedList <int> linkedTriangles = new LinkedList <int>();
int hashedIndex = 0;
LinkedList <Vector3> linkedVectors = new LinkedList <Vector3>();
for (int x = 0; x < (cellSize * scale); x++)
{
pos.x = x / scale;
for (int y = 0; y < (cellSize * scale); y++)
{
pos.y = y / scale;
for (int z = 0; z < (cellSize * scale); z++)
{
pos.z = z / scale;
hashedIndex = March(pos, hashedVertexes, linkedTriangles, hashedIndex, linkedVectors);
}
}
}
MeshData mesh = new MeshData(32);
/*
* int mexVertexPerMesh = 64000;
* int numMeshes = linkedVectors.Count / mexVertexPerMesh + 1;
* int vectorsRemaining = linkedVectors.Count % mexVertexPerMesh;
* LinkedList<Vector3[]> meshes = new LinkedList<Vector3[]>();
* for (int i = 0; i < numMeshes; i++)
* {
* if (i == numMeshes - 1)
* {
* Vector3[] vec = new Vector3[64000];
* int[] tri = new int[64000];
* }
* else
* {
* Vector3[] vec = new Vector3[vectorsRemaining];
* }
* }
*
*/
Vector3[] finalVectors = LinkListToArray(linkedVectors);
mesh.vertices = finalVectors;
int[] finalTriangles = LinkListToArray(linkedTriangles);
mesh.triangles = finalTriangles;
return(mesh.CreateMesh());
}
void OnMeshDataRecieved(MeshData meshData)
{
meshObject = meshData.CreateMesh();
hasMesh = true;
updateCallBack();
}
public void DrawMesh(float[,] heightMap, Color[] colorMap, int width, int height)
{
Debug.Log("-----------------------------");
MeshData meshData = MeshGenerator.GenerateTerrainMesh(heightMap);
Texture2D texture = TextureGenerator.TextureFromColorMap(colorMap, width, height);
meshFilter.sharedMesh = meshData.CreateMesh();
meshRenderer.sharedMaterial.mainTexture = texture;
}
public void DrawMesh(MeshData meshData, Texture2D texture) {
currentTexture = texture;
//print (currentTexture.width + " " + currentTexture.height);
meshFilter.sharedMesh = meshData.CreateMesh ();
meshRenderer.sharedMaterial.mainTexture = texture;
GetComponent<MeshCollider>().sharedMesh = meshFilter.sharedMesh;
}
public void DrawMesh(MeshData meshData, MinMaxTracker heightTracker, ColorSettings colorSettings)
{
colorGen.UpdateSettings(colorSettings);
colorGen.UpdateHeight(heightTracker);
colorGen.UpdateColors();
meshFilter.sharedMesh = meshData.CreateMesh();
meshFilter.GetComponent <MeshRenderer>().sharedMaterial = colorSettings.terrainMaterial;
}
void LateUpdate()
{
gHeightHandle.Complete();
m_heightMap.CopyTo(managedHeightMap);
MeshData meshData = MeshGenerator.GenerateTerrainMesh(managedHeightMap,
m_descriptor.pixelSize, m_descriptor.realSize);
oceanMesh = meshData.CreateMesh();
}
public override void LateUpdateOcean(float _time)
{
heightMapHandle.Complete();
m_heightMap.CopyTo(managedHeightMap);
MeshData meshData = MeshGenerator.GenerateTerrainMesh(managedHeightMap,
m_descriptor.pixelSize, m_descriptor.realSize);
oceanMesh = meshData.CreateMesh();
}
private void OnMeshDataReceived(object meshDataObject)
{
MeshData meshData = (MeshData)meshDataObject;
mesh = meshData.CreateMesh();
hasMesh = true;
meshVertices = meshData.GetVertices();
updateCallback?.Invoke();
}
void OnMeshDataReceived(MeshData meshData)
{
mesh = meshData.CreateMesh();
hasMesh = true;
// TODO:
var viewerPosition = Vector2.zero;
updateCallback(viewerPosition);
}
public void DrawMesh(MeshData meshData)
{
if (meshFilter != null)
{
meshFilter.sharedMesh = meshData.CreateMesh();
textureRenderer.gameObject.SetActive(false);
meshFilter.gameObject.SetActive(true);
}
}
private void DrawMesh(MeshData meshData)
{
if (meshFilter)
{
meshFilter.sharedMesh = meshData.CreateMesh();
}
textureRender.gameObject.SetActive(false);
meshFilter.gameObject.SetActive(true);
}
private void OnMeshData(MeshData data)
{
target.mesh = data.CreateMesh();
if (flatShaded)
{
NoShared();
}
generated = false;
}
// Use this for initialization
void Start()
{
MeshData meshData = MeshGenerator.GeneratePlaneMesh(64, 64);
var meshFilter = gameObject.AddComponent <MeshFilter>();
var meshRenderer = gameObject.AddComponent <MeshRenderer>();
meshFilter.sharedMesh = meshData.CreateMesh();
meshRenderer.material = Mat;
meshRenderer.sharedMaterial.mainTexture = Texture;
}
Mesh createMesh(MeshData meshData, Texture2D texture)
{
MeshFilter meshFilter = plane.GetComponent <MeshFilter>();
MeshRenderer meshRendered = plane.GetComponent <MeshRenderer>();
meshRendered.sharedMaterial = material;
meshFilter.sharedMesh = meshData.CreateMesh();
meshRendered.sharedMaterial.SetTexture("_BaseMap", texture);
return(meshFilter.sharedMesh);
}
public void GenerateWater()
{
float[,] noiseMap = Noise.GenerateNoiseMap(_size, data, false, 0);
TriangleNet.Mesh mesh = MeshGenerator.GenerateTriangulatedMesh(_size, _distributionData);
_meshData = MeshGenerator.GenerateMeshData(mesh, data.meshHeightCurve, noiseMap, data.meshHeightMultiplier);
Color[] colors = _mapDisplay.GenerateColors(mesh, noiseMap);
_meshData.AddColors(colors);
UnityEngine.Mesh m = _meshData.CreateMesh();
_mapDisplay.DisplayMesh(m);
}
void OnMeshDataReceived(MeshData meshData)
{
mesh = meshData.CreateMesh();
if (storeCoordData)
{
meshCoords = meshData.getPositions();
}
hasMesh = true;
updateCallback();
}
public void DrawMeshLand(MeshData meshData, Texture2D texture)
{
//Renderer rend;
//rend = GetComponent<Renderer>();
shader1 = Shader.Find("Standard");
shader2 = Shader.Find("Custom/Terrain");
//var invincibleShader = Shader.Find("Terrain");
meshFilter.sharedMesh = meshData.CreateMesh();
//textureRender.sharedMaterial.shader = shader2;
meshRenderer.sharedMaterial.shader = shader2;
}
public void DrawMesh(MeshData meshData, Texture2D texture)
{
//rend = GetComponent<Renderer>();
shader1 = Shader.Find("Standard");
//var invincibleShader = Shader.Find("Terrain");
meshFilter.sharedMesh = meshData.CreateMesh();
meshRenderer.sharedMaterial.mainTexture = texture;
//textureRender.material.shader = invincibleShader;
textureRender.material.shader = shader1;
meshRenderer.sharedMaterial.shader = shader1;
}
void OnMeshDataReceived(object meshDataObject)
{
MeshData meshData = (MeshData)meshDataObject;
mesh = meshData.CreateMesh();
hasMesh = true;
if (updateCallback != null)
{
updateCallback();
}
}
/// <summary>
/// Render the chunk mesh data
/// </summary>
private void RenderChunkMesh()
{
if (MeshMode != MeshingModes.ColliderOnly)
{
meshFilter.mesh = meshData.CreateMesh();
}
if (MeshMode != MeshingModes.MeshOnly)
{
meshCollider.sharedMesh = meshData.CreateColliderMesh();
}
}
public void RenderHeightmap(float[,] heightmap)
{
this.heightmap = heightmap;
mf = GetComponent <MeshFilter>();
mr = GetComponent <MeshRenderer>();
MeshData meshData = MeshGenerator.GenerateTerrainMesh(heightmap, 0, false);
Mesh newMesh = meshData.CreateMesh(true);
mf.sharedMesh = newMesh;
}
void OnMeshDataReceived(MeshTaskInfo info)
{
MeshData meshData = info.meshData;
//主线程回调
isWaitForData = false;
mesh = meshData.CreateMesh();// TODO pool mesh
DictionaryPool <MeshData> .Return(meshData);
hasMesh = true;
updateCallback();
}
public void UpdateMesh(float[,] heightMap, float heightMultiplier, AnimationCurve heightCurve, float uniformScale, TerrainRegion[] terrainRegions)
{
MeshData meshData = generateMeshData(heightMap, heightMultiplier, heightCurve, uniformScale);
meshFilter.sharedMesh = meshData.CreateMesh();
meshCollider.sharedMesh = meshFilter.sharedMesh;
// if(!Application.isPlaying) AssetDatabase.CreateAsset(meshRenderer.sharedMaterial, "Assets/Materials/Mat_Terrain.mat");
// if(!Application.isPlaying) AssetDatabase.CreateAsset(meshFilter.sharedMesh, "Assets/Models/TerrainMesh.asset");
UpdateMaterial(heightMultiplier, heightCurve, uniformScale, terrainRegions);
}
public void GenerateTreeMesh()
{
if (drawMesh)
{
m = TreeMeshGenerator.GenerateTreeMesh(lines, 1.05f, radius, thinning);
meshFilter.sharedMesh = m.CreateMesh();
}
else
{
meshFilter.sharedMesh = new Mesh();
}
}
public void DrawMesh(MeshData meshData, Texture2D texture)
{
MeshFilter meshFilter = GetComponent <MeshFilter>();
Mesh mesh = meshData.CreateMesh();
meshFilter.sharedMesh = mesh;
TextureRenderer renderer = GetComponent <TextureRenderer>();
renderer.DrawTexture(texture);
}
public List <Mesh> BuildMesh(List <Mesh> meshesToUse = null)
{
var meshes = new List <Mesh>();
int curTriangle = 0;
int curAvailableTriangle = triangle.Count;
int curAvailableVertex = kMaxVertex;
int curAvailableIndex = kMaxIndex;
int curLine = 0;
int curAvailableLine = line.Count;
int curMesh = 0;
while (true)
{
int numTriangle = ProcessShapes(ref curAvailableTriangle, ref curAvailableVertex, ref curAvailableIndex, MeshData.kVertexPerTriangle, MeshData.kIndexPerTriangle);
int numLine = ProcessShapes(ref curAvailableLine, ref curAvailableVertex, ref curAvailableIndex, MeshData.kVertexPerLine, MeshData.kIndexPerLine);
if (numTriangle > 0 || numLine > 0)
{
MeshData md = new MeshData(numLine, numTriangle);
if (numTriangle > 0)
{
md.Add(triangle, curTriangle, curTriangle + numTriangle);
curTriangle += numTriangle;
}
if (numLine > 0)
{
md.Add(line, curLine, curLine + numLine);
curLine += numLine;
}
meshes.Add(md.CreateMesh(
meshesToUse != null && meshesToUse.Count > curMesh
? meshesToUse[curMesh]
: null
));
curAvailableVertex = kMaxVertex;
curAvailableIndex = kMaxIndex;
++curMesh;
}
else
{
break;
}
}
if (meshesToUse != null)
{
for (int i = curMesh; i != meshesToUse.Count; ++i)
{
UnityEngine.Object.DestroyImmediate(meshesToUse[i]);
meshesToUse[i] = null;
}
}
return(meshes);
}
public void DrawMesh(MeshData meshData, Texture2D texture)
{
Mesh mesh = meshData.CreateMesh();
//Updating the collider causes the program to slow down a lot! Be aware!
meshCollider.sharedMesh = mesh;
meshCollider.enabled = false;
meshCollider.enabled = true;
meshFilter.sharedMesh = mesh;
meshRender.sharedMaterial.mainTexture = texture;
}
public override void DrawNodeProperties(Rect viewRect)
{
base.DrawNodeProperties(viewRect);
EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField("NoiseMap");
EditorGUILayout.LabelField("[MAP TEXTURE]");
if (texture != null)
{
GUI.DrawTexture(new Rect(50f, 100f, 200, 200), texture, ScaleMode.ScaleToFit, true, 0.0F);
}
GUI.Label(new Rect(50f, 320f, 200, 20), "Select Plane");
terrain = (GameObject)EditorGUI.ObjectField(new Rect(50f, 340f, 200, 16), terrain, typeof(GameObject), true);
GUI.Label(new Rect(50f, 400f, 200, 20), "Height Multiplier");
heightMultiplier = GUI.HorizontalSlider(new Rect(50f, 420f, 200, 20), heightMultiplier, -100f, 100f);
GUI.Label(new Rect(50f, 440f, 200, 20), "Value : " + heightMultiplier.ToString());
if (GUI.Button(new Rect(50f, 360f, 200, 20), "Generate Terrain"))
{
MeshData terrainMesh = MeshGenerator.GenerateTerrainMesh(noiseMap, heightMultiplier);
terrain.GetComponent <MeshFilter>().sharedMesh = terrainMesh.CreateMesh();
if (terrain.GetComponent <MeshCollider>() != null)
{
DestroyImmediate(terrain.GetComponent <MeshCollider>());
}
terrain.AddComponent <MeshCollider>();
}
if (GUI.changed && terrain != null)
{
MeshData terrainMesh = MeshGenerator.GenerateTerrainMesh(noiseMap, heightMultiplier);
terrain.GetComponent <MeshFilter>().sharedMesh = terrainMesh.CreateMesh();
if (terrain.GetComponent <MeshCollider>() != null)
{
DestroyImmediate(terrain.GetComponent <MeshCollider>());
}
terrain.AddComponent <MeshCollider>();
}
EditorGUILayout.EndVertical();
}
public static Mesh GeneratePolygonMesh(Vector3[] points)
{
MeshData meshData = new MeshData(points.Length);
meshData.vertices = points;
for (int i = 1; i < points.Length - 1; i++)
{
meshData.AddTriangle(0, i, i + 1);
}
return(meshData.CreateMesh());
}
void updateMesh(int lod, MeshFilter mf, float[,] noiseMap, float interval2)
{
if (mf.sharedMesh != null)
{
mf.sharedMesh.Clear();
}
MeshData mesh = PlaneGenerator.Generate(interval2 * 2, interval2 * 2, textQual / lod - 2, textQual / lod - 2);
mesh.vertices = addNormalNoise(mesh.vertices, noiseMap, meshHeightMultiplier, false);
mf.sharedMesh = mesh.CreateMesh();
}
public void MakeLowPoly()
{
MeshFilter filter = GetComponent <MeshFilter>();
if (filter == null)
{
return;
}
MeshData meshData = new MeshData(filter, true);
filter.sharedMesh = meshData.CreateMesh();
}
public void Generate(TerrainConfig config) {
config.MapHeight += 1;
config.MapWidth += 1;
Config = config;
float[,] noiseMap = Noise.GenerateNoiseMap(
config.MapWidth,
config.MapHeight,
config.Seed,
config.NoiseScale,
config.Octaves,
config.Persistance,
config.Lacunarity,
config.Offset
);
Color[] colorMap = new Color[config.MapWidth * config.MapHeight];
for (int y = 0; y < config.MapHeight; y++) {
for (int x = 0; x < config.MapWidth; x++) {
float currentHeight = noiseMap[x, y];
for (int i = 0; i < TerrainTypes.Length; i++) {
if (currentHeight <= TerrainTypes[i].Height) {
colorMap[y * config.MapWidth + x] = TerrainTypes[i].Color;
//print (y * config.MapWidth + x);
break;
}
}
}
}
int width = noiseMap.GetLength(0);
int height = noiseMap.GetLength(1);
float topLeftX = (width - 1) / -2f;
float topLeftZ = (height - 1) / 2f;
MeshData meshData = new MeshData(width, height);
int vertexIndex = 0;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
meshData.Vertices[vertexIndex] = new Vector3((topLeftX + x) / 4, 0, (topLeftZ - y) / 4);
meshData.Uvs[vertexIndex] = new Vector2((x / (float) width), (y / (float) height));
if (x < width - 1 && y < height - 1) {
meshData.AddTriangle(vertexIndex, vertexIndex + width + 1, vertexIndex + width);
meshData.AddTriangle(vertexIndex + width + 1, vertexIndex, vertexIndex + 1);
}
vertexIndex++;
}
}
Texture = new Texture2D(width, height);
Texture.filterMode = FilterMode.Point;
Texture.wrapMode = TextureWrapMode.Clamp;
Texture.SetPixels(colorMap);
Texture.Apply();
Mesh finalMesh = meshData.CreateMesh();
GetComponent<MeshFilter>().sharedMesh = finalMesh;
GetComponent<MeshRenderer>().material.mainTexture = Texture;
GetComponent<MeshCollider>().sharedMesh = finalMesh;
}
public void DrawMesh(MeshData meshData)
{
meshFilter.sharedMesh = meshData.CreateMesh();
meshFilter.transform.localScale = Vector3.one * FindObjectOfType<MapGenerator>().terrainData.uniformScale;
}
void OnMeshDataReceived(MeshData meshData) {
mesh = meshData.CreateMesh ();
hasMesh = true;
updateCallback ();
}
public void DrawMesh(MeshData meshData, Texture2D texture)
{
meshFilter.sharedMesh = meshData.CreateMesh();
//meshRenderer.sharedMaterial.mainTexture = texture;
}
void OnMeshDataReceived(MeshData meshData) {
meshFilter.mesh = meshData.CreateMesh ();
}
void OnMeshDataReceived(MeshData meshData)
{
mesh = meshData.CreateMesh();
hasMesh = true;
}
