public static Scene <Model> BuildScene(List <Rhino.Geometry.Mesh> meshes)
{
var merged_mesh = new Rhino.Geometry.Mesh();
foreach (var m in meshes)
{
merged_mesh.Append(m);
}
return(BuildScene(merged_mesh));
}
public static Rhino.Geometry.Mesh UnionMesh(List <Rhino.Geometry.Mesh> meshes)
{
Rhino.Geometry.Mesh outMesh = new Rhino.Geometry.Mesh();
foreach (Rhino.Geometry.Mesh m in meshes)
{
outMesh.Append(m);
}
return(outMesh);
}
void DrawData(Grasshopper.Kernel.Data.IGH_Structure volatileData, IGH_DocumentObject docObject)
{
if (!volatileData.IsEmpty)
{
foreach (var value in volatileData.AllData(true))
{
// First check for IGH_PreviewData to discard no graphic elements like strings, doubles, vectors...
if (value is IGH_PreviewData)
{
switch (value.ScriptVariable())
{
case Rhino.Geometry.Point3d point: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.Point(point))); break;
case Rhino.Geometry.Line line: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.LineCurve(line))); break;
case Rhino.Geometry.Rectangle3d rect: primitives.Add(new ParamPrimitive(docObject, rect.ToNurbsCurve())); break;
case Rhino.Geometry.Arc arc: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.ArcCurve(arc))); break;
case Rhino.Geometry.Circle circle: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.ArcCurve(circle))); break;
case Rhino.Geometry.Ellipse ellipse: primitives.Add(new ParamPrimitive(docObject, ellipse.ToNurbsCurve())); break;
case Rhino.Geometry.Curve curve: primitives.Add(new ParamPrimitive(docObject, curve)); break;
case Rhino.Geometry.Mesh mesh: primitives.Add(new ParamPrimitive(docObject, mesh)); break;
case Rhino.Geometry.Box box:
{
var boxMeshes = Rhino.Geometry.Mesh.CreateFromBox(box, 1, 1, 1);
if (boxMeshes != null)
{
primitives.Add(new ParamPrimitive(docObject, boxMeshes));
}
}
break;
case Rhino.Geometry.Brep brep:
{
var brepMeshes = Rhino.Geometry.Mesh.CreateFromBrep(brep, activeDefinition.PreviewCurrentMeshParameters());
if (brepMeshes != null)
{
var previewMesh = new Rhino.Geometry.Mesh();
previewMesh.Append(brepMeshes);
primitives.Add(new ParamPrimitive(docObject, previewMesh));
}
}
break;
}
}
}
}
}
public static Rhino.Geometry.Mesh ConvertToRhinoMesh(List <g3.PolyLine3d> inputLines)
{
Rhino.Geometry.Mesh result = new Rhino.Geometry.Mesh();
foreach (var l in inputLines)
{
var poly = ConvertToRhinoPolyline(l);
var temp = Rhino.Geometry.Mesh.CreateFromClosedPolyline(poly);
temp.Ngons.AddPlanarNgons(double.MaxValue / 10);
result.Append(temp);
}
result.UnifyNormals();
return(result);
}
Rhino.Geometry.Mesh GetDocumentPreview(GH_Document document)
{
var meshPreview = new Rhino.Geometry.Mesh();
var meshes = new List <Rhino.Geometry.Mesh>();
foreach (var obj in document.Objects.OfType <IGH_ActiveObject>())
{
if (obj.Locked)
{
continue;
}
if (obj is IGH_PreviewObject previewObject)
{
if (previewObject.IsPreviewCapable)
{
if (obj is IGH_Component component)
{
if (!component.Hidden)
{
foreach (var param in component.Params.Output)
{
meshes.AddRange(GetParamMeshes(param));
}
}
}
else if (obj is IGH_Param param)
{
meshes.AddRange(GetParamMeshes(param));
}
}
}
}
if (meshes.Count > 0)
{
meshPreview.Append(meshes);
return(meshPreview);
}
else
{
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="file">3dm file to write to disk.</param>
/// <param name="path">Path of the file to write.</param>
/// <returns></returns>
public static bool Write3dm(RhinoDoc doc, FileWriteOptions options, string path)
{
var file3dm = new File3dm();
var objectEnumeratorSettings = new ObjectEnumeratorSettings
{
HiddenObjects = true,
IncludeLights = true
};
foreach (var rhinoObject in doc.Objects.GetObjectList(objectEnumeratorSettings))
{
if ((options.WriteSelectedObjectsOnly && rhinoObject.IsSelected(true) == 1) || (!options.WriteSelectedObjectsOnly) || (rhinoObject.IsSelected(true) == 2))
{
file3dm.AllMaterials.Add(doc.Materials[rhinoObject.Attributes.MaterialIndex]);
var matId = file3dm.AllMaterials.Count - 1;
var att = rhinoObject.Attributes;
att.MaterialIndex = matId;
switch (rhinoObject.ObjectType)
{
case ObjectType.Mesh:
file3dm.Objects.AddMesh(rhinoObject.Geometry as Rhino.Geometry.Mesh, att);
break;
case ObjectType.Brep:
case ObjectType.Extrusion:
case ObjectType.Surface:
case ObjectType.SubD:
var meshes = rhinoObject.GetMeshes(Rhino.Geometry.MeshType.Default);
var mesh = new Rhino.Geometry.Mesh();
foreach (var m in meshes)
{
mesh.Append(m);
}
file3dm.Objects.AddMesh(mesh, att);
break;
}
}
}
return(file3dm.Write(path, 0));
}
public List <Rhino.Geometry.Mesh> GetParamMeshes(IGH_Param param)
{
var meshes = new List <Rhino.Geometry.Mesh>();
foreach (var value in param.VolatileData.AllData(true))
{
if (value is IGH_PreviewData)
{
switch (value.ScriptVariable())
{
case Rhino.Geometry.Mesh mesh:
meshes.Add(mesh);
break;
case Rhino.Geometry.Brep brep:
var previewMesh = new Rhino.Geometry.Mesh();
previewMesh.Append(Rhino.Geometry.Mesh.CreateFromBrep(brep, Rhino.Geometry.MeshingParameters.Default));
meshes.Add(previewMesh);
break;
}
}
}
return(meshes);
}
Rhino.Geometry.Mesh GetDocumentPreview(GH_Document document)
{
var meshPreview = new Rhino.Geometry.Mesh();
foreach (var obj in document.Objects.OfType <IGH_ActiveObject>())
{
if (obj.Locked)
{
continue;
}
if (obj is IGH_PreviewObject previewObject)
{
if (previewObject.IsPreviewCapable)
{
//primitivesBoundingBox = Rhino.Geometry.BoundingBox.Union(primitivesBoundingBox, previewObject.ClippingBox);
if (obj is IGH_Component component)
{
if (!component.Hidden)
{
foreach (var param in component.Params.Output)
{
foreach (var value in param.VolatileData.AllData(true))
{
if (value is IGH_PreviewData)
{
switch (value.ScriptVariable())
{
case Rhino.Geometry.Mesh mesh:
//Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(mesh, GeometryResolver.Settings));
// cb?.Invoke(Newtonsoft.Json.JsonConvert.SerializeObject(mesh, GeometryResolver.Settings));
meshPreview.Append(mesh);
break;
case Rhino.Geometry.Brep brep:
var previewMesh = new Rhino.Geometry.Mesh();
previewMesh.Append(Rhino.Geometry.Mesh.CreateFromBrep(brep, Rhino.Geometry.MeshingParameters.Default));
//Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(previewMesh, GeometryResolver.Settings));
// cb?.Invoke(Newtonsoft.Json.JsonConvert.SerializeObject(previewMesh, GeometryResolver.Settings));
meshPreview.Append(previewMesh);
break;
}
}
}
}
}
}
else if (obj is IGH_Param param)
{
foreach (var value in param.VolatileData.AllData(true))
{
if (value is IGH_PreviewData)
{
switch (value.ScriptVariable())
{
case Rhino.Geometry.Mesh mesh:
// Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(mesh, GeometryResolver.Settings));
// cb?.Invoke(Newtonsoft.Json.JsonConvert.SerializeObject(mesh, GeometryResolver.Settings));
meshPreview.Append(mesh);
break;
case Rhino.Geometry.Brep brep:
var previewMesh = new Rhino.Geometry.Mesh();
previewMesh.Append(Rhino.Geometry.Mesh.CreateFromBrep(brep, Rhino.Geometry.MeshingParameters.Default));
// Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(previewMesh, GeometryResolver.Settings));
// cb?.Invoke(Newtonsoft.Json.JsonConvert.SerializeObject(previewMesh, GeometryResolver.Settings));
meshPreview.Append(previewMesh);
break;
}
}
}
}
}
}
}
return(meshPreview);
}
public override bool CastTo <Q>(ref Q target)
{
if (base.CastTo <Q>(ref target))
{
return(true);
}
var element = (DB.Element) this;
if (typeof(DB.Element).IsAssignableFrom(typeof(Q)))
{
if (element is null)
{
if (IsValid)
{
return(false);
}
}
else if (!typeof(Q).IsAssignableFrom(element.GetType()))
{
return(false);
}
target = (Q)(object)element;
return(true);
}
if (element is null)
{
return(false);
}
if (element.Category?.HasMaterialQuantities ?? false)
{
if (typeof(Q).IsAssignableFrom(typeof(GH_Mesh)))
{
DB.Options options = null;
using (var geometry = element.GetGeometry(DB.ViewDetailLevel.Fine, out options)) using (options)
{
if (geometry is object)
{
var mesh = new Rhino.Geometry.Mesh();
mesh.Append(geometry.GetPreviewMeshes(null).Where(x => x is object));
mesh.Normals.ComputeNormals();
if (mesh.Faces.Count > 0)
{
target = (Q)(object)new GH_Mesh(mesh);
return(true);
}
}
}
}
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Curve)))
{
var axis = Axis;
if (axis is null)
{
return(false);
}
target = (Q)(object)new GH_Curve(axis);
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Plane)))
{
try
{
var plane = Plane;
if (!plane.IsValid || !plane.Origin.IsValid)
{
return(false);
}
target = (Q)(object)new GH_Plane(plane);
return(true);
}
catch (Autodesk.Revit.Exceptions.InvalidOperationException) { return(false); }
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Point)))
{
var location = Location;
if (!location.IsValid)
{
return(false);
}
target = (Q)(object)new GH_Point(location);
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Vector)))
{
var normal = ZAxis;
if (!normal.IsValid)
{
return(false);
}
target = (Q)(object)new GH_Vector(normal);
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Transform)))
{
var plane = Plane;
if (!plane.IsValid || !plane.Origin.IsValid)
{
return(false);
}
target = (Q)(object)new GH_Transform(Rhino.Geometry.Transform.PlaneToPlane(Rhino.Geometry.Plane.WorldXY, plane));
return(true);
}
if (typeof(Q).IsAssignableFrom(typeof(GH_Box)))
{
var box = Box;
if (!box.IsValid)
{
return(false);
}
target = (Q)(object)new GH_Box(box);
return(true);
}
return(false);
}
private void ExtractGeometry(Grasshopper.Kernel.Types.IGH_Goo iGoo, ref List <Rhino.Geometry.GeometryBase> resGeom)
{
if (iGoo is Grasshopper.Kernel.Types.GH_GeometryGroup group)
{
foreach (var geomGoo in group.Objects)
{
ExtractGeometry(geomGoo, ref resGeom);
}
return;
}
Rhino.Geometry.GeometryBase geometryBase = null;
try
{
switch (iGoo.ScriptVariable())
{
case Rhino.Geometry.Point3d point:
geometryBase = new Rhino.Geometry.Point(point);
break;
case Rhino.Geometry.Line line:
geometryBase = new Rhino.Geometry.LineCurve(line);
break;
case Rhino.Geometry.Rectangle3d rect:
geometryBase = rect.ToNurbsCurve();
break;
case Rhino.Geometry.Arc arc:
geometryBase = new Rhino.Geometry.ArcCurve(arc);
break;
case Rhino.Geometry.Circle circle:
geometryBase = new Rhino.Geometry.ArcCurve(circle);
break;
case Rhino.Geometry.Ellipse ellipse:
geometryBase = ellipse.ToNurbsCurve();
break;
case Rhino.Geometry.Curve curve:
geometryBase = curve;
break;
case Rhino.Geometry.Box box:
geometryBase = Rhino.Geometry.Mesh.CreateFromBox(box, 1, 1, 1); break;
case Rhino.Geometry.Mesh mesh:
geometryBase = mesh; break;
case Rhino.Geometry.Brep brep:
{
if (!CompoundDrawable.IsRenderMode)
{
foreach (var crv in brep.GetWireframe(-1))
{
resGeom.Add(crv);
}
}
else
{
var previewMesh = new Rhino.Geometry.Mesh();
previewMesh.Append(Rhino.Geometry.Mesh.CreateFromBrep(brep, MeshParameters));
geometryBase = previewMesh;
}
break;
}
case Rhino.Geometry.Plane plane:
{
double len = 4.0;
var x = new Rhino.Geometry.Interval(-len, len);
var y = new Rhino.Geometry.Interval(-len, len);
geometryBase = Rhino.Geometry.Mesh.CreateFromPlane(plane, x, y, 5, 5);
break;
}
default:
{
System.Diagnostics.Debug.Fail("Not supported GH type", iGoo.GetType().ToString());
break;
}
}
}
catch (Exception e)
{
System.Diagnostics.Debug.Fail(e.Source, e.Message);
}
if (geometryBase != null)
{
resGeom.Add(geometryBase);
}
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.DocObjects.ObjRef obj_ref;
const string prompt = "Select surface or polysurface to mesh";
const Rhino.DocObjects.ObjectType object_type =
Rhino.DocObjects.ObjectType.Surface |
Rhino.DocObjects.ObjectType.Brep;
Result res = Rhino.Input.RhinoGet.GetOneObject(prompt, false, object_type, out obj_ref);
if (res != Result.Success)
{
return(res);
}
Rhino.DocObjects.RhinoObject obj = obj_ref.Object();
if (null == obj)
{
return(Result.Failure);
}
Rhino.Geometry.Mesh obj_mesh = new Rhino.Geometry.Mesh();
Rhino.Geometry.Mesh[] meshes = obj.GetMeshes(Rhino.Geometry.MeshType.Render);
if (meshes.Length > 0)
{
foreach (Rhino.Geometry.Mesh m in meshes)
{
obj_mesh.Append(m);
}
}
else
{
Rhino.Geometry.MeshingParameters mesh_params = obj.GetRenderMeshParameters();
if (obj.CreateMeshes(Rhino.Geometry.MeshType.Render, mesh_params, false) > 0)
{
meshes = obj.GetMeshes(Rhino.Geometry.MeshType.Render);
if (meshes.Length > 0)
{
foreach (Rhino.Geometry.Mesh m in meshes)
{
obj_mesh.Append(m);
}
}
}
}
if (obj_mesh.IsValid)
{
obj_mesh.Faces.ConvertQuadsToTriangles();
}
if (obj_mesh.IsValid)
{
doc.Objects.AddMesh(obj_mesh);
doc.Views.Redraw();
}
return(Result.Success);
}
public static string Serialize(Rhino.RhinoDoc doc)
{
var model = new glTFLoader.Schema.Gltf();
#region Iterate through objects in doc
foreach (Rhino.DocObjects.RhinoObject o in doc.Objects)
{
var mesh = new Rhino.Geometry.Mesh();
var glTFMesh = new glTFLoader.Schema.Mesh();
switch (o.ObjectType)
{
case Rhino.DocObjects.ObjectType.Extrusion:
case Rhino.DocObjects.ObjectType.SubD:
case Rhino.DocObjects.ObjectType.Brep:
mesh.Append(o.GetMeshes(Rhino.Geometry.MeshType.Default));
break;
case Rhino.DocObjects.ObjectType.Mesh:
mesh = o.Geometry as Rhino.Geometry.Mesh;
break;
default:
Rhino.RhinoApp.WriteLine("Exporting {0} is not supported.", o.ObjectType);
break;
}
// do something with mesh
glTFMesh.Name = o.Name;
var primitive = new glTFLoader.Schema.MeshPrimitive();
// Faces
var accessor = new glTFLoader.Schema.Accessor();
accessor.Type = glTFLoader.Schema.Accessor.TypeEnum.SCALAR;
var indices = new List <int>();
foreach (var face in mesh.Faces)
{
if (face.IsTriangle)
{
indices.Add(face.A);
indices.Add(face.B);
indices.Add(face.C);
}
if (face.IsQuad)
{
indices.Add(face.A);
indices.Add(face.B);
indices.Add(face.C);
indices.Add(face.D);
}
}
accessor.Count = indices.Count;
int min = 0;
int max = 0;
foreach (var id in indices)
{
if (id < min)
{
min = id;
}
if (id > max)
{
max = id;
}
}
accessor.Min = new float [] { min };
accessor.Max = new float [] { max };
/*
* var faceIds = accessorData[mp.Indices.Value];
* var faces = new List<MeshFace>();
*
* for (int i = 0; i <= faceIds.Count - 3; i = i + 3)
* faces.Add(new MeshFace(faceIds[i], faceIds[i + 1], faceIds[i + 2]));
*
* meshPart.Faces.AddFaces(faces);
*/
}
#endregion
return(glTFLoader.Interface.SerializeModel(model));
}
