public List <MeshInfos> Update(int verticesMax)
{
int N = xyzList.Count;
List <MeshInfos> meshList = new List <MeshInfos>();
for (int st = 0; st < N; st += verticesMax)
{
int len = verticesMax;
if (len > N - st)
{
len = N - st;
}
MeshInfos mesh = new MeshInfos();
mesh.vertexCount = len;
mesh.vertices = new Vector3[len];
mesh.normals = new Vector3[len];
mesh.colors = new Color[len];
for (int i = 0; i < len; i++)
{
mesh.vertices[i] = (Vector3)xyzList[st + i];
mesh.normals[i] = (Vector3)norList[st + i];
mesh.colors[i] = (Color)rgbList[st + i];
}
meshList.Add(mesh);
}
return(meshList);
}
public static void getMesh(ref List <MeshInfos> meshList, int vMax)
{
unsafe
{
if (meshList == null)
{
meshList = new List <MeshInfos>();
}
byte *ptr = (byte *)callUpdate();
int size = *((int *)ptr) * 3;
ptr = ptr + 4;
int meshId = 0;
for (int st = 0; st < size; st += vMax, meshId++)
{
if (meshId >= meshList.Count)
{
meshList.Add(new MeshInfos());
}
MeshInfos mesh = meshList[meshId];
int len = vMax;
if (size - st < len)
{
len = size - st;
}
if (mesh.vertexCount != len)
{
mesh.vertexCount = len;
mesh.vertices = new Vector3[len];
mesh.colors = new Color[len];
}
Parallel.For(0, len, i => {
int id = (st + i) * POINT_BYTES;
byte *p = ptr + id;
mesh.vertices[i].x = *((float *)p + 0);
mesh.vertices[i].y = *((float *)p + 1);
mesh.vertices[i].z = *((float *)p + 2);
mesh.colors[i].r = (float)(*(p + 12)) / 255;
mesh.colors[i].g = (float)(*(p + 13)) / 255;
mesh.colors[i].b = (float)(*(p + 14)) / 255;
});
}
while (meshId < meshList.Count)
{
meshList.Remove(meshList[meshId]);
}
}
}
public static void getMesh(ref List <MeshInfos> meshList, int vMax)
{
unsafe
{
if (ptr == null)
{
return;
}
int size = *((int *)ptr) * 3;
ptr = ptr + 4;
int meshId = 0;
for (int st = 0; st < size; st += vMax / 2, meshId++)
{
if (meshId >= meshList.Count)
{
MeshInfos newMesh = new MeshInfos();
newMesh.vertexCount = vMax;
newMesh.vertices = new Vector3[vMax];
newMesh.colors = new Color[vMax];
meshList.Add(newMesh);
}
MeshInfos mesh = meshList[meshId];
int len = Math.Max(0, Math.Min(size - st, vMax / 2));
Parallel.For(0, len / 3, i => {
byte *p0 = ptr + (st + i * 3) * POINT_BYTES;
byte *p1 = p0 + POINT_BYTES;
byte *p2 = p1 + POINT_BYTES;
int i6 = i * 6;
mesh.vertices[i6 + 0] = *((Vector3 *)p0);
mesh.vertices[i6 + 1] = *((Vector3 *)p1);
mesh.vertices[i6 + 2] = *((Vector3 *)p2);
mesh.vertices[i6 + 3] = (mesh.vertices[i6 + 0] + mesh.vertices[i6 + 1]) * 0.5f;
mesh.vertices[i6 + 4] = (mesh.vertices[i6 + 1] + mesh.vertices[i6 + 2]) * 0.5f;
mesh.vertices[i6 + 5] = (mesh.vertices[i6 + 2] + mesh.vertices[i6 + 0]) * 0.5f;
mesh.colors[i6 + 0].r = (float)(*(p0 + 12)) / 255;
mesh.colors[i6 + 0].g = (float)(*(p0 + 13)) / 255;
mesh.colors[i6 + 0].b = (float)(*(p0 + 14)) / 255;
mesh.colors[i6 + 3].r = (float)(*(p0 + 16)) / 255;
mesh.colors[i6 + 3].g = (float)(*(p0 + 17)) / 255;
mesh.colors[i6 + 3].b = (float)(*(p0 + 18)) / 255;
mesh.colors[i6 + 1].r = (float)(*(p1 + 12)) / 255;
mesh.colors[i6 + 1].g = (float)(*(p1 + 13)) / 255;
mesh.colors[i6 + 1].b = (float)(*(p1 + 14)) / 255;
mesh.colors[i6 + 4].r = (float)(*(p1 + 16)) / 255;
mesh.colors[i6 + 4].g = (float)(*(p1 + 17)) / 255;
mesh.colors[i6 + 4].b = (float)(*(p1 + 18)) / 255;
mesh.colors[i6 + 2].r = (float)(*(p2 + 12)) / 255;
mesh.colors[i6 + 2].g = (float)(*(p2 + 13)) / 255;
mesh.colors[i6 + 2].b = (float)(*(p2 + 14)) / 255;
mesh.colors[i6 + 5].r = (float)(*(p2 + 16)) / 255;
mesh.colors[i6 + 5].g = (float)(*(p2 + 17)) / 255;
mesh.colors[i6 + 5].b = (float)(*(p2 + 18)) / 255;
});
Parallel.For(len * 2, vMax, i => {
mesh.vertices[i].Set(0, 0, 0); //mesh.colors[i] = new Color();
});
mesh.exist = true;
}
for (int id = meshId; id < meshList.Count; id++)
{
MeshInfos mesh = meshList[id];
if (mesh.exist)
{
Parallel.For(0, vMax, i => {
mesh.vertices[i].Set(0, 0, 0); //mesh.colors[i] = new Color();
});
mesh.exist = false;
}
}
}
}
public void Generate()
{
if (meshArray == null || meshArray.Length != meshList.Count)
{
if (meshArray != null)
{
foreach (Mesh mesh in meshArray)
{
if (mesh != null)
{
Destroy(mesh);
}
}
}
meshArray = new Mesh[meshList.Count];
}
for (int i = 0; i < meshList.Count; i++)
{
MeshInfos meshInfo = meshList[i];
int count = meshInfo.vertexCount;
if (meshArray[i] == null)
{
meshArray[i] = new Mesh();
}
Mesh mesh = meshArray[i];
if (mesh.vertexCount != meshInfo.vertices.Length)
{
mesh.Clear();
}
mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 16f);
//System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
//stopwatch.Start();
mesh.vertices = meshInfo.vertices;
mesh.colors = meshInfo.colors;
//stopwatch.Stop();
//Debug.Log(stopwatch.Elapsed.TotalMilliseconds);
if (mesh.GetIndices(0) != null && mesh.GetIndices(0).Length != count)
{
int[] indices = new int[count];
int[] tris = new int[count];
Parallel.For(0, count, j => {
indices[j] = j;
int res = j % 3;
if (res == 0)
{
tris[j] = j;
}
else if (res == 1)
{
tris[j] = j + 1;
}
else
{
tris[j] = j - 1;
}
});
mesh.SetIndices(indices, MeshTopology.Points, 0);
mesh.SetTriangles(tris, 0);
}
}
if (transform.childCount == meshArray.Length)
{
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
child.GetComponent <MeshFilter>().mesh = meshArray[i];
}
}
else
{
for (int i = transform.childCount - 1; i >= 0; i--)
{
Transform child = transform.GetChild(i);
DestroyImmediate(child.gameObject);
}
for (int i = 0; i < meshArray.Length; i++)
{
CreateGameObjectWithMesh(meshArray[i], gameObject.name + "_" + i, transform);
}
}
}
public void Generate()
{
if (meshArray == null || meshArray.Length != meshList.Count)
{
if (meshArray != null)
{
foreach (Mesh mesh in meshArray)
{
if (mesh != null)
{
Destroy(mesh);
}
}
}
meshArray = new Mesh[meshList.Count];
}
for (int i = 0; i < meshList.Count; i++)
{
MeshInfos meshInfo = meshList[i];
int count = meshInfo.vertexCount;
int[] indices = new int[count];
Parallel.For(0, count, j => {
indices[j] = j;
});
if (meshArray[i] == null)
{
meshArray[i] = new Mesh();
}
Mesh mesh = meshArray[i];
if (mesh.vertexCount != meshInfo.vertices.Length)
{
mesh.Clear();
}
mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 16f);
mesh.vertices = meshInfo.vertices;
mesh.normals = meshInfo.normals;
mesh.colors = meshInfo.colors;
mesh.SetIndices(indices, MeshTopology.Points, 0);
}
if (transform.childCount == meshArray.Length)
{
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
child.GetComponent <MeshFilter>().mesh = meshArray[i];
}
}
else
{
for (int i = transform.childCount - 1; i >= 0; i--)
{
Transform child = transform.GetChild(i);
DestroyImmediate(child.gameObject);
}
for (int i = 0; i < meshArray.Length; i++)
{
CreateGameObjectWithMesh(meshArray[i], gameObject.name + "_" + i, transform);
}
}
}
public void Generate()
{
List <MeshInfos> generateList = meshList;
if (meshArray == null || meshArray.Length != generateList.Count)
{
if (meshArray != null)
{
foreach (Mesh mesh in meshArray)
{
if (mesh != null)
{
Destroy(mesh);
}
}
}
meshArray = new Mesh[generateList.Count];
}
for (int i = 0; i < generateList.Count; i++)
{
if (meshArray[i] == null)
{
meshArray[i] = new Mesh();
}
MeshInfos meshInfo = generateList[i];
Mesh mesh = meshArray[i];
if (mesh.vertexCount != meshInfo.vertices.Length)
{
mesh.Clear();
mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 16f);
mesh.vertices = meshInfo.vertices;
mesh.colors = meshInfo.colors;
mesh.SetIndices(indicesMax, MeshTopology.Points, 0);
mesh.SetTriangles(trisMax, 0);
}
else
{
mesh.vertices = meshInfo.vertices;
mesh.colors = meshInfo.colors;
}
}
if (transform.childCount == meshArray.Length)
{
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
child.GetComponent <MeshFilter>().mesh = meshArray[i];
}
}
else
{
for (int i = transform.childCount - 1; i >= 0; i--)
{
Transform child = transform.GetChild(i);
DestroyImmediate(child.gameObject);
}
for (int i = 0; i < meshArray.Length; i++)
{
CreateGameObjectWithMesh(meshArray[i], gameObject.name + "_" + i, transform);
}
}
}
