private static void AddMetadataToDatasmithActor(FDatasmithFacadeActor InDatasmithActor, RhinoSceneHierarchyNode InNode, FDatasmithFacadeScene InDatasmithScene)
{
if (!InNode.Info.bHasRhinoObject)
{
return;
}
RhinoObject NodeObject = InNode.Info.RhinoModelComponent as RhinoObject;
NameValueCollection UserStrings = NodeObject.Attributes.GetUserStrings();
if (UserStrings != null && UserStrings.Count > 0)
{
string[] Keys = UserStrings.AllKeys;
FDatasmithFacadeMetaData DatasmithMetaData = new FDatasmithFacadeMetaData(InDatasmithActor.GetName() + "_DATA");
DatasmithMetaData.SetLabel(InDatasmithActor.GetLabel());
DatasmithMetaData.SetAssociatedElement(InDatasmithActor);
for (int KeyIndex = 0; KeyIndex < Keys.Length; ++KeyIndex)
{
string CurrentKey = Keys[KeyIndex];
string EvaluatedValue = FDatasmithRhinoUtilities.EvaluateAttributeUserText(InNode, UserStrings.Get(CurrentKey));
DatasmithMetaData.AddPropertyString(CurrentKey, EvaluatedValue);
}
InDatasmithScene.AddMetaData(DatasmithMetaData);
}
}
private static void AddTagsToDatasmithActor(FDatasmithFacadeActor InDatasmithActor, RhinoSceneHierarchyNode InNode)
{
if (!InNode.bIsRoot && InNode.Info.Tags != null)
{
foreach (string CurrentTag in InNode.Info.Tags)
{
InDatasmithActor.AddTag(CurrentTag);
}
}
}
public void SetDatasmithActor(FDatasmithFacadeActor InActor)
{
if (bIsRoot || DatasmithActor != null)
{
RhinoApp.WriteLine(string.Format("Error: Generating a datasmith actor for a Hierarchy node that doesn't need one!"));
return;
}
DatasmithActor = InActor;
}
private static void AddActorToParent(FDatasmithFacadeActor InDatasmithActor, RhinoSceneHierarchyNode InNode, FDatasmithFacadeScene InDatasmithScene)
{
if (InNode.Parent.bIsRoot)
{
InDatasmithScene.AddActor(InDatasmithActor);
}
else
{
InNode.Parent.DatasmithActor.AddChild(InDatasmithActor);
}
}
private static FDatasmithFacadeActor ParseEmptyActor(RhinoSceneHierarchyNode InNode)
{
string HashedName = FDatasmithFacadeElement.GetStringHash(InNode.Info.Name);
FDatasmithFacadeActor DatasmithActor = new FDatasmithFacadeActor(HashedName);
DatasmithActor.SetLabel(InNode.Info.Label);
float[] MatrixArray = InNode.Info.WorldTransform.ToFloatArray(false);
DatasmithActor.SetWorldTransform(MatrixArray);
return(DatasmithActor);
}
private static void ExportHierarchyNode(FDatasmithFacadeScene DatasmithScene, RhinoSceneHierarchyNode Node, DatasmithRhinoSceneParser SceneParser)
{
FDatasmithFacadeActor ExportedActor = null;
if (Node.Info.bHasRhinoObject)
{
RhinoObject CurrentObject = Node.Info.RhinoModelComponent as RhinoObject;
if (CurrentObject.ObjectType == ObjectType.InstanceReference ||
CurrentObject.ObjectType == ObjectType.Point)
{
// The Instance Reference node is exported as an empty actor under which we create the instanced block.
// Export points as empty actors as well.
ExportedActor = ParseEmptyActor(Node);
}
else if (CurrentObject.ObjectType == ObjectType.Light)
{
ExportedActor = ParseLightActor(Node);
}
else if (SceneParser.ObjectIdToMeshInfoDictionary.TryGetValue(CurrentObject.Id, out DatasmithMeshInfo MeshInfo))
{
// If the node's object has a mesh associated to it, export it as a MeshActor.
ExportedActor = ParseMeshActor(Node, SceneParser, MeshInfo);
}
else
{
//#ueent_todo Log non-exported object in DatasmithExport UI (Writing to Rhino Console is extremely slow).
}
}
else
{
// This node has no RhinoObject (likely a layer), export an empty Actor.
ExportedActor = ParseEmptyActor(Node);
}
if (ExportedActor != null)
{
// Add common additional data to the actor, and add it to the hierarchy.
Node.SetDatasmithActor(ExportedActor);
AddTagsToDatasmithActor(ExportedActor, Node);
AddMetadataToDatasmithActor(ExportedActor, Node, DatasmithScene);
ExportedActor.SetLayer(GetDatasmithActorLayers(Node, SceneParser));
AddActorToParent(ExportedActor, Node, DatasmithScene);
}
}
private static FDatasmithFacadeActor ParseLightActor(RhinoSceneHierarchyNode InNode)
{
LightObject RhinoLightObject = InNode.Info.RhinoModelComponent as LightObject;
FDatasmithFacadeActor ParsedDatasmithActor = SetupLightActor(InNode.Info, RhinoLightObject.LightGeometry);
if (ParsedDatasmithActor != null)
{
float[] MatrixArray = InNode.Info.WorldTransform.ToFloatArray(false);
ParsedDatasmithActor.SetWorldTransform(MatrixArray);
}
else
{
// #ueent_todo: Log non supported light type.
ParsedDatasmithActor = ParseEmptyActor(InNode);
}
return(ParsedDatasmithActor);
}
private static FDatasmithFacadeActor ParseMeshActor(RhinoSceneHierarchyNode InNode, DatasmithRhinoSceneParser InSceneParser, DatasmithMeshInfo InMeshInfo)
{
string HashedActorName = FDatasmithFacadeActor.GetStringHash("A:" + InNode.Info.Name);
FDatasmithFacadeActorMesh DatasmithActorMesh = new FDatasmithFacadeActorMesh(HashedActorName);
DatasmithActorMesh.SetLabel(InNode.Info.Label);
Transform OffsetTransform = Transform.Translation(InMeshInfo.PivotOffset);
Transform WorldTransform = Transform.Multiply(InNode.Info.WorldTransform, OffsetTransform);
DatasmithActorMesh.SetWorldTransform(WorldTransform.ToFloatArray(false));
string MeshName = FDatasmithFacadeElement.GetStringHash(InMeshInfo.Name);
DatasmithActorMesh.SetMesh(MeshName);
if (InNode.Info.bOverrideMaterial)
{
RhinoMaterialInfo MaterialInfo = InSceneParser.GetMaterialInfoFromMaterialIndex(InNode.Info.MaterialIndex);
DatasmithActorMesh.AddMaterialOverride(MaterialInfo.Name, 0);
}
return(DatasmithActorMesh);
}
void ExportMetadata()
{
int DelayExport = 2000; // milliseconds
int ExportBatchSize = 1000; // After each batch is exported, the process will wait for DelayExport and resume (unless cancelled)
int CurrentBatchSize = 0;
Func <FCachedDocumentData, bool> AddElements = (FCachedDocumentData CacheData) =>
{
while (CacheData.ElementsWithoutMetadata.Count > 0)
{
if (CurrentBatchSize == ExportBatchSize)
{
// Add some delay before exporting next batch.
CurrentBatchSize = 0;
// Send metadata to DirectLink.
DatasmithScene.BuildScene(SceneName);
DatasmithDirectLink.UpdateScene(DatasmithScene);
MetadataEvent.WaitOne(DelayExport);
}
if (MetadataCancelToken.IsCancellationRequested)
{
return(false);
}
var Entry = CacheData.ElementsWithoutMetadata.Dequeue();
// Handle the case where element might be deleted in the main export path.
if (!CacheData.CachedElements.ContainsKey(Entry.Key))
{
continue;
}
Element RevitElement = CacheData.SourceDocument.GetElement(Entry.Key);
if (RevitElement == null)
{
continue;
}
FDocumentData.FBaseElementData ElementData = Entry.Value;
FDatasmithFacadeActor Actor = ElementData.ElementActor;
ElementData.ElementMetaData = new FDatasmithFacadeMetaData(Actor.GetName() + "_DATA");
ElementData.ElementMetaData.SetLabel(Actor.GetLabel());
ElementData.ElementMetaData.SetAssociatedElement(Actor);
FDocumentData.AddActorMetadata(RevitElement, ElementData.ElementMetaData);
++CurrentBatchSize;
#if DEBUG
Debug.WriteLine($"metadata batch element {CurrentBatchSize}, remain in Q {CacheData.ElementsWithoutMetadata.Count}");
#endif
}
return(true);
};
List <FCachedDocumentData> CachesToExport = new List <FCachedDocumentData>();
Action <FCachedDocumentData> GetLinkedDocuments = null;
GetLinkedDocuments = (FCachedDocumentData InParent) =>
{
CachesToExport.Add(InParent);
foreach (var Cache in InParent.LinkedDocumentsCache.Values)
{
GetLinkedDocuments(Cache);
}
};
GetLinkedDocuments(RootCache);
foreach (var Cache in CachesToExport)
{
bool Success = AddElements(Cache);
if (!Success)
{
#if DEBUG
Debug.WriteLine("metadata cancelled");
#endif
return; // Metadata export was cancelled.
}
}
if (CurrentBatchSize > 0)
{
// Send remaining chunk of metadata.
DatasmithScene.BuildScene(SceneName);
DatasmithDirectLink.UpdateScene(DatasmithScene);
}
#if DEBUG
Debug.WriteLine("metadata exported");
#endif
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(FDatasmithFacadeActor obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public void AddChild(FDatasmithFacadeActor InChildActorPtr)
{
DatasmithFacadeCSharpPINVOKE.FDatasmithFacadeActor_AddChild(swigCPtr, FDatasmithFacadeActor.getCPtrAndDisown(InChildActorPtr));
}
public void AddActor(FDatasmithFacadeActor InActorPtr)
{
DatasmithFacadeCSharpPINVOKE.FDatasmithFacadeScene_AddActor(swigCPtr, FDatasmithFacadeActor.getCPtr(InActorPtr));
}
public void RemoveActor(FDatasmithFacadeActor InActorPtr)
{
DatasmithFacadeCSharpPINVOKE.FDatasmithFacadeScene_RemoveActor__SWIG_1(swigCPtr, FDatasmithFacadeActor.getCPtr(InActorPtr));
}
public void RemoveActor(FDatasmithFacadeActor InActorPtr, FDatasmithFacadeScene.EActorRemovalRule RemovalRule)
{
DatasmithFacadeCSharpPINVOKE.FDatasmithFacadeScene_RemoveActor__SWIG_0(swigCPtr, FDatasmithFacadeActor.getCPtr(InActorPtr), (int)RemovalRule);
}
public void RemoveChild(FDatasmithFacadeActor InChild)
{
DatasmithFacadeCSharpPINVOKE.FDatasmithFacadeActor_RemoveChild(swigCPtr, FDatasmithFacadeActor.getCPtr(InChild));
}
