//----------------------------------------------------------
public static void set_appearance_asset(Document doc, Material material)
{
try
{
var asset = new FilteredElementCollector(doc).OfClass(typeof(AppearanceAssetElement)).First(x => x.Name == "Generic");
AppearanceAssetElement assetElem = asset as AppearanceAssetElement;
AppearanceAssetElement assetElemNew = assetElem.Duplicate(material.Name + DateTime.Now.ToString("ddMMyyHHmmss"));
AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(doc);
Asset editableAsset = editScope.Start(assetElemNew.Id);
AssetPropertyDoubleArray4d genericDiffuseProperty = editableAsset.FindByName("generic_diffuse") as AssetPropertyDoubleArray4d;
genericDiffuseProperty.SetValueAsColor(material.Color);
AssetPropertyDouble genericTransparency = editableAsset.FindByName("generic_transparency") as AssetPropertyDouble;
genericTransparency.Value = Convert.ToDouble(material.Transparency) / 100;
editScope.Commit(true);
material.AppearanceAssetId = assetElemNew.Id;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Sets the material's texture.
/// </summary>
/// <param name="material"></param>
/// <param name="angle"></param>
/// <param name="offset"></param>
/// <param name="size"></param>
public static void SetTextureBase(this Material material, double angle, double[] offset, double[] size)
{
var doc = material.Document;
if (offset == null || offset.Length == 0)
{
return;
}
if (size == null || size.Length == 0)
{
return;
}
using var editScope = new AppearanceAssetEditScope(doc);
var asset = editScope.Start(material.AppearanceAssetId);
if (asset[TextureWAngle] is AssetPropertyDouble angleProp)
{
angleProp.Value = angle;
}
if (asset[TextureRealWorldOffsetX] is AssetPropertyDistance xOffsetProp)
{
xOffsetProp.Value = UnitUtils.Convert(offset[0], DUT_DECIMAL_FEET, xOffsetProp.DisplayUnitType);
}
if (asset[TextureRealWorldOffsetY] is AssetPropertyDistance yOffsetProp)
{
yOffsetProp.Value = UnitUtils.Convert(offset[1], DUT_DECIMAL_FEET, yOffsetProp.DisplayUnitType);
}
if (asset[TextureRealWorldScaleX] is AssetPropertyDistance xSizeProp)
{
var minXSize = UnitUtils.Convert(0.01, xSizeProp.DisplayUnitType, DUT_MILLIMETERS);
if (size[0] > minXSize)
{
xSizeProp.Value = UnitUtils.Convert(size[0], DUT_DECIMAL_FEET, xSizeProp.DisplayUnitType);
}
}
if (asset[TextureRealWorldScaleY] is AssetPropertyDistance ySizeProp)
{
var minYSize = UnitUtils.Convert(0.01, ySizeProp.DisplayUnitType, DUT_MILLIMETERS);
if (size[1] > minYSize)
{
ySizeProp.Value = UnitUtils.Convert(size[1], DUT_DECIMAL_FEET, ySizeProp.DisplayUnitType);
}
}
editScope.Commit(true);
}
public void GetDiffuseColor()
{
var message = new StringBuilder();
Document doc = this.ActiveUIDocument.Document;
var materials = new FilteredElementCollector(doc).OfClass(typeof(Material)).ToList();
foreach (Material mat in materials)
{
try
{
ElementId appAssetId = mat.AppearanceAssetId;
if (appAssetId != ElementId.InvalidElementId)
{
AppearanceAssetElement assetElem = mat.Document.GetElement(appAssetId) as AppearanceAssetElement;
if (assetElem != null)
{
using (Transaction t = new Transaction(assetElem.Document, "Get Material Color"))
{
t.Start();
using (AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(assetElem.Document))
{
string name = mat.Name;
Asset editableAsset = editScope.Start(assetElem.Id);
AssetPropertyDoubleArray4d genericDiffuseProperty = editableAsset.FindByName("generic_diffuse") as AssetPropertyDoubleArray4d;
var color = genericDiffuseProperty.GetValueAsColor();
string red = color.Red.ToString();
string green = color.Green.ToString();
string blue = color.Blue.ToString();
message.AppendLine(name + "-" + red + "_" + green + "_" + blue + ".");
editScope.Commit(true);
}
t.Commit();
}
}
else
{
message.AppendLine(mat.Name.ToString() + " - " + appAssetId.ToString());
}
}
else
{
message.AppendLine(mat.Name.ToString() + " - " + appAssetId.ToString());
}
}
catch (Exception ex)
{
message.AppendLine(mat.Name.ToString() + " - " + ex.Message);
}
}
TaskDialog.Show("Materials in the project", message.ToString());
}
/// <summary>
/// Sets texture's path.
/// </summary>
/// <param name="material"></param>
/// <param name="texturePath"></param>
public static void SetTexturePath(this Material material, string texturePath)
{
var doc = material.Document;
using var editScope = new AppearanceAssetEditScope(doc);
var editableAsset = editScope.Start(material.AppearanceAssetId);
var bitmapAssist = editableAsset[UnifiedbitmapBitmap];
if (bitmapAssist is AssetPropertyString path && path.IsValidValue(texturePath))
{
path.Value = texturePath;
}
editScope.Commit(true);
}
void ChangeRenderingTexturePath(Document doc)
{
// As there is only one material in the sample
// project, we can use FilteredElementCollector
// and grab the first result
Material mat = new FilteredElementCollector(doc).OfClass(typeof(Material)).FirstElement() as Material;
// Fixed path for new texture
// Texture included in sample files
string texturePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "new_texture.png");
using (Transaction t = new Transaction(doc))
{
t.Start("Changing material texture path");
using (AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(doc))
{
Asset editableAsset = editScope.Start(mat.AppearanceAssetId);
// Getting the correct AssetProperty
AssetProperty assetProperty = editableAsset["generic_diffuse"];
Asset connectedAsset = assetProperty.GetConnectedProperty(0) as Asset;
// Getting the right connected Asset
if (connectedAsset.Name == "UnifiedBitmapSchema")
{
AssetPropertyString path = connectedAsset.FindByName(UnifiedBitmap.UnifiedbitmapBitmap) as AssetPropertyString;
if (path.IsValidValue(texturePath))
{
path.Value = texturePath;
}
}
editScope.Commit(true);
}
TaskDialog.Show("Material texture path", "Material texture path changed to:\n" + texturePath);
t.Commit();
t.Dispose();
}
}
/// <summary>
/// 更改外观
/// </summary>
/// <param name="material"></param>
/// <param name="bumpmapImageFilepath"></param>
public static void ChangeRenderingTexturePath(Material mat, Document doc, string texturePath, double x, double y)
{
using (AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(doc))
{
Asset editableAsset = editScope.Start(mat.AppearanceAssetId);
#if VERSION2018
AssetProperty assetProperty = editableAsset["generic_diffuse"];
#else
// VERSION2019
AssetProperty assetProperty = editableAsset.FindByName("generic_diffuse");
#endif
Asset connectedAsset = assetProperty.GetConnectedProperty(0) as Asset;
/*if (connectedAsset == null)
* {
*
* // Add a new default connected asset
* assetProperty.AddConnectedAsset("UnifiedBitmap");
* connectedAsset = assetProperty.GetSingleConnectedAsset();
* }*/
if (connectedAsset.Name == "UnifiedBitmapSchema")
{
// TaskDialog.Show("Tip", "成功");
AssetPropertyString path = connectedAsset.FindByName(UnifiedBitmap.UnifiedbitmapBitmap) as AssetPropertyString;
AssetPropertyBoolean scalelock = connectedAsset.FindByName(UnifiedBitmap.TextureScaleLock) as AssetPropertyBoolean;
scalelock.Value = false;
AssetPropertyDistance sizeY = connectedAsset.FindByName(UnifiedBitmap.TextureRealWorldScaleY) as AssetPropertyDistance;
sizeY.Value = y;
AssetPropertyDistance sizeX = connectedAsset.FindByName(UnifiedBitmap.TextureRealWorldScaleX) as AssetPropertyDistance;
sizeX.Value = x;
if (path.IsValidValue(texturePath))
{
path.Value = texturePath;
}
else
{
throw new Exception("找不到文件:" + texturePath);
//TaskDialog.Show("Tip", "文件路径错误");
}
}
editScope.Commit(true);
}
}
// 定义修改贴图路径的方法
public string ChangeRenderingTexturePath(Document doc, Material mat, string newPath)
{
try
{
using (Transaction t = new Transaction(doc))
{
t.Start("更改贴图位置");
using (AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(doc))
{
Asset editableAsset = editScope.Start(mat.AppearanceAssetId);
// Getting the correct AssetProperty
AssetProperty assetProperty = editableAsset.FindByName("generic_diffuse");
if (assetProperty is null)
{
assetProperty = editableAsset.FindByName("masonrycmu_color");
}
Asset connectedAsset = assetProperty.GetConnectedProperty(0) as Asset;
// getting the right connected Asset
if (connectedAsset.Name == "UnifiedBitmapSchema")
{
AssetPropertyString path = connectedAsset.FindByName(UnifiedBitmap.UnifiedbitmapBitmap) as AssetPropertyString;
if (path.IsValidValue(newPath))
{
path.Value = newPath;
}
}
editScope.Commit(true);
}
t.Commit();
t.Dispose();
}
return(mat.Name);
}
catch (Exception)
{
TaskDialog.Show("错误提示！！！", "材质【" + mat.Name + "】的贴图更改失败，请手动更改材质贴图");
return(null);
}
}
//----------------------------------------------------------
public void SetColorAppearanceAsset(Document doc, Material material)
{
try
{
var list = new FilteredElementCollector(doc).OfClass(typeof(AppearanceAssetElement)).ToList();
List <string> name = new List <string>();
foreach (AppearanceAssetElement e in list)
{
name.Add(e.Name);
}
string newName = "";
for (var i = 0; i < 10000000; i++)
{
if (name.Any(x => x == material.Name + "(" + i.ToString() + ")") == false)
{
newName = material.Name + "(" + i.ToString() + ")";
break;
}
}
AppearanceAssetElement assetElem = list[0] as AppearanceAssetElement;
AppearanceAssetElement assetElemNew = assetElem.Duplicate(newName);
AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(doc);
Asset editableAsset = editScope.Start(assetElemNew.Id);
AssetPropertyDoubleArray4d genericDiffuseProperty = editableAsset["generic_diffuse"] as AssetPropertyDoubleArray4d;
genericDiffuseProperty.SetValueAsColor(material.Color);
AssetPropertyDouble genericTransparency = editableAsset["generic_transparency"] as AssetPropertyDouble;
genericTransparency.Value = Convert.ToDouble(material.Transparency) / 100;
editScope.Commit(true);
material.AppearanceAssetId = assetElemNew.Id;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Enable tint color.
/// </summary>
private void EnableTintColor()
{
using (Transaction transaction = new Transaction(m_document, "Enable tint color"))
{
transaction.Start();
using (AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(m_document))
{
Asset editableAsset = editScope.Start(m_currentAppearanceAssetElementId);
// If the material supports tint but it is not enabled, it will be enabled first with a value (255 255 255)
AssetPropertyBoolean tintToggleProp = editableAsset["common_Tint_toggle"] as AssetPropertyBoolean;
AssetPropertyDoubleArray4d tintColorProp = editableAsset["common_Tint_color"] as AssetPropertyDoubleArray4d;
tintToggleProp.Value = true;
tintColorProp.SetValueAsColor(new Color(255, 255, 255));
editScope.Commit(true);
}
transaction.Commit();
}
}
/// <summary>
/// Edit tint color property.
/// </summary>
/// <param name="lighter">Increase the tint color property or not.</param>
internal void EditMaterialTintColorProperty(bool lighter)
{
using (AppearanceAssetEditScope editScope = new AppearanceAssetEditScope(m_document))
{
Asset editableAsset = editScope.Start(m_currentAppearanceAssetElementId);
AssetPropertyDoubleArray4d metalColorProp = editableAsset["common_Tint_color"] as AssetPropertyDoubleArray4d;
Color color = metalColorProp.GetValueAsColor();
byte red = color.Red;
byte green = color.Green;
byte blue = color.Blue;
// Increment factor (value related to 255)
int factor = 25;
if (lighter)
{
red = (byte)LimitValue(red + factor);
green = (byte)LimitValue(green + factor);
blue = (byte)LimitValue(blue + factor);
}
else
{
red = (byte)LimitValue(red - factor);
green = (byte)LimitValue(green - factor);
blue = (byte)LimitValue(blue - factor);
}
if (metalColorProp.IsValidValue(color))
{
metalColorProp.SetValueAsColor(new Color(red, green, blue));
}
editScope.Commit(true);
}
}
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);
}
static ElementId ToHost(Rhino.DocObjects.Material mat, Document doc, Dictionary <string, Autodesk.Revit.DB.Material> materials)
{
var id = ElementId.InvalidElementId;
if (materials.TryGetValue(mat.Name ?? "Default", out var material))
{
id = material.Id;
}
else
{
id = Autodesk.Revit.DB.Material.Create(doc, mat.Name);
var newMaterial = doc.GetElement(id) as Autodesk.Revit.DB.Material;
newMaterial.Color = new Autodesk.Revit.DB.Color(255, 255, 255);
#if REVIT_2019
if (newMaterial.AppearanceAssetId == ElementId.InvalidElementId)
{
if (AppearanceAssetElement.GetAppearanceAssetElementByName(doc, mat.Name) is AppearanceAssetElement appearanceAssetElement)
{
newMaterial.AppearanceAssetId = appearanceAssetElement.Id;
}
else
{
appearanceAssetElement = AppearanceAssetElement.GetAppearanceAssetElementByName(doc, "Generic");
if (appearanceAssetElement is null)
{
var assets = Revit.ActiveUIApplication.Application.GetAssets(AssetType.Appearance);
foreach (var asset in assets)
{
if (asset.Name == "Generic")
{
appearanceAssetElement = AppearanceAssetElement.Create(doc, mat.Name, asset);
newMaterial.AppearanceAssetId = appearanceAssetElement.Id;
break;
}
}
}
else
{
appearanceAssetElement = appearanceAssetElement.Duplicate(mat.Name);
newMaterial.AppearanceAssetId = appearanceAssetElement.Id;
}
if (newMaterial.AppearanceAssetId != ElementId.InvalidElementId)
{
using (var editScope = new AppearanceAssetEditScope(doc))
{
var editableAsset = editScope.Start(newMaterial.AppearanceAssetId);
var genericDiffuseProperty = editableAsset.FindByName("generic_diffuse") as AssetPropertyDoubleArray4d;
genericDiffuseProperty.SetValueAsColor(mat.DiffuseColor.ToHost());
var properties = new List <AssetProperty>(editableAsset.Size);
for (int i = 0; i < editableAsset.Size; i++)
{
properties.Add(editableAsset[i]);
}
editScope.Commit(false);
}
}
}
}
#endif
materials.Add(mat.Name, newMaterial);
}
return(id);
}
