public static void ExportMaterials(FDatasmithFacadeScene DatasmithScene, DatasmithRhinoSceneParser SceneParser)
{
int TextureAndMaterialCount = SceneParser.TextureHashToTextureInfo.Count + SceneParser.MaterialHashToMaterialInfo.Count;
int TextureAndMaterialProgress = 0;
foreach (RhinoTextureInfo CurrentTextureInfo in SceneParser.TextureHashToTextureInfo.Values)
{
FDatasmithRhinoProgressManager.Instance.UpdateCurrentTaskProgress((float)(++TextureAndMaterialProgress) / TextureAndMaterialCount);
FDatasmithFacadeTexture TextureElement = ParseTexture(CurrentTextureInfo);
if (TextureElement != null)
{
DatasmithScene.AddTexture(TextureElement);
}
}
foreach (RhinoMaterialInfo CurrentMaterialInfo in SceneParser.MaterialHashToMaterialInfo.Values)
{
FDatasmithRhinoProgressManager.Instance.UpdateCurrentTaskProgress((float)(++TextureAndMaterialProgress) / TextureAndMaterialCount);
FDatasmithFacadeUEPbrMaterial DSMaterial = new FDatasmithFacadeUEPbrMaterial(CurrentMaterialInfo.Name);
DSMaterial.SetLabel(CurrentMaterialInfo.Label);
ParseMaterial(DSMaterial, CurrentMaterialInfo.RhinoMaterial, SceneParser);
DatasmithScene.AddMaterial(DSMaterial);
}
}
private static void ExportActors(FDatasmithFacadeScene DatasmithScene, DatasmithRhinoSceneParser SceneParser)
{
foreach (RhinoSceneHierarchyNode Node in SceneParser.SceneRoot)
{
if (Node.bIsRoot)
{
continue;
}
ExportHierarchyNode(DatasmithScene, Node, SceneParser);
}
}
public static Rhino.Commands.Result ExportScene(DatasmithRhinoSceneParser SceneParser, FDatasmithFacadeScene DatasmithScene)
{
FDatasmithRhinoProgressManager.Instance.StartMainTaskProgress("Exporting Materials", 0.2f);
FDatasmithRhinoMaterialExporter.ExportMaterials(DatasmithScene, SceneParser);
FDatasmithRhinoProgressManager.Instance.StartMainTaskProgress("Exporting Meshes", 0.7f);
FDatasmithRhinoMeshExporter.ExportMeshes(DatasmithScene, SceneParser);
FDatasmithRhinoProgressManager.Instance.StartMainTaskProgress("Exporting Actors", 0.8f);
ExportActors(DatasmithScene, SceneParser);
return(Rhino.Commands.Result.Success);
}
public static Rhino.PlugIns.WriteFileResult Export(string Filename, RhinoDoc RhinoDocument, Rhino.FileIO.FileWriteOptions Options)
{
string RhinoAppName = Rhino.RhinoApp.Name;
string RhinoVersion = Rhino.RhinoApp.ExeVersion.ToString();
FDatasmithFacadeElement.SetCoordinateSystemType(FDatasmithFacadeElement.ECoordinateSystemType.RightHandedZup);
FDatasmithFacadeElement.SetWorldUnitScale((float)Rhino.RhinoMath.UnitScale(RhinoDocument.ModelUnitSystem, UnitSystem.Centimeters));
FDatasmithFacadeScene DatasmithScene = new FDatasmithFacadeScene("Rhino", "Robert McNeel & Associates", "Rhino3D", RhinoVersion);
DatasmithScene.PreExport();
try
{
RhinoApp.WriteLine(string.Format("Exporting to {0}.", System.IO.Path.GetFileName(Filename)));
RhinoApp.WriteLine("Press Esc key to cancel...");
FDatasmithRhinoProgressManager.Instance.StartMainTaskProgress("Parsing Document", 0.1f);
DatasmithRhinoSceneParser SceneParser = new DatasmithRhinoSceneParser(RhinoDocument, Options);
SceneParser.ParseDocument();
if (ExportScene(SceneParser, DatasmithScene) == Rhino.Commands.Result.Success)
{
string SceneName = System.IO.Path.GetFileName(Filename);
FDatasmithRhinoProgressManager.Instance.StartMainTaskProgress("Writing to files..", 1);
DatasmithScene.ExportScene(Filename);
}
}
catch (DatasmithExportCancelledException)
{
return(Rhino.PlugIns.WriteFileResult.Cancel);
}
catch (Exception e)
{
RhinoApp.WriteLine("An unexpected error has occured:");
RhinoApp.WriteLine(e.ToString());
return(Rhino.PlugIns.WriteFileResult.Failure);
}
finally
{
FDatasmithRhinoProgressManager.Instance.StopProgress();
}
return(Rhino.PlugIns.WriteFileResult.Success);
}
public static void ExportMeshes(FDatasmithFacadeScene DatasmithScene, DatasmithRhinoSceneParser SceneParser)
{
int MeshIndex = 0;
int MeshCount = SceneParser.ObjectIdToMeshInfoDictionary.Count;
foreach (DatasmithMeshInfo CurrentMeshInfo in SceneParser.ObjectIdToMeshInfoDictionary.Values)
{
FDatasmithRhinoProgressManager.Instance.UpdateCurrentTaskProgress((float)(MeshIndex++) / MeshCount);
string HashedName = FDatasmithFacadeElement.GetStringHash(CurrentMeshInfo.Name);
FDatasmithFacadeMesh DatasmithMesh = new FDatasmithFacadeMesh(HashedName);
DatasmithMesh.SetLabel(CurrentMeshInfo.Label);
List <RhinoMaterialInfo> MaterialInfos = new List <RhinoMaterialInfo>(CurrentMeshInfo.MaterialIndices.Count);
CurrentMeshInfo.MaterialIndices.ForEach((MaterialIndex) => MaterialInfos.Add(SceneParser.GetMaterialInfoFromMaterialIndex(MaterialIndex)));
ParseMesh(DatasmithMesh, CurrentMeshInfo.RhinoMeshes, MaterialInfos);
DatasmithScene.AddMesh(DatasmithMesh);
}
}
public static void ParseMaterial(FDatasmithFacadeUEPbrMaterial DSMaterial, Material RhinoMaterial, DatasmithRhinoSceneParser SceneParser)
{
Color MaterialDiffuseColor = RhinoMaterial.DiffuseColor;
MaterialDiffuseColor = Color.FromArgb(255 - (byte)(255 * RhinoMaterial.Transparency), MaterialDiffuseColor);
Texture[] MaterialTextures = RhinoMaterial.GetTextures();
for (int TextureIndex = 0; TextureIndex < MaterialTextures.Length; ++TextureIndex)
{
Texture RhinoTexture = MaterialTextures[TextureIndex];
if (RhinoTexture != null)
{
RhinoTextureInfo TextureInfo = SceneParser.GetTextureInfoFromRhinoTexture(RhinoTexture.Id);
if (TextureInfo != null)
{
AddTextureToMaterial(DSMaterial, TextureInfo, MaterialDiffuseColor);
}
}
}
// Set a diffuse color if there's nothing in the BaseColor
if (DSMaterial.GetBaseColor().GetExpression() == null)
{
FDatasmithFacadeMaterialExpressionColor ColorExpression = DSMaterial.AddMaterialExpressionColor();
ColorExpression.SetName("Diffuse Color");
ColorExpression.SetsRGBColor(MaterialDiffuseColor.R, MaterialDiffuseColor.G, MaterialDiffuseColor.B, MaterialDiffuseColor.A);
ColorExpression.ConnectExpression(DSMaterial.GetBaseColor());
}
if (RhinoMaterial.Transparency > 0)
{
DSMaterial.SetBlendMode(/*EBlendMode::BLEND_Translucent*/ 2);
if (DSMaterial.GetOpacity().GetExpression() == null)
{
// Transparent color
FDatasmithFacadeMaterialExpressionScalar Scalar = DSMaterial.AddMaterialExpressionScalar();
Scalar.SetName("Opacity");
Scalar.SetScalar(1 - (float)RhinoMaterial.Transparency);
Scalar.ConnectExpression(DSMaterial.GetOpacity());
}
else
{
// Modulate the opacity map with the color transparency setting
FDatasmithFacadeMaterialExpressionGeneric Multiply = DSMaterial.AddMaterialExpressionGeneric();
Multiply.SetExpressionName("Multiply");
FDatasmithFacadeMaterialExpressionScalar Scalar = DSMaterial.AddMaterialExpressionScalar();
Scalar.SetName("Opacity Output Level");
Scalar.SetScalar(1 - (float)RhinoMaterial.Transparency);
Scalar.ConnectExpression(Multiply.GetInput(0));
FDatasmithFacadeMaterialExpression CurrentOpacityExpression = DSMaterial.GetOpacity().GetExpression();
CurrentOpacityExpression.ConnectExpression(Multiply.GetInput(1));
DSMaterial.GetOpacity().SetExpression(Multiply);
}
}
float Shininess = (float)(RhinoMaterial.Shine / Material.MaxShine);
if (Math.Abs(Shininess) > float.Epsilon)
{
FDatasmithFacadeMaterialExpressionScalar ShininessExpression = DSMaterial.AddMaterialExpressionScalar();
ShininessExpression.SetName("Roughness");
ShininessExpression.SetScalar(1f - Shininess);
ShininessExpression.ConnectExpression(DSMaterial.GetRoughness());
}
float Reflectivity = (float)RhinoMaterial.Reflectivity;
if (Math.Abs(Reflectivity) > float.Epsilon)
{
FDatasmithFacadeMaterialExpressionScalar ReflectivityExpression = DSMaterial.AddMaterialExpressionScalar();
ReflectivityExpression.SetName("Metallic");
ReflectivityExpression.SetScalar(Reflectivity);
ReflectivityExpression.ConnectExpression(DSMaterial.GetMetallic());
}
}
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 string GetDatasmithActorLayers(RhinoSceneHierarchyNode InNode, DatasmithRhinoSceneParser SceneParser)
{
bool bIsSameAsParentLayer =
!(InNode.Info.bHasRhinoLayer ||
(InNode.Parent.bIsRoot && InNode.Info.RhinoModelComponent == null) || //This is a dummy document layer.
(InNode.Parent?.Info.RhinoModelComponent as RhinoObject)?.ObjectType == ObjectType.InstanceReference);
if (bIsSameAsParentLayer && InNode.Parent?.DatasmithActor != null)
{
return(InNode.Parent.DatasmithActor.GetLayer());
}
else
{
return(SceneParser.GetNodeLayerString(InNode));
}
}
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);
}
