/// <summary>
/// Generate representations for nodes
/// </summary>
/// <param name="node"></param>
protected void GenerateRepresentations(Node node)
{
Guid objID = Guid.Empty;
if (!Links.ContainsFirst(node.GUID))
{
if (!node.IsDeleted)
{
objID = RhinoOutput.BakePoint(node.Position);
Links.Add(node.GUID, objID);
}
}
else
{
objID = Links.GetSecond(node.GUID);
if (node.IsDeleted)
{
RhinoOutput.DeleteObject(objID);
objID = Guid.Empty;
}
else
{
objID = RhinoOutput.BakeOrReplacePoint(objID, node.Position);
Links.Set(node.GUID, objID);
}
}
if (objID != Guid.Empty)
{
RhinoOutput.SetOriginalIDUserString(objID);
string layerPath = NodesLayerName;
RhinoOutput.SetObjectLayer(objID, layerPath);
RhinoOutput.SetObjectName(objID, node.Description);
}
}
/// <summary>
/// Delete all Rhino handle objects linked to model objects by this layer
/// </summary>
public void DeleteAllHandles()
{
foreach (Guid guid in Links.Values)
{
RhinoOutput.DeleteObject(guid);
}
RhinoOutput.DeleteEmptySubLayers(BaseLayerName);
}
/// <summary>
/// Is the handle of this object (if it has one) currently hidden in Rhino?
/// </summary>
/// <param name="unique"></param>
/// <returns></returns>
public bool IsHandleHidden(Unique unique)
{
if (Links.ContainsFirst(unique.GUID))
{
return(!RhinoOutput.ObjectVisible(Links.GetSecond(unique.GUID)));
}
return(false);
}
public void SelectHandle(ModelObject mObj)
{
Guid hID = LinkedHandle(mObj);
if (hID != Guid.Empty)
{
RhinoOutput.SelectObject(hID);
}
}
/// <summary>
/// Do any handle objects exist?
/// </summary>
/// <returns></returns>
public bool HandlesExist()
{
foreach (Guid guid in Links.Keys)
{
if (RhinoOutput.ObjectExists(guid))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Generate the handle representation of an element
/// </summary>
/// <param name="element"></param>
protected void GenerateRepresentations(Element element)
{
Guid objID = Guid.Empty;
if (!Links.ContainsFirst(element.GUID))
{
if (!element.IsDeleted)
{
string idString = element.GetGeometry()?.Attributes?.SourceID;
if (!string.IsNullOrWhiteSpace(idString))
{
objID = new Guid(idString);
if (!RhinoOutput.ObjectExists(objID))
{
objID = Guid.Empty;
}
}
objID = RhinoOutput.BakeOrReplace(objID, element.GetGeometry());
Links.Add(element.GUID, objID);
}
}
else
{
objID = Links.GetSecond(element.GUID);
if (element.IsDeleted)
{
RhinoOutput.DeleteObject(objID);
objID = Guid.Empty;
}
else
{
if (!_Undeleting && !_Replacing)
{
objID = RhinoOutput.BakeOrReplace(objID, element.GetGeometry());
Links.Set(element.GUID, objID);
}
}
}
if (objID != Guid.Empty)
{
RhinoOutput.SetOriginalIDUserString(objID);
string layerPath = ElementsLayerPath;
if (element.GetFamily() != null)
{
layerPath += element.GetFamily().Name;
}
RhinoOutput.SetObjectLayer(objID, layerPath);
RhinoOutput.SetObjectName(objID, element.Description);
}
}
public bool Select(IList items, bool clear = false)
{
if (clear)
{
RhinoOutput.UnselectAllObjects();
}
foreach (object item in items)
{
if (item is ModelObject)
{
Handles.SelectHandle((ModelObject)item);
}
}
return(true);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Host.EnsureInitialisation();
PanelElementCollection elements = Core.Instance.ActiveDocument.Model.Elements.PanelElements;
foreach (PanelElement lEl in elements)
{
RhinoMeshAvatar mAv = new RhinoMeshAvatar();
((IMeshAvatar)mAv).Builder.AddPanelPreview(lEl);
((IMeshAvatar)mAv).FinalizeMesh();
RhinoOutput.BakeMesh(mAv.RenderMesh);
}
Host.Instance.Refresh();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Host.EnsureInitialisation();
LinearElementCollection elements = Core.Instance.ActiveDocument.Model.Elements.LinearElements;
foreach (LinearElement lEl in elements)
{
if (!lEl.IsDeleted)
{
Extrusion extrusion = ToRC.ConvertToExtrusion(lEl);
Guid guid = Guid.Empty;
if (extrusion != null)
{
guid = RhinoOutput.BakeExtrusion(extrusion);
}
else
{
Brep brep = ToRC.ConvertToBrep(lEl);
if (brep != null)
{
guid = RhinoOutput.Bake(brep);
}
}
if (guid != Guid.Empty)
{
RhinoOutput.SetObjectName(guid, lEl.Name);
if (lEl.Family != null)
{
RhinoOutput.SetObjectUserString(guid, "Family", lEl.Family.Name);
if (lEl.Family.GetPrimaryMaterial() != null)
{
RhinoOutput.SetObjectUserString(guid, "Material", lEl.Family.GetPrimaryMaterial().Name);
}
if (lEl.Family.Profile != null)
{
RhinoOutput.SetObjectUserString(guid, "Profile", lEl.Family.Profile.ToString());
}
}
}
}
}
Host.Instance.Refresh();
return(Result.Success);
}
public override void InvalidateOnUpdate(object modified, PropertyChangedEventArgs e)
{
if (modified is Family && e.PropertyName == "Name" && e is PropertyChangedEventArgsExtended)
{
var e2 = (PropertyChangedEventArgsExtended)e;
string oldName = ((string)e2.OldValue).Trim();
if (string.IsNullOrWhiteSpace(oldName))
{
oldName = "_UNNAMED_";
}
string newName = ((string)e2.NewValue).Trim();
if (string.IsNullOrWhiteSpace(newName))
{
newName = "_UNNAMED_";
}
RhinoOutput.ChangeLayerName(ElementsLayerPath + oldName, newName);
}
base.InvalidateOnUpdate(modified, e);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Host.EnsureInitialisation();
LinearElementCollection elements = Core.Instance.ActiveDocument.Model.Elements.LinearElements;
foreach (LinearElement lEl in elements)
{
if (!lEl.IsDeleted)
{
RhinoMeshAvatar mAv = new RhinoMeshAvatar();
((IMeshAvatar)mAv).Builder.AddSectionPreview(lEl);
((IMeshAvatar)mAv).FinalizeMesh();
Guid guid = RhinoOutput.BakeMesh(mAv.RenderMesh);
if (guid != Guid.Empty)
{
RhinoOutput.SetObjectName(guid, lEl.Name);
if (lEl.Family != null)
{
RhinoOutput.SetObjectUserString(guid, "Family", lEl.Family.Name);
if (lEl.Family.GetPrimaryMaterial() != null)
{
RhinoOutput.SetObjectUserString(guid, "Material", lEl.Family.GetPrimaryMaterial().Name);
}
if (lEl.Family.Profile != null)
{
RhinoOutput.SetObjectUserString(guid, "Profile", lEl.Family.Profile.ToString());
}
}
}
}
}
Host.Instance.Refresh();
return(Result.Success);
}
private void HandlesAddRhinoObject(object sender, RhinoObjectEventArgs e)
{
if (!RhinoOutput.Writing && !_Replacing)
{
if (e.TheObject.Attributes.HasUserData)
{
string data = e.TheObject.Attributes.GetUserString("SAL_ORIGINAL");
if (!string.IsNullOrEmpty(data) && data != e.ObjectId.ToString())
{
Guid storedGuid = new Guid(data);
if (this.Links.ContainsSecond(storedGuid))
{
ModelObject mO = LinkedModelObject(storedGuid);
//Create copy of object:
if (mO is Element)
{
VertexGeometry geometry = FromRC.Convert(e.TheObject.Geometry);
Element element = null;
if (mO is LinearElement)
{
LinearElement lElement = ((LinearElement)mO).Duplicate();//Core.Instance.ActiveDocument?.Model?.Create.CopyOf((Element)mO, geometry);
bool split = false;
if (geometry is Curve)
{
Curve newCrv = (Curve)geometry;
if (lElement.Geometry != null)
{
Curve oldCrv = lElement.Geometry;
if (newCrv.Length < oldCrv.Length)
{
//TODO: Check end point distance to curve
double maxDist = 0;
foreach (Vertex v in newCrv.Vertices)
{
double dist = oldCrv.DistanceToSquared(v.Position);
if (dist > maxDist)
{
maxDist = dist;
}
}
if (maxDist < Tolerance.Distance)
{
split = true;
}
}
}
lElement.ReplaceGeometry(newCrv, split);
}
lElement.GenerateNodes(new NodeGenerationParameters());
element = lElement;
}
if (mO is PanelElement)
{
PanelElement pElement = ((PanelElement)mO).Duplicate();//Core.Instance.ActiveDocument?.Model?.Create.CopyOf((Element)mO, geometry);
if (geometry is Surface)
{
pElement.ReplaceGeometry((Surface)geometry);
}
element = pElement;
}
RhinoOutput.SetOriginalIDUserString(e.ObjectId);
if (element != null)
{
Links.Set(element.GUID, e.ObjectId);
Core.Instance.ActiveDocument.Model.Add(element);
}
}
else if (mO is Node)
{
if (e.TheObject.Geometry is RC.Point)
{
Node node = ((Node)mO).Duplicate();
RC.Point pt = (RC.Point)e.TheObject.Geometry;
node.Position = FromRC.Convert(pt).Position;
RhinoOutput.SetOriginalIDUserString(e.ObjectId);
Links.Set(node.GUID, e.ObjectId);
Core.Instance.ActiveDocument.Model.Add(node);
}
}
}
}
}
}
}
