public override void SetMeshData(RawMesh mesh, int[] vertexGroup, int groupCount, TriangleGroup triangleGroup)
{
//Calculate average for bias.
var sum = new Vector3[groupCount];
var count = new int[groupCount];
for (int i = 0; i < mesh.Vertices.Length; ++i)
{
var g = vertexGroup[i];
sum[g] += mesh.Vertices[i];
count[g] += 1;
}
//Run qf solver
_results = new Vector3[groupCount];
var c = new QFCoefficient();
for (int i = 0; i < groupCount; ++i)
{
c.Reset();
var nFaces = 0;
var vertices = Enumerable.Range(0, vertexGroup.Length).Where(ii => vertexGroup[ii] == i).ToArray();
foreach (var tt in triangleGroup.GetExternalTriangles(i))
{
var v1 = mesh.Vertices[mesh.Triangles[tt].Va];
var v2 = mesh.Vertices[mesh.Triangles[tt].Vb];
var v3 = mesh.Vertices[mesh.Triangles[tt].Vc];
var n = Vector3.Normalize(Vector3.Cross(v2 - v1, v3 - v1));
c.AddPlane(v1, n);
nFaces += 1;
}
c.AddBias(sum[i] / count[i], nFaces * 0.01f + 0.01f);
_results[i] = QFSolver.Solve(c);
}
}
public void RegenerateMesh()
{
// Stopwatch sw = new Stopwatch();
// sw.Start();
RawMesh rawMesh = MeshGenerator.GenerateMesh(Chunk);
// sw.Stop();
// UnityEngine.Debug.LogFormat(
// "{5} Generation took: {0}us for {1} verts and {2} triangles and {3} objects, taking avg {4}us per obj.",
// sw.ElapsedTicks / 10d,
// rawMesh.Vertices.Length,
// rawMesh.Triangles.Length,
// Chunk.Blocks.Length,
// (sw.ElapsedTicks / 10d) / Chunk.Blocks.Length,
// name
// );
Mesh localmesh = meshFilter.mesh;
localmesh.Clear();
localmesh.vertices = rawMesh.Vertices;
localmesh.uv = rawMesh.Uv;
localmesh.triangles = rawMesh.Triangles;
localmesh.RecalculateNormals();
MeshCollider.sharedMesh = localmesh;
}
private void AppendFace(RawMesh mesh, BaseBlock block, Face face, int xPos, int yPos, int zPos)
{
if (!block.CanBeRendered)
{
return;
}
int faceOrder = face.GetHashCode();
RawMesh tMesh = block.GetDrawData();
int sideCount = block.Sides;
int faceVertexCount = block.VertexCount / sideCount;
int faceIndicesCount = block.Indices / sideCount;
int faceUvCount = block.UvCount / sideCount;
//vertex
for (int offset = 0; offset < faceVertexCount; offset++)
{
mesh.Vertices[mesh.vertexCount + offset] = tMesh.Vertices[faceOrder * 4 + offset] + new Vector3(xPos, yPos, zPos);
}
//triangle
for (int offset = 0; offset < faceIndicesCount; offset++)
{
mesh.Triangles[mesh.trianglesCount + offset] = tMesh.Triangles[faceOrder * 6 + offset] + mesh.vertexCount - faceOrder * 4;
}
//uvs
//todo doesnt support multiple face textures
for (int offset = 0; offset < faceUvCount; offset++)
{
mesh.Uv[mesh.uvCount + offset] = tMesh.Uv[faceOrder * 4 + offset];
}
mesh.vertexCount += 4;
mesh.trianglesCount += 6;
mesh.uvCount += 4;
}
//Warning: not thread safe!
public static float GetSampleAverage(RawMesh mesh, float ratio = 2f, int sample = 3)
{
var total = 0f;
for (int s = 0; s < sample; ++s)
{
var tt = _rand.Next(mesh.Triangles.Length);
total += MinDistance(mesh, tt);
}
return(total / sample * ratio);
}
private static float MinDistance(RawMesh mesh, int t)
{
var va = mesh.Vertices[mesh.Triangles[t].Va];
var vb = mesh.Vertices[mesh.Triangles[t].Vb];
var vc = mesh.Vertices[mesh.Triangles[t].Vc];
var da = (vb - vc).LengthSquared();
var db = (vc - va).LengthSquared();
var dc = (va - vb).LengthSquared();
return((float)Math.Sqrt(Math.Min(da, Math.Min(db, dc))));
}
public override void SetMeshData(RawMesh mesh, int[] vertexGroup, int groupCount, TriangleGroup triangleGroup)
{
_sum = new Vector3[groupCount];
_count = new int[groupCount];
for (int i = 0; i < mesh.Vertices.Length; ++i)
{
var g = vertexGroup[i];
_sum[g] += mesh.Vertices[i];
_count[g] += 1;
}
}
public override void Load()
{
Entity cam = EntityFactory.CreateEntity();
cam.name = "cam";
cam.AddComponent(new Camera());
Entity ent = EntityFactory.CreateEntity();
ent.AddComponent(new Move());
ent.AddComponent(new MeshRenderer());
MeshTexture texture = MeshTexture.LoadTexture("Res/Images/bobross.png");
ent.GetComponent <MeshRenderer>().texturedMesh = new TexturedMesh(RawMesh.LoadToVao(v1, textureCoords, indices), texture);
base.Load();
}
public RawMesh Generate()
{
var ret = new RawMesh
{
Vertices = _vertices.ToArray(),
Triangles = new RawMesh.Triangle[_indices.Count / 3],
};
for (var i = 0; i < ret.Triangles.Length; ++i)
{
ret.Triangles[i] = new RawMesh.Triangle
{
Va = _indices[i * 3 + 0],
Vb = _indices[i * 3 + 1],
Vc = _indices[i * 3 + 2],
};
}
return(ret);
}
static int Main(string [] args)
{
bool error = false;
foreach (var s in args)
{
switch (s)
{
case "--dump":
Quickhull.dump_faces = true;
break;
default:
BinaryReader bw;
if (s.Substring(s.Length - 3) == ".gz")
{
bw = new BinaryReader(new GZipStream(File.Open(s, FileMode.Open, FileAccess.Read), CompressionMode.Decompress));
}
else
{
bw = new BinaryReader(File.Open(s, FileMode.Open, FileAccess.Read));
}
var mesh = new RawMesh(0);
mesh.Read(bw);
Debug.Log($"{s} - {mesh.verts.Length} points");
bw.Close();
var qh = new Quickhull(mesh);
var timer = System.Diagnostics.Stopwatch.StartNew();
var hull = qh.GetHull();
error |= qh.error;
timer.Stop();
Debug.Log($" - {hull.Count} faces {timer.ElapsedMilliseconds}ms");
break;
}
}
return(error ? 1 : 0);
}
public TriangleGroup(RawMesh mesh, int[] vertexGroup, int groupCount)
{
_mesh = mesh;
_vertexGroup = vertexGroup;
_internalTriangles = Enumerable.Repeat(-1, groupCount).ToArray();
_externalTriangles = Enumerable.Repeat(-1, groupCount).ToArray();
for (int i = 0; i < _mesh.Triangles.Length; ++i)
{
var tt = _mesh.Triangles[i];
var ia = vertexGroup[tt.Va];
var ib = vertexGroup[tt.Vb];
var ic = vertexGroup[tt.Vc];
if (ia == ib && ia == ic)
{
Append(i, ref _internalTriangles[ia]);
}
else
{
Append(i, ref _externalTriangles[ia]);
if (ib != ia)
{
Append(i, ref _externalTriangles[ib]);
}
if (ic != ia && ic != ib)
{
Append(i, ref _externalTriangles[ic]);
if (ib != ia)
{
Append(i, ref _allExternalTriangles);
}
}
}
}
}
public TexturedMesh(RawMesh _mesh, MeshTexture _texture)
{
this.rawMesh = _mesh;
this.texture = _texture;
}
public MeshSimplifier(RawMesh mesh, float clusterSize)
{
_mesh = mesh;
_clusterSize = clusterSize;
}
public abstract void SetMeshData(RawMesh mesh, int[] vertexGroup, int groupCount, TriangleGroup triangleGroup);
