protected override Mesh DoProcessing(MeshSemplifierData data)
{
MeshSimplifier simplifier = new MeshSimplifier(data.mesh);
simplifier.SimplifyMesh(data.Force);
return(simplifier.ToMesh());
}
// Start is called before the first frame update
void Start()
{
gameObject.AddComponent <MeshFilter>(); // Creation d'un composant MeshFilter qui peut ensuite être visualisé
gameObject.AddComponent <MeshRenderer>();
grid = new Grid(nbCubesPerRowsOnGrid, new Vector3(-1.25f, -1.25f, -1.25f), new Vector3(1.25f, 1.25f, 1.25f));
grid.SetDrawGrid(true);
ReadFile();
//WriteFile();
CenterAndNormalizeObject();
mshSimplifier = new MeshSimplifier(vertices, grid);
mshSimplifier.PartitionVerticesInGrid();
grid.SetActiveCubesInGrid();
mshSimplifier.AverageVerticesInCubes();
//grid.LogVerticesOfCubes();
ReindexTriangles();
RemoveDegeneratedTriangles();
msh = new Mesh();
msh.vertices = vertices;
msh.triangles = triangles;
gameObject.GetComponent <MeshFilter>().mesh = msh; // Remplissage du Mesh et ajout du matériel
gameObject.GetComponent <MeshRenderer>().material = mat;
}
MeshSimplifier EasySquares(int w) {
int verticesPerRow = w + 1;
Func<int, int, int> VertIdx = (x, y) => verticesPerRow * y + x;
List<Vec3f> vertices = new List<Vec3f>();
List<int> indices = new List<int>();
for (int y = 0; y < verticesPerRow; ++y) {
for (int x = 0; x < verticesPerRow; ++x) {
Vec3f v = new Vec3f();
v.x = x;
v.y = y;
v.z = 0;
vertices.Add(v);
}
}
for (int y = 0; y < w; ++y) {
for (int x = 0; x < w; ++x) {
indices.Add(VertIdx(x, y));
indices.Add(VertIdx(x + 1, y));
indices.Add(VertIdx(x + 1, y + 1));
indices.Add(VertIdx(x, y));
indices.Add(VertIdx(x + 1, y + 1));
indices.Add(VertIdx(x, y + 1));
}
}
MeshSimplifier m = new MeshSimplifier(vertices.ToArray(), indices.ToArray());
return m;
}
static void TestMeshWithHole()
{
int width = 3;
int verticesPerRow = width + 1;
Func <int, int, int> VertIdx = (x, y) => verticesPerRow * y + x;
List <Vec3f> vertices = new List <Vec3f>();
List <int> indices = new List <int>();
for (int y = 0; y < verticesPerRow; ++y)
{
for (int x = 0; x < verticesPerRow; ++x)
{
Vec3f v = new Vec3f();
v.x = x;
v.y = y;
v.z = 0;
vertices.Add(v);
}
}
for (int y = 0; y < width; ++y)
{
for (int x = 0; x < width; ++x)
{
if (x == 1 && y == 1)
{
// Make a hole
continue;
}
indices.Add(VertIdx(x, y));
indices.Add(VertIdx(x + 1, y));
indices.Add(VertIdx(x + 1, y + 1));
indices.Add(VertIdx(x, y));
indices.Add(VertIdx(x + 1, y + 1));
indices.Add(VertIdx(x, y + 1));
}
}
MeshSimplifier m = new MeshSimplifier(vertices.ToArray(), indices.ToArray());
m.SaveToObj("out_full.obj");
Console.WriteLine("Triangle count: {0}", m.Edges.Length / 3);
m.Simplify();
m.SaveToObj("out_simple.obj");
m.Compact();
Console.WriteLine("Triangle count: {0}", m.Edges.Length / 3);
Console.Write("\nPress any key to continue ... ");
Console.ReadKey();
}
public void SimplifyMesh(Transform t, float mean)
{
MeshSimplifier meshSimplifier = new MeshSimplifier();
float diff = t.GetComponent <MeshFilter>().mesh.triangles.Length / mean;
float quality = 2 / diff;
Mesh originalMesh;
if (t.GetComponent <MeshFilter>().mesh.triangles.Length / mean >= 3)
{
originalMesh = t.gameObject.GetComponent <MeshFilter>().mesh;
meshSimplifier.Initialize(originalMesh);
meshSimplifier.SimplifyMesh(quality);
Mesh destMesh = meshSimplifier.ToMesh();
t.gameObject.GetComponent <MeshFilter>().mesh = destMesh;
}
}
IEnumerator Simplify(Mesh inputMesh, Mesh outputMesh, float quality)
{
var meshSimplifier = new MeshSimplifier();
meshSimplifier.Vertices = inputMesh.vertices;
meshSimplifier.Normals = inputMesh.normals;
meshSimplifier.Tangents = inputMesh.tangents;
meshSimplifier.UV1 = inputMesh.uv;
meshSimplifier.UV2 = inputMesh.uv2;
meshSimplifier.UV3 = inputMesh.uv3;
meshSimplifier.UV4 = inputMesh.uv4;
meshSimplifier.Colors = inputMesh.colors;
var triangles = new int[inputMesh.subMeshCount][];
for (var submesh = 0; submesh < inputMesh.subMeshCount; submesh++)
{
triangles[submesh] = inputMesh.GetTriangles(submesh);
}
meshSimplifier.AddSubMeshTriangles(triangles);
meshSimplifier.SimplifyMesh(quality);
outputMesh.vertices = meshSimplifier.Vertices;
outputMesh.normals = meshSimplifier.Normals;
outputMesh.tangents = meshSimplifier.Tangents;
outputMesh.uv = meshSimplifier.UV1;
outputMesh.uv2 = meshSimplifier.UV2;
outputMesh.uv3 = meshSimplifier.UV3;
outputMesh.uv4 = meshSimplifier.UV4;
outputMesh.colors = meshSimplifier.Colors;
outputMesh.subMeshCount = meshSimplifier.SubMeshCount;
for (var submesh = 0; submesh < outputMesh.subMeshCount; submesh++)
{
outputMesh.SetTriangles(meshSimplifier.GetSubMeshTriangles(submesh), submesh);
}
yield break;
}
static void TestSimplify4()
{
//var voxels = MagicaFile.Load(@"C:\Projects\FloofBox\uRogue\Assets\VoxModels\cathedral-2.vox");
var voxels = MagicaFile.Load(@"..\..\..\..\Assets\Vox\TransparencyTest.vox");
var boxes = BoxMaker.MakeBoxes(voxels[0]);
Console.WriteLine("{0} boxes made", boxes.Count);
MeshSimplifier ms = Mesher.VoxelsToMeshFull(voxels[0]);
Console.WriteLine("Triangles before reduction: " + (ms.Edges.Length / 3));
ms.Simplify();
ms.Compact();
Console.WriteLine("Triangles after reduction: " + (ms.Edges.Length / 3));
int[] tris;
Vec3f[] rawPos;
Vec3f[] rawNormals;
Vec2f[] rawUvs;
VoxelSet <Vec4b> atlas;
ms.GetMesh(voxels[0], out tris, out rawPos, out rawNormals, out rawUvs, out atlas);
Bitmap bmp = new Bitmap(atlas.Size.x, atlas.Size.y);
for (int y = 0; y < atlas.Size.y; ++y)
{
for (int x = 0; x < atlas.Size.x; ++x)
{
bmp.SetPixel(x, y, Color.FromArgb(
atlas[x, y, 0].x,
atlas[x, y, 0].y,
atlas[x, y, 0].z
));
}
}
bmp.Save("Atlas.png");
}
public void TestTJunctionReduce() {
int w = 3;
int verticesPerRow = w + 1;
Func<int, int, int> VertIdx = (x, y) => verticesPerRow * y + x;
List<Vec3f> vertices = new List<Vec3f>();
for (int y = 0; y < verticesPerRow; ++y) {
for (int x = 0; x < verticesPerRow; ++x) {
Vec3f v = new Vec3f();
v.x = x;
v.y = y;
v.z = 0;
vertices.Add(v);
}
}
int[] indices = {
1, 2, 10,
2, 3, 10,
3, 11, 10,
// Becomes degenerate
1, 10, 5,
// Edge to collapse is 10 to 9
5, 10, 9,
4, 5, 9,
4, 9, 8
};
MeshSimplifier m = new MeshSimplifier(vertices.ToArray(), indices);
Assert.IsFalse(m.CanCollapse(12));
Assert.IsFalse(m.CanCollapse(13));
Assert.IsFalse(m.CanCollapse(14));
}
void Start()
{
// Get random position on mesh
edge = new MeshHelper();
constellationList.Add(ConstellationType.Ursa, Ursa);
constellationList.Add(ConstellationType.Leo, Leo);
constellationList.Add(ConstellationType.Tiger, Tiger);
constellationList.Add(ConstellationType.Orion, Orion);
// attempt to simplify constellation meshes
// https://github.com/Whinarn/UnityMeshSimplifier
meshSimplifier = new UnityMeshSimplifier.MeshSimplifier();
// Preprocess all meshes to have varying levels of complexity
PreprocessMeshes();
// get a constellation to start to avoid initialization errors
ConstellationShape = edge.GetRandomConstellation(constellationList, data.constellationNames);
constellationRenderer = ConstellationShape.GetComponentInChildren <Renderer>();
}
private void _generate_lod_versions(Mesh mesh, List <Mesh> list, int lod_count)
{
// The first instance in the LOD array is the default mesh.
list.Add(mesh);
// Initialize the mesh simplifier.
MeshSimplifier simplifier = new MeshSimplifier();
// Iterate through each LOD version.
for (int i = 1; i < lod_count; i++)
{
// Initialize the mesh simplifier with the previous LOD version mesh.
simplifier.Initialize(list[i - 1]);
// Simplify by a given percentage (0.5 = 50% by default).
simplifier.SimplifyMesh(0.5f);
// Get the resulting mesh.
Mesh destMesh = simplifier.ToMesh();
// Set the resulting mesh to the current LOD version.
list.Add(destMesh);
}
}
static void Main()
{
const float BlockSize = 0.02f;
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var form = new Form();
form.ClientSize = new Size(800, 600);
var func = MakeFunction(1 / BlockSize);
var meshGenerator = new DCSolver(func, (int)(4 / BlockSize));
var rawMesh = meshGenerator.Solve();
rawMesh = new MeshSimplifier(rawMesh, ClusterSizeHelper.GetSampleAverage(rawMesh, 3)).Run();
var m = NormalMesh.MakeNormal(rawMesh);
using (var device = LightDevice.Create(form))
{
var target = new RenderTargetList(device.GetDefaultTarget(Color.AliceBlue.WithAlpha(1)), device.CreateDepthStencilTarget());
target.Apply();
Pipeline pipeline = device.CompilePipeline(InputTopology.Triangle,
ShaderSource.FromResource("Viewer.Shader.fx", ShaderType.Vertex | ShaderType.Pixel));
pipeline.Apply();
var vertexConstant = pipeline.CreateConstantBuffer <Matrix4x4>();
pipeline.SetConstant(ShaderType.Vertex, 0, vertexConstant);
var input = pipeline.CreateVertexDataProcessor <Vertex>();
var vb = input.CreateImmutableBuffer(m.Vertices.Select(vv => new Vertex {
Position = new Vector4(m.Positions[vv.Position] * BlockSize, 1),
Normal = new Vector4(vv.Normal, 0),
}).ToArray());
var ib = pipeline.CreateImmutableIndexBuffer(m.Triangles.SelectMany(tt => new[] { tt.Va, tt.Vb, tt.Vc }).ToArray());
var camera = new Camera(new Vector3(10, 0, 0));
camera.SetForm(form);
var proj = device.CreatePerspectiveFieldOfView((float)Math.PI / 4).Transpose();
vertexConstant.Value = proj * camera.GetViewMatrix();
var pt = new Vector4(0, 0, 0, 0);
var r = Vector4.Transform(pt, vertexConstant.Value);
form.Show();
device.RunMultithreadLoop(delegate()
{
target.ClearAll();
camera.Step();
var view = camera.GetViewMatrix();
vertexConstant.Value = proj * view;
vertexConstant.Update();
ib.DrawAll(vb);
device.Present(true);
});
}
}
static void TestMesh()
{
int width = 16;
int verticesPerRow = width + 1;
Func <int, int, int> VertIdx = (x, y) => verticesPerRow * y + x;
List <Vec3f> vertices = new List <Vec3f>();
List <int> indices = new List <int>();
for (int y = 0; y < verticesPerRow; ++y)
{
for (int x = 0; x < verticesPerRow; ++x)
{
Vec3f v = new Vec3f();
v.x = x;
v.y = y;
v.z = 0;
vertices.Add(v);
}
}
for (int y = 0; y < width; ++y)
{
for (int x = 0; x < width; ++x)
{
indices.Add(VertIdx(x, y));
indices.Add(VertIdx(x + 1, y));
indices.Add(VertIdx(x + 1, y + 1));
indices.Add(VertIdx(x, y));
indices.Add(VertIdx(x + 1, y + 1));
indices.Add(VertIdx(x, y + 1));
}
}
MeshSimplifier m = new MeshSimplifier(vertices.ToArray(), indices.ToArray());
m.SaveToObj("out_full.obj");
int triangleCount = 0;
for (int i = 0; i < m.Edges.Length; i += 3)
{
if (m.Edges[i].vertexIdx >= 0)
{
triangleCount++;
}
else
{
Console.WriteLine("Bad edge at index: {0}", i);
}
}
m.Compact();
Console.WriteLine("Triangle count: {0}", triangleCount);
m.Simplify();
triangleCount = 0;
for (int i = 0; i < m.Edges.Length; i += 3)
{
if (m.Edges[i].vertexIdx >= 0)
{
triangleCount++;
for (int j = 0; j < 3; ++j)
{
Vec3f p = m.Points[m.Edges[i + j].vertexIdx];
Console.WriteLine("<{0}, {1}, {2}>", p.x, p.y, p.z);
}
Console.WriteLine();
}
}
m.SaveToObj("out_simple.obj");
m.Compact();
Console.WriteLine("Triangle count: {0}", triangleCount);
Console.Write("\nPress any key to continue ... ");
Console.ReadKey();
}
internal void createmesh(string meshname, Vector3[] newVertices, Vector3[] newNormals, Vector2[] newUV, int[] newTriangles, Transform objectParent)
{
Mesh mesh = new Mesh();
GameObject part = new GameObject(meshname);
part.AddComponent(typeof(MeshFilter));
part.AddComponent(typeof(MeshRenderer));
var renderer = part.GetComponent <MeshRenderer>();
renderer.material = materialDictionary[0].mat;
renderer.enabled = false;
renderer.receiveShadows = false;
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
foreach (MaterialPreference mp in materialDictionary)
{
if (mp.name == meshname.Split(' ')[0])
{
part.GetComponent <MeshRenderer>().material = mp.mat;
}
}
//part.GetComponent<MeshRenderer>().material = GetComponent<MeshRenderer>().material;
part.name = meshname;
part.GetComponent <MeshFilter>().mesh = mesh;
string meshparentname = meshname.Split(' ')[0];
if (parentObjects.ContainsKey(meshparentname))
{
part.transform.SetParent(parentObjects[meshparentname].transform);
allLayerObjects[meshparentname].Add(int.Parse(meshname.Split(' ')[1]), part);
}
else
{
GameObject parentobj = new GameObject(meshparentname);
parentObjects.Add(meshparentname, parentobj);
parentvisible.Add(meshparentname, true);
part.transform.SetParent(parentObjects[meshparentname].transform);
allLayerObjects.Add(meshparentname, new Dictionary <int, GameObject>());
allLayerObjects[meshparentname].Add(int.Parse(meshname.Split(' ')[1]), part);
parentobj.transform.SetParent(RootForObject.transform);
parentobj.transform.localPosition = Vector3.zero;
parentobj.transform.localScale = Vector3.one;
parentobj.transform.localRotation = Quaternion.identity;
}
part.transform.localPosition = Vector3.zero;
part.transform.localScale = Vector3.one;
part.transform.localRotation = Quaternion.identity;
mesh.vertices = newVertices;
mesh.normals = newNormals;
mesh.uv = newUV;
mesh.triangles = newTriangles;
MeshSimplifier meshSimplifier = new MeshSimplifier();
meshSimplifier.Initialize(mesh);
MeshSimplifierstruct msc = new MeshSimplifierstruct();
msc.MeshSimplifier = meshSimplifier;
msc.MeshFilter = part.GetComponent <MeshFilter>();
//lock (meshSimplifierQueueLock)
{
loader.meshSimplifierQueue.Enqueue(msc);
}
loader.simplifypossible = true;
}
