public void AddInstance(Rhino.Geometry.Transform transform)
{
foreach (GltfMeshMaterialPair pair in meshMaterialPairs)
{
Rhino.Geometry.Mesh rhinoMesh = pair.RhinoMesh.DuplicateMesh();
rhinoMesh.Transform(GltfUtils.YupToZup * transform);
rhinoMesh.TextureCoordinates.ReverseTextureCoordinates(1);
Guid objectId = doc.Objects.AddMesh(rhinoMesh);
Rhino.DocObjects.RhinoObject rhinoObject = doc.Objects.Find(objectId);
Rhino.Render.RenderMaterial material = converter.GetMaterial(pair.MaterialIndex);
if (rhinoObject != null && material != null)
{
rhinoObject.RenderMaterial = material;
rhinoObject.Attributes.MaterialSource = Rhino.DocObjects.ObjectMaterialSource.MaterialFromObject;
rhinoObject.Attributes.Name = pair.Name;
rhinoObject.CommitChanges();
}
}
}
private string TextureName(bool b, Rhino.DocObjects.RhinoObject myGeo)
{
//string tex = "No Texture";
if ((b) && Rhino.RhinoDoc.ActiveDoc.RenderTextures.Count > 0)
{
Rhino.Render.RenderMaterial myGeoRendMat = myGeo.GetRenderMaterial(true);
Rhino.Render.TextureMapping texMapping = myGeo.GetTextureMapping(1);
Rhino.Render.Fields.Field fields = myGeoRendMat.Fields.GetField(myGeoRendMat.Name);
string tex = fields.Name;
//Rhino.Render.RenderTexture renderTexture = myGeoRendMat.TextureChildSlotName
return(tex);
}
else
{
return("No Texture");
}
}
static ElementId ToHost(Rhino.Render.RenderMaterial mat, Document doc, string name)
{
var appearanceAssetId = ElementId.InvalidElementId;
#if REVIT_2019
if (AppearanceAssetElement.GetAppearanceAssetElementByName(doc, name) is AppearanceAssetElement appearanceAssetElement)
{
appearanceAssetId = appearanceAssetElement.Id;
}
else
{
appearanceAssetElement = GetGenericAppearanceAssetElement(doc);
if (appearanceAssetElement is null)
{
var assets = Revit.ActiveUIApplication.Application.GetAssets(AssetType.Appearance);
foreach (var asset in assets)
{
if (asset.Name == GenericAssetName())
{
appearanceAssetElement = AppearanceAssetElement.Create(doc, name, asset);
appearanceAssetId = appearanceAssetElement.Id;
break;
}
}
}
else
{
appearanceAssetElement = appearanceAssetElement.Duplicate(name);
appearanceAssetId = appearanceAssetElement.Id;
}
if (appearanceAssetId != ElementId.InvalidElementId)
{
using (var editScope = new AppearanceAssetEditScope(doc))
{
var editableAsset = editScope.Start(appearanceAssetId);
//var category = editableAsset.FindByName("category") as AssetPropertyString;
//category.Value = $":{mat.Category.FirstCharUpper()}";
var description = editableAsset.FindByName("description") as AssetPropertyString;
description.Value = mat.Notes ?? string.Empty;
var keyword = editableAsset.FindByName("keyword") as AssetPropertyString;
{
string tags = string.Empty;
foreach (var tag in (mat.Tags ?? string.Empty).Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
tags += $":{tag.Replace(':', ';')}";
}
keyword.Value = tags;
}
if (mat.SmellsLikeMetal || mat.SmellsLikeTexturedMetal)
{
var generic_self_illum_luminance = editableAsset.FindByName(Generic.GenericIsMetal) as AssetPropertyBoolean;
generic_self_illum_luminance.Value = true;
}
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.Diffuse, out Rhino.Display.Color4f diffuse))
{
var generic_diffuse = editableAsset.FindByName(Generic.GenericDiffuse) as AssetPropertyDoubleArray4d;
generic_diffuse.SetValueAsDoubles(new double[] { diffuse.R, diffuse.G, diffuse.B, diffuse.A });
}
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.Transparency, out double transparency))
{
var generic_transparency = editableAsset.FindByName(Generic.GenericTransparency) as AssetPropertyDouble;
generic_transparency.Value = transparency;
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.TransparencyColor, out Rhino.Display.Color4f transparencyColor))
{
diffuse = diffuse.BlendTo((float)transparency, transparencyColor);
var generic_diffuse = editableAsset.FindByName(Generic.GenericDiffuse) as AssetPropertyDoubleArray4d;
generic_diffuse.SetValueAsDoubles(new double[] { diffuse.R, diffuse.G, diffuse.B, diffuse.A });
}
}
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.Ior, out double ior))
{
var generic_refraction_index = editableAsset.FindByName(Generic.GenericRefractionIndex) as AssetPropertyDouble;
generic_refraction_index.Value = ior;
}
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.Shine, out double shine))
{
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.Specular, out Rhino.Display.Color4f specularColor))
{
var generic_reflectivity_at_0deg = editableAsset.FindByName(Generic.GenericReflectivityAt0deg) as AssetPropertyDouble;
generic_reflectivity_at_0deg.Value = shine * specularColor.L;
}
}
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.Reflectivity, out double reflectivity))
{
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.ReflectivityColor, out Rhino.Display.Color4f reflectivityColor))
{
var generic_reflectivity_at_90deg = editableAsset.FindByName(Generic.GenericReflectivityAt90deg) as AssetPropertyDouble;
generic_reflectivity_at_90deg.Value = reflectivity * reflectivityColor.L;
if (mat.Fields.TryGetValue("fresnel-enabled", out bool fresnel_enabled) && !fresnel_enabled)
{
diffuse = diffuse.BlendTo((float)reflectivity, reflectivityColor);
var generic_diffuse = editableAsset.FindByName(Generic.GenericDiffuse) as AssetPropertyDoubleArray4d;
generic_diffuse.SetValueAsDoubles(new double[] { diffuse.R, diffuse.G, diffuse.B, diffuse.A });
}
}
}
if (mat.Fields.TryGetValue("polish-amount", out double polish_amount))
{
var generic_glossiness = editableAsset.FindByName(Generic.GenericGlossiness) as AssetPropertyDouble;
generic_glossiness.Value = polish_amount;
}
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.Emission, out Rhino.Display.Color4f emission))
{
var generic_self_illum_filter_map = editableAsset.FindByName(Generic.GenericSelfIllumFilterMap) as AssetPropertyDoubleArray4d;
generic_self_illum_filter_map.SetValueAsDoubles(new double[] { emission.R, emission.G, emission.B, emission.A });
}
if (mat.Fields.TryGetValue(Rhino.Render.RenderMaterial.BasicMaterialParameterNames.DisableLighting, out bool self_illum))
{
var generic_self_illum_luminance = editableAsset.FindByName(Generic.GenericSelfIllumLuminance) as AssetPropertyDouble;
generic_self_illum_luminance.Value = self_illum ? 200000 : 0.0;
}
editScope.Commit(false);
}
}
}
#endif
return(appearanceAssetId);
}
internal SceneObject(Rhino.Geometry.Mesh mesh, Rhino.Render.RenderMaterial material)
{
m_mesh = mesh;
m_material = material;
}
