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
}
}
