public DMesh3 getMesh() { BpcData pc = GetBakedPointCloud(); ulong size; byte[] data = GetPackedMesh(out size); Console.WriteLine($"Rawmesh size: {size}"); List <int> tris = new List <int>(); if (size > 0) { for (int position = 0; position < (int)size; position += 12) { tris.Add((int)BitConverter.ToUInt32(data, position)); tris.Add((int)BitConverter.ToUInt32(data, position + 4)); tris.Add((int)BitConverter.ToUInt32(data, position + 8)); } } DMesh3 dmesh = DMesh3Builder.Build <Vector3d, int, int>(pc.positions, tris); if (pc.colors.Count() > 0) { dmesh.EnableVertexColors(new Vector3f()); foreach (int idx in dmesh.VertexIndices()) { dmesh.SetVertexColor(idx, pc.colors.ElementAt(idx)); } } return(dmesh); }
private static void LoadAssetsAsMeshes(IList <Asset> assets, int trianglesLimit, double scale, Dictionary <Asset, DMesh3> destination) { if (destination == null) { return; } var meshBuilder = new DMesh3Builder() { NonManifoldTriBehavior = DMesh3Builder.AddTriangleFailBehaviors.DiscardTriangle }; var objReader = new OBJFormatReader(); var reader = new StandardMeshReader() { MeshBuilder = meshBuilder, ReadInvariantCulture = true }; //reader.AddFormatHandler(objReader); foreach (var asset in assets) { //var isMeshLoaded = objReader.ReadFile(asset.OpenAssetFile(), meshBuilder, null, new ParsingMessagesHandler((s, o) => {; })); var isMeshLoaded = reader.Read(asset.OpenAssetFile(), asset.FileFormat.ToString(), ReadOptions.Defaults); if (isMeshLoaded.code == IOCode.Ok) { var mesh = meshBuilder.Meshes.Last(); Reducer r = new Reducer(mesh) { PreserveBoundaryShape = true, }; r.ReduceToTriangleCount(trianglesLimit); MeshTransforms.Scale(mesh, scale); destination[asset] = mesh; } } }
void Start() { if (model != null) { mesh = model.sharedMesh; meshVertices = mesh.vertices; meshTriangles = mesh.triangles; for (int i = 0; i < meshVertices.Length; i++) { meshVertices[i] = model.transform.TransformPoint(meshVertices[i]); } binarySpacePartition = new BSP(mesh, 14); #if G3_USING_UNITY DMesh3Builder dMeshBuilder = new DMesh3Builder(); dMeshBuilder.AppendNewMesh(false, false, false, false); foreach (Vector3 vertex in meshVertices) { dMeshBuilder.AppendVertex(vertex.x, vertex.y, vertex.z); } for (int i = 0; i < meshTriangles.Length; i += 3) { dMeshBuilder.AppendTriangle(meshTriangles[i], meshTriangles[i + 1], meshTriangles[i + 2]); } g3MeshTree = new DMeshAABBTree3(dMeshBuilder.Meshes[0]); g3MeshTree.Build(); #endif } }
/// <summary> /// Convert unity Mesh to a g3.DMesh3. Ignores UV's. /// </summary> public static DMesh3 UnityMeshToDMesh(Mesh mesh) { Vector3[] mesh_vertices = mesh.vertices; Vector3f[] dmesh_vertices = new Vector3f[mesh_vertices.Length]; for (int i = 0; i < mesh.vertexCount; ++i) { dmesh_vertices[i] = mesh_vertices[i]; } Vector3[] mesh_normals = mesh.normals; if (mesh_normals != null) { Vector3f[] dmesh_normals = new Vector3f[mesh_vertices.Length]; for (int i = 0; i < mesh.vertexCount; ++i) { dmesh_normals[i] = mesh_normals[i]; } return(DMesh3Builder.Build(dmesh_vertices, mesh.triangles, dmesh_normals)); } else { return(DMesh3Builder.Build <Vector3f, int, Vector3f>(dmesh_vertices, mesh.triangles, null, null)); } }
/// <summary> /// This is basically a utility function, returns first mesh in file, with default options. /// </summary> static public DMesh3 ReadMesh(string sFilename) { DMesh3Builder builder = new DMesh3Builder(); IOReadResult result = ReadFile(sFilename, ReadOptions.Defaults, builder); return((result.code == IOCode.Ok) ? builder.Meshes[0] : null); }
private Task <DMesh3Builder> loadObj(string filename) { TaskCompletionSource <DMesh3Builder> tcs1 = new TaskCompletionSource <DMesh3Builder>(); Task <DMesh3Builder> t1 = tcs1.Task; t1.ConfigureAwait(false); // Start a background task that will complete tcs1.Task Task.Factory.StartNew(() => { DMesh3Builder meshBuilder = new DMesh3Builder(); try { IOReadResult result = StandardMeshReader.ReadFile(filename, new ReadOptions(), meshBuilder); } catch (Exception e) when( e is UnauthorizedAccessException || e is DirectoryNotFoundException || e is FileNotFoundException || e is NotSupportedException ) { Debug.LogError("Failed to Load" + filename + " : " + e.ToString()); meshBuilder = new DMesh3Builder(); } tcs1.SetResult(meshBuilder); }); return(t1); }
public override bool BuildOnMesh(DMesh3Builder meshBuilder) { MeshUtility.FillPolygon(meshBuilder, Parameters.BasementPoints .Select(p => new Vector3d(p.X, 0.0, p.Y)).ToList(), -Vector3f.AxisY); return(true); }
public override bool BuildOnMesh(DMesh3Builder meshBuilder) { var doorCopy = new DMesh3(Mesh, bCompact: true); if (FrontNormal == -Vector3d.AxisZ) { // trick to prevent 180 rotation FrontNormal += new Vector3d(0.0000001, 0.0, 0.0); } var meshWidth = doorCopy.GetBounds().Width; var meshHeight = doorCopy.GetBounds().Height; var widthScale = WidthLimit / meshWidth; var heightScale = HeightLimit / meshHeight; Quaterniond orientingQuaternion = new Quaterniond(Vector3d.AxisZ, FrontNormal); MeshTransforms.Rotate(doorCopy, Vector3d.Zero, orientingQuaternion); MeshTransforms.Scale(doorCopy, Math.Min(widthScale, heightScale)); MeshTransforms.Translate(doorCopy, Origin); meshBuilder.AppendNewMesh(doorCopy); meshBuilder.SetActiveMesh(0); return(true); }
//convert a MeshGeometry3D object into a DMesh object private static DMesh3 MeshGeometryToDMesh(MeshGeometry3D mesh) { List <Vector3d> vertices = new List <Vector3d>(); foreach (Point3D point in mesh.Positions) { vertices.Add(new Vector3d(point.X, point.Y, point.Z)); } List <Vector3f> normals = new List <Vector3f>(); foreach (Point3D normal in mesh.Normals) { normals.Add(new Vector3f(normal.X, normal.Y, normal.Z)); } if (normals.Count() == 0) { normals = null; } List <Index3i> triangles = new List <Index3i>(); for (int i = 0; i < mesh.TriangleIndices.Count; i += 3) { triangles.Add(new Index3i(mesh.TriangleIndices[i], mesh.TriangleIndices[i + 1], mesh.TriangleIndices[i + 2])); } //converting the meshes to use Implicit Surface Modeling return(DMesh3Builder.Build(vertices, triangles, normals)); }
public override bool BuildOnMesh(DMesh3Builder meshBuilder) { Vector3d v00 = Origin, v01 = Origin, v10 = Origin; v01.y += Height; v10 += AlongWidthDirection * Width; Vector3d v11 = v10; v11.y += Height; var vInfo = new NewVertexInfo { bHaveN = true, n = new Vector3f(FrontNormal), }; int i00 = AppentVertex(meshBuilder, vInfo, v00); int i01 = AppentVertex(meshBuilder, vInfo, v01); int i10 = AppentVertex(meshBuilder, vInfo, v10); int i11 = AppentVertex(meshBuilder, vInfo, v11); meshBuilder.AppendTriangle(i00, i11, i01); meshBuilder.AppendTriangle(i00, i10, i11); return(true); }
public static void test_mesh_builders() { // test mesh builder DMesh3 origMesh = TestUtil.LoadTestMesh(Program.TEST_FILES_PATH + "bunny_open_base.obj"); float[] Vf = new float[origMesh.VertexCount * 3]; List <Vector3f> Vl = new List <Vector3f>(); int k = 0; foreach (Vector3d v in origMesh.Vertices()) { Vf[k++] = (float)v.x; Vf[k++] = (float)v.y; Vf[k++] = (float)v.z; Vl.Add((Vector3f)v); } double[] Nd = origMesh.NormalsBuffer.GetBufferCast <double>(); Vector3d[] Nl = new Vector3d[origMesh.VertexCount]; foreach (int vid in origMesh.VertexIndices()) { Nl[vid] = origMesh.GetVertexNormal(vid); } int[] Ti = origMesh.TrianglesBuffer.GetBuffer(); Index3i[] Tl = new Index3i[origMesh.TriangleCount]; foreach (int tid in origMesh.TriangleIndices()) { Tl[tid] = origMesh.GetTriangle(tid); } DMesh3 m1 = DMesh3Builder.Build(Vf, Ti, Nd); DMesh3 m2 = DMesh3Builder.Build(Vl, Tl, Nl); Util.gDevAssert(origMesh.IsSameMesh(m1, true)); Util.gDevAssert(origMesh.IsSameMesh(m2, true)); }
public static DMesh3 ToDMesh3(this Rhino.Geometry.Mesh ms) { int numV = ms.Vertices.Count; int numF = ms.Faces.Count; int numC = ms.VertexColors.Count; List <Vector3f> Vertices = new List <Vector3f>(numV); List <Vector3i> Triangles = new List <Vector3i>(numF); for (int i = 0; i < numV; i++) { Vertices.Add(ms.Vertices[i].ToVec3f()); } for (int i = 0; i < numF; i++) { Triangles.Add(ms.Faces[i].ToVec3i()); } DMesh3 dMs = DMesh3Builder.Build <Vector3f, Vector3i, Vector3f>(Vertices, Triangles); if (numV == numC) { dMs.EnableVertexColors(new Vector3f(0.5, 0.5, 0.5)); for (int i = 0; i < numV; i++) { dMs.SetVertexColor(i, new Vector3f((float)ms.VertexColors[i].R / 255, (float)ms.VertexColors[i].G / 255, (float)ms.VertexColors[i].B / 255)); } } return(dMs); }
string WriteOFF() { IEnumerable <float> coords = mesh.vertices.ToFloats(); DMesh3 dmesh3 = DMesh3Builder.Build <float, int, float>(coords.ToArray(), mesh.triangles); WriteMesh writeMesh = new WriteMesh { Mesh = dmesh3, Name = meshHash }; OFFWriter OFFwriter = new OFFWriter(); string OFF = Application.dataPath + "/VolumetricMeshes/" + meshHash + "/" + meshHash + ".off"; Directory.CreateDirectory(Application.dataPath + "/VolumetricMeshes/" + meshHash + "/"); FileStream OFFfile = File.OpenWrite(OFF); TextWriter textWriter = new StreamWriter(OFFfile); WriteOptions options = new WriteOptions() { RealPrecisionDigits = 7 }; OFFwriter.Write(textWriter, new List <WriteMesh>() { writeMesh }, options); textWriter.Flush(); textWriter.Close(); return(OFF); }
protected override void Recompute(DGArguments args) { System.Console.WriteLine("Reading file..."); ReadMesh = new DMesh3(); string path = CachedValue <string>(0, args); if (!File.Exists(path)) { return; } DMesh3Builder builder = new DMesh3Builder(); StandardMeshReader reader = new StandardMeshReader(); reader.MeshBuilder = builder; IOReadResult result = reader.Read(path, ReadOptions.Defaults); if (result.code != IOCode.Ok) { return; } ReadMesh = builder.Meshes[0]; }
// parse file and create a set of MeshSO objects public bool ReadFile(string sPath) { sSourcePath = sPath; SomeMeshesTooLargeForUnityWarning = false; // read the input file DMesh3Builder build = new DMesh3Builder(); StandardMeshReader reader = new StandardMeshReader() { MeshBuilder = build }; reader.warningEvent += on_warning; ReadOptions options = new ReadOptions(); options.ReadMaterials = true; LastReadResult = reader.Read(sPath, options); if (LastReadResult.code != IOCode.Ok) { return(false); } // create the material set List <SOMaterial> vSOMaterials = new List <SOMaterial>(); for (int k = 0; k < build.Materials.Count; ++k) { SOMaterial m = build_material(sPath, build.Materials[k]); vSOMaterials.Add(m); } // convert the read meshes into unity meshes SceneObjects = new List <ImportedObject>(); for (int k = 0; k < build.Meshes.Count; ++k) { DMesh3 mesh = build.Meshes[k]; int matID = build.MaterialAssignment[k]; SOMaterial soMaterial = (matID < 0 || matID >= vSOMaterials.Count) ? null : vSOMaterials[matID]; if (SwapLeftRight) { MeshTransforms.FlipLeftRightCoordSystems(mesh); } SceneObjects.Add(new ImportedObject() { mesh = mesh, material = soMaterial }); } return(SceneObjects.Count > 0); }
/// <summary> /// Generates a mesh for the ground that we can work with. /// </summary> private void LoadGroundMesh() { var vertices = _data.Vertices.Select(a => new Vector3f(a.X, a.Z, a.Y)); var triangles = _data.Triangles.Select(a => new Index3i(a.Indices[0], a.Indices[1], a.Indices[2])); _mesh = DMesh3Builder.Build <Vector3f, Index3i, Vector3f>(vertices, triangles, null, null); _spatial = new DMeshAABBTree3(_mesh); _spatial.Build(); }
public MeshICP ICP(DMesh3Builder mesh) { DMeshAABBTree3 tree = new DMeshAABBTree3(mesh.Meshes[1], autoBuild: true); MeshICP calc = new MeshICP(mesh.Meshes[0], tree); calc.Solve(); calc.Solve(bUpdate: true); return(calc); }
private DMesh3 LoadGLB(ModelRoot inputModel) { var glbMesh = inputModel.LogicalMeshes.First().Primitives.First(); var vertices = glbMesh.GetVertices("POSITION").AsVector3Array(); var indices = glbMesh.GetIndices(); var normals = glbMesh.GetVertices("NORMAL").AsVector3Array(); var mesh = DMesh3Builder.Build(vertices, indices, normals); return(mesh); }
public static void FillBetweenPolygons(DMesh3Builder meshBuilder, IList <Vector3d> polygon1, IList <Vector3d> polygon2) { for (int p = 0; p < polygon1.Count; ++p) { var nextP = ((p + 1) + polygon1.Count) % polygon1.Count; var sideBase = polygon1[nextP] - polygon1[p]; var sideTop = polygon2[nextP] - polygon2[p]; var normal = new Vector3f(sideTop.UnitCross(sideBase)); MeshUtility.FillBetweenEdges(meshBuilder, new MeshUtility.Edge(polygon1[p], polygon1[nextP]), new MeshUtility.Edge(polygon2[p], polygon2[nextP]), normal); } }
public static List <DMesh3> LoadMeshes(string path) { var builder = new DMesh3Builder(); var reader = new StandardMeshReader { MeshBuilder = builder }; var result = reader.Read(path, ReadOptions.Defaults); if (result.code == IOCode.Ok) { return(builder.Meshes); } return(null); }
public static void test_mesh_builder_104() { var vertices = new List <Vector3f> { new Vector3f(0, 0, 0), // 0 new Vector3f(1000, 0, 0), // 1 new Vector3f(1000, 200, 0), // 2 new Vector3f(0, 200, 0), // 3 new Vector3f(1000, 0, 200), // 4 new Vector3f(0, 0, 200), // 5 new Vector3f(1000, 0, -200), // 6 new Vector3f(0, 0, -200), // 7 new Vector3f(1000, -200, 0), // 8 new Vector3f(0, -200, 0) // 9 }; var triangles = new List <Index3i> { new Index3i(0, 1, 2), new Index3i(0, 2, 3), new Index3i(0, 4, 1), new Index3i(0, 5, 4), new Index3i(0, 1, 6), // Does not show new Index3i(0, 6, 7), new Index3i(0, 8, 1), // Does not show new Index3i(0, 9, 8) }; var mesh = DMesh3Builder.Build <Vector3f, Index3i, Vector3f>(vertices, triangles); Console.WriteLine($"Number of triangles: {mesh.TriangleCount}"); // Outputs 6, because mesh is not manifold Console.WriteLine($"Vertex Issues: {mesh.FindMetadata("AppendVertexIssues")}"); Console.WriteLine($"Triangle Issues: {mesh.FindMetadata("AppendTriangleIssues")}"); // for greater control of the meshing process use DMesh3Builder class Console.WriteLine("Trying again with DMesh3Builder instance"); DMesh3Builder builder = new DMesh3Builder(); builder.NonManifoldTriBehavior = DMesh3Builder.AddTriangleFailBehaviors.DuplicateAllVertices; mesh = builder.AppendMesh <Vector3f, Index3i, Vector3f>(vertices, triangles); Console.WriteLine($"Number of triangles: {mesh.TriangleCount}"); // Outputs 8, because non manifold is allowed Console.WriteLine($"Triangle Issues: {mesh.FindMetadata("AppendTriangleIssues")}"); Console.WriteLine($"Normals: {mesh.FindMetadata("Normals")}"); Console.WriteLine($"TriGroups: {mesh.FindMetadata("TriGroups")}"); var outF = TestUtil.WriteTestOutputMesh(mesh, "Issue104.obj"); Console.WriteLine($"Written to: {outF}"); }
public void Calculate(DMesh3Builder mesh) { var icp = ICP(mesh); DMesh3 source = mesh.Meshes[1]; //Func<Vector3d, Vector3d> TransformVector = (x, f) => //{ // return (Vector3d) //}; Func <Vector3d, Vector3d> TransformF = (v1) => { return(v1 += icp.Translation); }; MeshTransforms.PerVertexTransform(source, TransformF); }
private static void ApplyNodesRecursively(DMesh3Builder meshBuilder, GrammarNode currentNode, List <Task> tasksToWait) { if (currentNode == null) { return; } currentNode.BuildOnMesh(meshBuilder); if (currentNode is WindowNode) { tasksToWait.Add((currentNode as WindowNode).BuildingTask); } foreach (var child in currentNode.Subnodes) { ApplyNodesRecursively(meshBuilder, child, tasksToWait); } }
public Task BuildTreeAsync(Vector3[] positions, Vector3[] normals, int[] indices) { return(Task.Run(() => { var norm = ConvertToVector3f(normals); DMeshLocal = DMesh3Builder.Build(ConvertToVector3f(positions), indices, norm); TreeLocal = new DMeshAABBTree3(DMeshLocal); TreeLocal.Build(); box = new BoundingBox(DMeshLocal.GetBounds()); IsBuilt = true; return this; })); }
public MeshData Simplify(MeshData meshData, int numCells = 128, int targetVerticesCount = 10000) { var vertices = meshData.Vertices.Select(v => new Vector3f(v.x, v.y, v.z)); var normals = meshData.Normals?.Select(v => new Vector3f(v.x, v.y, v.z)); var mesh = DMesh3Builder.Build(vertices, meshData.Triangles, normals); mesh = VoxelizeMesh(numCells, mesh); mesh = ReduceVertexCount(targetVerticesCount, mesh); mesh = CreateCompactMesh(mesh); return(new MeshData( mesh.Vertices().Select(v => new Vector3((float)v.x, (float)v.y, (float)v.z)).ToArray(), mesh.Triangles().SelectMany(i3 => i3.array).ToArray() )); }
private static IList <DMesh3> MakeMeshFromGrammar(GrammarNode buildingWord) { var mesh = new DMesh3(MeshComponents.VertexNormals | MeshComponents.FaceGroups); var builder = new DMesh3Builder() { Meshes = { mesh }, DuplicateTriBehavior = DMesh3Builder.AddTriangleFailBehaviors.DiscardTriangle, NonManifoldTriBehavior = DMesh3Builder.AddTriangleFailBehaviors.DiscardTriangle, }; builder.SetActiveMesh(0); var tasksToWait = new List <Task>(); ApplyNodesRecursively(builder, buildingWord, tasksToWait); Task.WaitAll(tasksToWait.ToArray()); return(builder.Meshes); }
async Task process_and_complete_import(string sFilename, DMesh3Builder builder, double targetHeight, int reduceToCount, Action <string> onCompletedF) { CCStatus.BeginOperation("processing"); await Task.Run(() => { if (targetHeight > 0.001 && Math.Abs(targetHeight - Bounds.Height) > 0.001) { double scaleH = targetHeight / Bounds.Height; Vector3d o = Bounds.Center - Bounds.Extents.y *Vector3d.AxisY; foreach (var mesh in builder.Meshes) { MeshTransforms.Scale(mesh, scaleH *Vector3d.One, o); } } }); await Task.Run(() => { if (reduceToCount != -1 && reduceToCount < TriCount) { foreach (var mesh in builder.Meshes) { if (mesh.TriangleCount < 10) { continue; } double tri_fraction = (double)mesh.TriangleCount / (double)TriCount; int NT = (int)(tri_fraction *reduceToCount); if (NT < 10) { NT = 10; } Reducer r = new Reducer(mesh); r.ReduceToTriangleCount(NT); } } }); CCStatus.EndOperation("processing"); await complete_import(sFilename, builder, onCompletedF); }
void MeshReplace() { Mesh newMesh = new Mesh(); //The triangles tend to come out reversed, so we need to fix them DMesh3 dmesh3 = DMesh3Builder.Build <float, int, float>(verticies, faces); MeshNormals.QuickCompute(dmesh3); dmesh3.ReverseOrientation(false); newMesh.vertices = verticies.ToVectors().ToArray(); newMesh.triangles = dmesh3.TrianglesBuffer.ToArray(); for (int i = 0; i < mesh.uv.Length; i++) { newMesh.uv[i] = mesh.uv[i]; } newMesh.MarkDynamic(); GetComponent <MeshFilter>().mesh = newMesh; }
void Start() { if (model != null) { mesh = model.sharedMesh; meshVertices = mesh.vertices; meshTriangles = mesh.triangles; for (int i = 0; i < meshVertices.Length; i++) { meshVertices[i] = model.transform.TransformPoint(meshVertices[i]); } binarySpacePartition = new BSP(mesh, 14); if (diskMaterial) { int numDisksToDraw = Mathf.Min(binarySpacePartition.splittingDisks.Length, 15); diskMatrices = new Matrix4x4[numDisksToDraw]; for (int i = 0; i < numDisksToDraw; i++) { diskMatrices[i] = Matrix4x4.TRS( binarySpacePartition.splittingDisks[i].average, Quaternion.LookRotation(binarySpacePartition.splittingDisks[i].plane), new Vector3(1f, 1f, 0.0001f) * Mathf.Sqrt(binarySpacePartition.splittingDisks[i].sqRadius)); } } #if G3_USING_UNITY DMesh3Builder dMeshBuilder = new DMesh3Builder(); dMeshBuilder.AppendNewMesh(false, false, false, false); foreach (Vector3 vertex in meshVertices) { dMeshBuilder.AppendVertex(vertex.x, vertex.y, vertex.z); } for (int i = 0; i < meshTriangles.Length; i += 3) { dMeshBuilder.AppendTriangle(meshTriangles[i], meshTriangles[i + 1], meshTriangles[i + 2]); } g3MeshTree = new DMeshAABBTree3(dMeshBuilder.Meshes[0]); g3MeshTree.Build(); #endif } }