/// <summary>
/// Check if the selected material supports "tint".
/// </summary>
/// <returns>True if the selected material supports "tint" or not.</returns>
private bool SupportTintColor()
{
if (this.m_currentAppearanceAssetElementId == ElementId.InvalidElementId)
{
return(false);
}
AppearanceAssetElement assetElem = m_document.GetElement(this.m_currentAppearanceAssetElementId) as AppearanceAssetElement;
if (assetElem == null)
{
return(false);
}
Asset asset = assetElem.GetRenderingAsset();
AssetPropertyDoubleArray4d tintColorProp = asset["common_Tint_color"] as AssetPropertyDoubleArray4d;
if (tintColorProp == null)
{
return(false);
}
// If the material supports tint but it is not enabled, it will be enabled first with a value (255 255 255)
AssetPropertyBoolean tintToggleProp = asset["common_Tint_toggle"] as AssetPropertyBoolean;
if ((tintToggleProp != null) && !(tintToggleProp.Value))
{
EnableTintColor();
}
return(true);
}
public static Color4D ColorFromAssetDoubleArray4d(AssetPropertyDoubleArray4d prop)
{
#if REVIT2019 || REVIT2020
var colorValues = prop.GetValueAsDoubles()?.ToList() ?? new List <double>();
if (colorValues != null && colorValues.Count > 3)
{
return(new Color4D(
(float)colorValues[0],
(float)colorValues[1],
(float)colorValues[2],
(float)colorValues[3]));
}
else
{
// Default return if invalid
return(new Color4D(200));
}
#else
return(new Color4D(
(float)prop.Value.get_Item(0),
(float)prop.Value.get_Item(1),
(float)prop.Value.get_Item(2),
(float)prop.Value.get_Item(3)));
#endif
}
//----------------------------------------------------------
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);
}
}
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());
}
private ModelMaterial ExportMaterial(Tuple <Document, ElementId> documentAndMaterialId)
{
Document item = documentAndMaterialId.Item1;
ElementId item2 = documentAndMaterialId.Item2;
ModelMaterial exportedMaterial = new ModelMaterial();
Material material = item.GetElement(item2) as Material;
if (material != null && material.IsValidObject)
{
exportedMaterial.Name = textureFinder.CleanName(material.Name, userSetting);
if (material.Color.IsValid)
{
exportedMaterial.Color = System.Drawing.Color.FromArgb(material.Color.Red, material.Color.Green, material.Color.Blue);
}
exportedMaterial.Shininess = material.Shininess;
exportedMaterial.Transparency = material.Transparency;
if (material.AppearanceAssetId != ElementId.InvalidElementId)
{
Asset asset = (item.GetElement(material.AppearanceAssetId) as AppearanceAssetElement).GetRenderingAsset();
if (asset.Size == 0)
{
AssetSetIterator assetSetIterator = libraryAssetSet.ForwardIterator();
while (assetSetIterator.MoveNext())
{
Asset asset2 = assetSetIterator.Current as Asset;
if (asset2 != null && asset2.Name == asset.Name)
{
asset = asset2;
break;
}
}
}
textureFinder.FindDiffuseTexturePathFromAsset(exportedMaterial, asset);
AssetPropertyDoubleArray4d assetPropertyDoubleArray4d = asset.FindByName("generic_diffuse") as AssetPropertyDoubleArray4d;
if (assetPropertyDoubleArray4d != null)
{
exportedMaterial.Color = System.Drawing.Color.FromArgb((byte)(assetPropertyDoubleArray4d.GetValueAsDoubles().ElementAt(1) * 255.0), ((byte)(assetPropertyDoubleArray4d.GetValueAsDoubles().ElementAt(1) * 255.0)), (byte)(assetPropertyDoubleArray4d.GetValueAsDoubles().ElementAt(2) * 255.0));
}
}
}
return(exportedMaterial);
}
/// <summary>
/// Check if the button Lighter is enabled.
/// </summary>
/// <returns>True if the material can be made lighter or not.</returns>
internal bool IsLighterEnabled()
{
if (!SupportTintColor())
{
return(false);
}
AppearanceAssetElement assetElem = m_document.GetElement(m_currentAppearanceAssetElementId) as AppearanceAssetElement;
if (assetElem == null)
{
return(false);
}
Asset asset = assetElem.GetRenderingAsset();
AssetPropertyDoubleArray4d tintColorProp = asset.FindByName("common_Tint_color") as AssetPropertyDoubleArray4d;
Color tintColor = tintColorProp.GetValueAsColor();
Color white = new Color(255, 255, 255);
return(!ColorsEqual(tintColor, white));
}
/// <summary>
/// Check if the button Darker is enabled.
/// </summary>
/// <returns>True if the material can be made darker or not.</returns>
internal bool IsDarkerEnabled()
{
if (!SupportTintColor())
{
return(false);
}
AppearanceAssetElement assetElem = m_document.GetElement(this.m_currentAppearanceAssetElementId) as AppearanceAssetElement;
if (assetElem == null)
{
return(false);
}
Asset asset = assetElem.GetRenderingAsset();
AssetPropertyDoubleArray4d tintColorProp = asset["common_Tint_color"] as AssetPropertyDoubleArray4d;
Color tintColor = tintColorProp.GetValueAsColor();
Color black = new Color(0, 0, 0);
return(!ColorsEqual(tintColor, black));
}
//----------------------------------------------------------
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);
}
}
public void ReadAssetProperty(AssetProperty prop, StreamWriter objWriter)
{
switch (prop.Type)
{
// Retrieve the value from simple type property is easy.
// for example, retrieve bool property value.
#if R2016
case AssetPropertyType.APT_Integer:
#elif R2018
case AssetPropertyType.Integer:
#endif
var AssetPropertyInt = prop as AssetPropertyInteger;
objWriter.WriteLine(AssetPropertyInt.Name + "= " + AssetPropertyInt.Value.ToString() + ";" + AssetPropertyInt.IsReadOnly.ToString());
break;
#if R2016
case AssetPropertyType.APT_Distance:
#elif R2018
case AssetPropertyType.Distance:
#endif
var AssetPropertyDistance = prop as AssetPropertyDistance;
objWriter.WriteLine(AssetPropertyDistance.Name + "= " + AssetPropertyDistance.Value + ";" + AssetPropertyDistance.IsReadOnly.ToString());
break;
#if R2016
case AssetPropertyType.APT_Double:
#elif R2018
case AssetPropertyType.Double1:
#endif
var AssetPropertyDouble = prop as AssetPropertyDouble;
objWriter.WriteLine(AssetPropertyDouble.Name + "= " + AssetPropertyDouble.Value.ToString() + ";" + AssetPropertyDouble.IsReadOnly.ToString());
break;
#if R2016
case AssetPropertyType.APT_DoubleArray2d:
#elif R2018
case AssetPropertyType.Double2:
#endif
var AssetPropertyDoubleArray2d = prop as AssetPropertyDoubleArray2d;
objWriter.WriteLine(AssetPropertyDoubleArray2d.Name + "= " + AssetPropertyDoubleArray2d.Value.ToString() + ";" + AssetPropertyDoubleArray2d.IsReadOnly.ToString());
break;
#if R2016
case AssetPropertyType.APT_DoubleArray4d:
#elif R2018
case AssetPropertyType.Double4:
#endif
var AssetPropertyDoubleArray4d = prop as AssetPropertyDoubleArray4d;
objWriter.WriteLine(AssetPropertyDoubleArray4d.Name + "= " + AssetPropertyDoubleArray4d.Value.ToString() + ";" + AssetPropertyDoubleArray4d.IsReadOnly.ToString());
break;
#if R2016
case AssetPropertyType.APT_String:
#elif R2018
case AssetPropertyType.String:
#endif
AssetPropertyString val = prop as AssetPropertyString;
objWriter.WriteLine(val.Name + "= " + val.Value + ";" + val.IsReadOnly.ToString());
break;
#if R2016
case AssetPropertyType.APT_Boolean:
#elif R2018
case AssetPropertyType.Boolean:
#endif
AssetPropertyBoolean boolProp = prop as AssetPropertyBoolean;
objWriter.WriteLine(boolProp.Name + "= " + boolProp.Value.ToString() + ";" + boolProp.IsReadOnly.ToString());
break;
// When you retrieve the value from the data array property,
// you may need to get which value the property stands for.
// for example, the APT_Double44 may be a transform data.
#if R2016
case AssetPropertyType.APT_Double44:
#elif R2018
case AssetPropertyType.Double44:
#endif
AssetPropertyDoubleArray4d transformProp = prop as AssetPropertyDoubleArray4d;
DoubleArray tranformValue = transformProp.Value;
objWriter.WriteLine(transformProp.Name + "= " + transformProp.Value.ToString() + ";" + tranformValue.IsReadOnly.ToString());
break;
// The APT_List contains a list of sub asset properties with same type.
#if R2016
case AssetPropertyType.APT_List:
#elif R2018
case AssetPropertyType.List:
#endif
AssetPropertyList propList = prop as AssetPropertyList;
IList <AssetProperty> subProps = propList.GetValue();
if (subProps.Count == 0)
{
break;
}
switch (subProps[0].Type)
{
#if R2016
case AssetPropertyType.APT_Integer:
#elif R2018
case AssetPropertyType.Integer:
#endif
foreach (AssetProperty subProp in subProps)
{
AssetPropertyInteger intProp = subProp as AssetPropertyInteger;
int intValue = intProp.Value;
objWriter.WriteLine(intProp.Name + "= " + intProp.Value.ToString() + ";" + intProp.IsReadOnly.ToString());
}
break;
#if R2016
case AssetPropertyType.APT_String:
#elif R2018
case AssetPropertyType.String:
#endif
foreach (AssetProperty subProp in subProps)
{
AssetPropertyString intProp = subProp as AssetPropertyString;
string intValue = intProp.Value;
objWriter.WriteLine(intProp.Name + "= " + intProp.Value.ToString() + ";" + intProp.IsReadOnly.ToString());
}
break;
}
break;
#if R2016
case AssetPropertyType.APT_Asset:
#elif R2018
case AssetPropertyType.Asset:
#endif
Asset propAsset = prop as Asset;
for (int i = 0; i < propAsset.Size; i++)
{
ReadAssetProperty(propAsset[i], objWriter);
}
break;
#if R2016
case AssetPropertyType.APT_Reference:
#elif R2018
case AssetPropertyType.Reference:
#endif
break;
default:
objWriter.WriteLine("居然有啥都不是类型的" + prop.Type.ToString());
break;
}
// Get the connected properties.
// please notice that the information of many texture stores here.
if (prop.NumberOfConnectedProperties == 0)
{
return;
}
foreach (AssetProperty connectedProp in prop.GetAllConnectedProperties())
{
ReadAssetProperty(connectedProp, objWriter);
}
}
private static Tuple <Type, Object> GetTypeAndValue(AssetProperty assetProperty, int level)
{
Object theValue;
Type valueType;
//For each AssetProperty, it has different type and value
//must deal with it separately
try
{
if (assetProperty is AssetPropertyBoolean)
{
AssetPropertyBoolean property = assetProperty as AssetPropertyBoolean;
valueType = typeof(AssetPropertyBoolean);
theValue = property.Value;
}
else if (assetProperty is AssetPropertyDistance)
{
AssetPropertyDistance property = assetProperty as AssetPropertyDistance;
valueType = typeof(AssetPropertyDistance);
theValue = property.Value;
}
else if (assetProperty is AssetPropertyDouble)
{
AssetPropertyDouble property = assetProperty as AssetPropertyDouble;
valueType = typeof(AssetPropertyDouble);
theValue = property.Value;
}
else if (assetProperty is AssetPropertyDoubleArray2d)
{
//Default, it is supported by PropertyGrid to display Double []
//Try to convert DoubleArray to Double []
AssetPropertyDoubleArray2d property = assetProperty as AssetPropertyDoubleArray2d;
valueType = typeof(AssetPropertyDoubleArray2d);
theValue = GetSystemArrayAsString(property.Value);
}
else if (assetProperty is AssetPropertyDoubleArray3d)
{
AssetPropertyDoubleArray3d property = assetProperty as AssetPropertyDoubleArray3d;
valueType = typeof(AssetPropertyDoubleArray3d);
//theValue = GetSystemArrayAsString( property.Value ); // 2017
theValue = Util.DoubleArrayString(property.GetValueAsDoubles()); // 2018
}
else if (assetProperty is AssetPropertyDoubleArray4d)
{
AssetPropertyDoubleArray4d property = assetProperty as AssetPropertyDoubleArray4d;
valueType = typeof(AssetPropertyDoubleArray4d);
//theValue = GetSystemArrayAsString( property.Value ); // 2017
theValue = Util.DoubleArrayString(property.GetValueAsDoubles()); // 2018
}
else if (assetProperty is AssetPropertyDoubleMatrix44)
{
AssetPropertyDoubleMatrix44 property = assetProperty as AssetPropertyDoubleMatrix44;
valueType = typeof(AssetPropertyDoubleMatrix44);
theValue = GetSystemArrayAsString(property.Value);
}
else if (assetProperty is AssetPropertyEnum)
{
AssetPropertyEnum property = assetProperty as AssetPropertyEnum;
valueType = typeof(AssetPropertyEnum);
theValue = property.Value;
}
else if (assetProperty is AssetPropertyFloat)
{
AssetPropertyFloat property = assetProperty as AssetPropertyFloat;
valueType = typeof(AssetPropertyFloat);
theValue = property.Value;
}
else if (assetProperty is AssetPropertyInteger)
{
AssetPropertyInteger property = assetProperty as AssetPropertyInteger;
valueType = typeof(AssetPropertyInteger);
theValue = property.Value;
}
else if (assetProperty is AssetPropertyReference)
{
AssetPropertyReference property = assetProperty as AssetPropertyReference;
valueType = typeof(AssetPropertyReference);
theValue = "REFERENCE"; //property.Type;
}
else if (assetProperty is AssetPropertyString)
{
AssetPropertyString property = assetProperty as AssetPropertyString;
valueType = typeof(AssetPropertyString);
theValue = property.Value;
}
else if (assetProperty is AssetPropertyTime)
{
AssetPropertyTime property = assetProperty as AssetPropertyTime;
valueType = typeof(AssetPropertyTime);
theValue = property.Value;
}
else
{
valueType = typeof(String);
theValue = "Unprocessed asset type: " + assetProperty.GetType().Name;
}
if (assetProperty.NumberOfConnectedProperties > 0)
{
String result = "";
result = theValue.ToString();
TaskDialog.Show("Connected properties found", assetProperty.Name + ": " + assetProperty.NumberOfConnectedProperties);
IList <AssetProperty> properties = assetProperty.GetAllConnectedProperties();
foreach (AssetProperty property in properties)
{
if (property is Asset)
{
// Nested?
Asset asset = property as Asset;
int size = asset.Size;
for (int i = 0; i < size; i++)
{
//AssetProperty subproperty = asset[i]; // 2018
AssetProperty subproperty = asset.Get(i); // 2019
Tuple <Type, Object> valueAndType = GetTypeAndValue(subproperty, level + 1);
String indent = "";
if (level > 0)
{
for (int iLevel = 1; iLevel <= level; iLevel++)
{
indent += " ";
}
}
result += "\n " + indent + "- connected: name: " + subproperty.Name + " | type: " + valueAndType.Item1.Name +
" | value: " + valueAndType.Item2.ToString();
}
}
}
theValue = result;
}
}
catch
{
return(null);
}
return(new Tuple <Type, Object>(valueType, theValue));
}
/// <summary>
/// Gets the current value of the property on a component.
/// </summary>
/// <param name="component">The component with the property for which to retrieve the value.</param>
/// <returns>The value of a property for a given component.</returns>
public override object GetValue(object component)
{
//For each AssetProperty, it has different type and value
//must deal with it separately
try
{
if (m_assetProperty is AssetPropertyBoolean)
{
AssetPropertyBoolean property = m_assetProperty as AssetPropertyBoolean;
m_valueType = typeof(Boolean);
m_value = property.Value;
}
else if (m_assetProperty is AssetPropertyDistance)
{
AssetPropertyDistance property = m_assetProperty as AssetPropertyDistance;
m_valueType = typeof(Double);
m_value = property.Value;
}
else if (m_assetProperty is AssetPropertyDouble)
{
AssetPropertyDouble property = m_assetProperty as AssetPropertyDouble;
m_valueType = typeof(Double);
m_value = property.Value;
}
else if (m_assetProperty is AssetPropertyDoubleArray2d)
{
//Default, it is supported by PropertyGrid to display Double []
//Try to convert DoubleArray to Double []
AssetPropertyDoubleArray2d property = m_assetProperty as AssetPropertyDoubleArray2d;
m_valueType = typeof(Double[]);
m_value = GetSystemArray(property.Value);
}
else if (m_assetProperty is AssetPropertyDoubleArray3d)
{
AssetPropertyDoubleArray3d property = m_assetProperty as AssetPropertyDoubleArray3d;
m_valueType = typeof(Double[]);
m_value = GetSystemArray(property.Value);
}
else if (m_assetProperty is AssetPropertyDoubleArray4d)
{
AssetPropertyDoubleArray4d property = m_assetProperty as AssetPropertyDoubleArray4d;
m_valueType = typeof(Double[]);
m_value = GetSystemArray(property.Value);
}
else if (m_assetProperty is AssetPropertyDoubleMatrix44)
{
AssetPropertyDoubleMatrix44 property = m_assetProperty as AssetPropertyDoubleMatrix44;
m_valueType = typeof(Double[]);
m_value = GetSystemArray(property.Value);
}
else if (m_assetProperty is AssetPropertyEnum)
{
AssetPropertyEnum property = m_assetProperty as AssetPropertyEnum;
m_valueType = typeof(int);
m_value = property.Value;
}
else if (m_assetProperty is AssetPropertyFloat)
{
AssetPropertyFloat property = m_assetProperty as AssetPropertyFloat;
m_valueType = typeof(float);
m_value = property.Value;
}
else if (m_assetProperty is AssetPropertyInteger)
{
AssetPropertyInteger property = m_assetProperty as AssetPropertyInteger;
m_valueType = typeof(int);
m_value = property.Value;
}
else if (m_assetProperty is AssetPropertyReference)
{
AssetPropertyReference property = m_assetProperty as AssetPropertyReference;
m_valueType = typeof(String);
m_value = property.Type;
}
else if (m_assetProperty is AssetPropertyString)
{
AssetPropertyString property = m_assetProperty as AssetPropertyString;
m_valueType = typeof(String);
m_value = property.Value;
}
else if (m_assetProperty is AssetPropertyTime)
{
AssetPropertyTime property = m_assetProperty as AssetPropertyTime;
m_valueType = typeof(DateTime);
m_value = property.Value;
}
else
{
return(null);
}
}
catch
{
return(null);
}
return(m_value);
}
private void LogMaterial(AssetProperty asset, StringBuilder log, string t = null)
{
if (asset == null)
{
return;
}
log.Append(t + "Asset.Type:" + asset.Type.ToString() + "::" + asset.Name + "=");
switch (asset.Type)
{
case AssetPropertyType.APT_Asset:
Asset a = asset as Asset;
log.Append("Asset,Size:" + a.Size + "\n");
for (int i = 0; i < a.Size; i++)
{
LogMaterial(a[i], log, t + "\t");
}
break;
case AssetPropertyType.APT_Boolean:
AssetPropertyBoolean ab = asset as AssetPropertyBoolean;
log.Append(ab.Value + "\n");
break;
case AssetPropertyType.APT_Distance:
AssetPropertyDistance ad = asset as AssetPropertyDistance;
log.Append(ad.Value + "\n");
break;
case AssetPropertyType.APT_Double:
AssetPropertyDouble ado = asset as AssetPropertyDouble;
log.Append(ado.Value + "\n");
break;
case AssetPropertyType.APT_Double44:
break;
case AssetPropertyType.APT_DoubleArray2d:
AssetPropertyDoubleArray2d ado2 = asset as AssetPropertyDoubleArray2d;
log.Append(ado2.Value.get_Item(0) + "," + ado2.Value.get_Item(1) + "\n");
break;
case AssetPropertyType.APT_DoubleArray3d:
AssetPropertyDoubleArray3d ado3 = asset as AssetPropertyDoubleArray3d;
log.Append(ado3.Value.get_Item(0) + "," + ado3.Value.get_Item(1) + "," + ado3.Value.get_Item(2) + "\n");
break;
case AssetPropertyType.APT_DoubleArray4d:
AssetPropertyDoubleArray4d ado4 = asset as AssetPropertyDoubleArray4d;
log.Append(ado4.Value.get_Item(0) + "," + ado4.Value.get_Item(1) + "," + ado4.Value.get_Item(2) + "," + ado4.Value.get_Item(3) + "\n");
break;
case AssetPropertyType.APT_Enum:
AssetPropertyEnum ae = asset as AssetPropertyEnum;
log.Append(ae.Value + "\n");
break;
case AssetPropertyType.APT_Float:
AssetPropertyFloat af = asset as AssetPropertyFloat;
log.Append(af.Value + "\n");
break;
case AssetPropertyType.APT_FloatArray:
IList <float> lf = (asset as AssetPropertyFloatArray).GetValue();
foreach (float f in lf)
{
log.Append(f + ",");
}
log.Append("\n");
break;
case AssetPropertyType.APT_Int64:
AssetPropertyInt64 ai6 = asset as AssetPropertyInt64;
log.Append(ai6.Value + "\n");
break;
case AssetPropertyType.APT_Integer:
AssetPropertyInteger ai = asset as AssetPropertyInteger;
log.Append(ai.Value + "\n");
break;
case AssetPropertyType.APT_List:
break;
case AssetPropertyType.APT_Properties:
AssetProperties ap = asset as AssetProperties;
log.Append("AssetProperties,Count:" + ap.Size + "\n");
for (int i = 0; i < ap.Size; i++)
{
LogMaterial(ap[i], log, t + "\t");
}
break;
case AssetPropertyType.APT_Reference:
break;
case AssetPropertyType.APT_String:
AssetPropertyString _as = asset as AssetPropertyString;
log.Append(_as.Value + "\n");
break;
case AssetPropertyType.APT_Time:
AssetPropertyTime at = asset as AssetPropertyTime;
log.Append(at.Value + "\n");
break;
case AssetPropertyType.APT_UInt64:
AssetPropertyUInt64 aiu6 = asset as AssetPropertyUInt64;
log.Append(aiu6.Value + "\n");
break;
case AssetPropertyType.APT_Unknown:
log.Append("\n");
break;
default:
log.Append("\n");
break;
}
foreach (Asset _a in asset.GetAllConnectedProperties())
{
log.Append(t + "GetAllConnectedProperties:\n");
LogMaterial(_a, log, t + "\t");
}
}
private void AddFaceMaterial(Material materialElement, UIDocument doc)
{
//string s = geomFace.MaterialElement.Name;
//ElementId elementId = e.Id;
//MaterialSet materials = e.Materials;
//ElementId materialId = geomFace.MaterialElement.Id;
//Material materialElement = doc.Document.get_Element(materialId) as Material;
Asset m_asset = materialElement.RenderAppearance;
double[] d_featureBase = { 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0 };
//shininess
d_featureBase[cShininess] = (double)materialElement.Shininess / 128;
d_featureBase[cTransparency] = 1.0 - (double)materialElement.Transparency / 100;
d_featureBase[cAmbientR] = (double)materialElement.Color.Red / 255;
d_featureBase[cAmbientR + 1] = (double)materialElement.Color.Green / 255;
d_featureBase[cAmbientR + 2] = (double)materialElement.Color.Blue / 255;
d_featureBase[cSpecularR] = (double)d_featureBase[cAmbientR] * materialElement.Smoothness / 100;
d_featureBase[cSpecularR + 1] = (double)d_featureBase[cAmbientR + 1] * materialElement.Smoothness / 100;
d_featureBase[cSpecularR + 2] = (double)d_featureBase[cAmbientR + 2] * materialElement.Smoothness / 100;
Lid_FeatureMaterial.Add((double)Liu_FeatureIndex.Count + 1);
cl_ElementData clED_Values;
if (Dic_MaterialElementData.TryGetValue(materialElement.Name, out clED_Values))
{
for (int inex = 0; inex < 3; inex++)
{
if (null != clED_Values)
{
d_featureBase[cDiffuseR + inex] = clED_Values.Diffuse[inex];
}
}
}
else
{
clED_Values = new cl_ElementData();
double[] ap = { 0.0, 0.0, 0.0 };
clED_Values.Diffuse = ap;
for (int index = 0; index < m_asset.Size; index++)
{
AssetProperty m_assetProperty = m_asset[index];
if (null != m_assetProperty)
{
Type m_valueType;
Object m_value;
try
{
if (m_assetProperty is AssetPropertyDoubleArray4d)
{
AssetPropertyDoubleArray4d property = m_assetProperty as AssetPropertyDoubleArray4d;
//m_valueType = typeof(Double[]);
//m_value = GetSystemArray(property.Value); masonrycmu_color
if (m_assetProperty.Name == "generic_diffuse" ||
m_assetProperty.Name == "masonrycmu_color" ||
m_assetProperty.Name == "water_tint_color" ||
m_assetProperty.Name == "ceramic_color" ||
m_assetProperty.Name == "glazing_transmittance_map" ||
m_assetProperty.Name == "concrete_color" ||
m_assetProperty.Name == "plasticvinyl_color" ||
m_assetProperty.Name == "hardwood_tint_color" ||
m_assetProperty.Name == "metal_color" ||
m_assetProperty.Name == "solidglass_transmittance_custom_color" ||
m_assetProperty.Name == "wallpaint_color")
{
double[] values = new double[property.Value.Size];
int inro = 0;
foreach (Double value in property.Value)
{
values[inro++] = value;
}
d_featureBase[cDiffuseR] = (double)d_featureBase[cAmbientR] * values[0];
d_featureBase[cDiffuseR + 1] = (double)d_featureBase[cAmbientR + 1] * values[1];
d_featureBase[cDiffuseR + 2] = (double)d_featureBase[cAmbientR + 2] * values[2];
for (int inex = 0; inex < 3; inex++)
{
//d_featureBase[cDiffuseR + inex] = values[inex];
clED_Values.Diffuse[inex] = d_featureBase[cDiffuseR + inex];
}
}
}
else if (m_assetProperty is AssetPropertyDoubleArray2d)
{
//Default, it is supported by PropertyGrid to display Double []
//Try to convert DoubleArray to Double []
AssetPropertyDoubleArray2d property = m_assetProperty as AssetPropertyDoubleArray2d;
m_valueType = typeof(Double[]);
m_value = GetSystemArray(property.Value);
}
else if (m_assetProperty is AssetPropertyDoubleArray3d)
{
AssetPropertyDoubleArray3d property = m_assetProperty as AssetPropertyDoubleArray3d;
m_valueType = typeof(Double[]);
m_value = GetSystemArray(property.Value);
}
else if (m_assetProperty is AssetPropertyDoubleMatrix44)
{
AssetPropertyDoubleMatrix44 property = m_assetProperty as AssetPropertyDoubleMatrix44;
m_valueType = typeof(Double[]);
m_value = GetSystemArray(property.Value);
}
else
{
//AssetPropertyTime property = m_assetProperty as AssetPropertyTime;
//m_valueType = typeof(DateTime);
//m_value = property.Value;
}
}
catch
{
}
}
//FOR
}
Dic_MaterialElementData.Add(materialElement.Name, clED_Values);
}
for (int i_i = 0; i_i < d_featureBase.Length; i_i++)
{
Lid_FeatureMaterial.Add(d_featureBase[i_i]);
}
}
public void ReadAssetProperty(AssetProperty prop, StreamWriter objWriter)
{
switch (prop.Type)
{
// Retrieve the value from simple type property is easy.
// for example, retrieve bool property value.
#if _Revit2018
case AssetPropertyType.Integer:
#else
case AssetPropertyType.APT_Integer:
#endif
var AssetPropertyInt = prop as AssetPropertyInteger;
objWriter.WriteLine(_priexFix + AssetPropertyInt.Name + "= " + AssetPropertyInt.Value);
break;
#if _Revit2018
case AssetPropertyType.Distance:
#else
case AssetPropertyType.APT_Distance:
#endif
var AssetPropertyDistance = prop as AssetPropertyDistance;
objWriter.WriteLine(_priexFix + AssetPropertyDistance.Name + "= " + AssetPropertyDistance.Value);
break;
#if _Revit2018
case AssetPropertyType.Float:
#else
case AssetPropertyType.APT_Float:
#endif
var assFlot = prop as AssetPropertyFloat;
objWriter.WriteLine(_priexFix + assFlot.Name + "= " + assFlot.Value);
break;
#if _Revit2018
case AssetPropertyType.Double1:
#else
case AssetPropertyType.APT_Double:
#endif
var AssetPropertyDouble = prop as AssetPropertyDouble;
objWriter.WriteLine(_priexFix + AssetPropertyDouble.Name + "= " + AssetPropertyDouble.Value);
break;
#if _Revit2018
case AssetPropertyType.Double2:
#else
case AssetPropertyType.APT_DoubleArray2d:
#endif
var AssetPropertyDoubleArray2d = prop as AssetPropertyDoubleArray2d;
string msg = AssetPropertyDoubleArray2d.Value.Cast <double>().Aggregate(string.Empty, (current, v) => current + (v + ", "));
objWriter.WriteLine(_priexFix + AssetPropertyDoubleArray2d.Name + "= " + msg);
break;
#if _Revit2018
case AssetPropertyType.Double3:
var arr3d = prop as AssetPropertyDoubleArray3d;
msg = arr3d.GetValueAsDoubles().Cast <double>().Aggregate(string.Empty, (current, v) => current + (v + ", "));
#else
case AssetPropertyType.APT_DoubleArray3d:
var arr3d = prop as AssetPropertyDoubleArray3d;
msg = arr3d.Value.Cast <double>().Aggregate(string.Empty, (current, v) => current + (v + ", "));
#endif
objWriter.WriteLine(_priexFix + arr3d.Name + "= " + msg);
break;
#if _Revit2018
case AssetPropertyType.Double4:
var arr4d = prop as AssetPropertyDoubleArray4d;
msg = arr4d.GetValueAsDoubles().Cast <double>().Aggregate(string.Empty, (current, v) => current + (v + ", "));
#else
case AssetPropertyType.APT_DoubleArray4d:
var arr4d = prop as AssetPropertyDoubleArray4d;
msg = arr4d.Value.Cast <double>().Aggregate(string.Empty, (current, v) => current + (v + ", "));
#endif
objWriter.WriteLine(_priexFix + arr4d.Name + "= " + msg);
break;
#if _Revit2018
case AssetPropertyType.String:
#else
case AssetPropertyType.APT_String:
#endif
AssetPropertyString val = prop as AssetPropertyString;
objWriter.WriteLine(_priexFix + val.Name + "= " + val.Value);
break;
#if _Revit2018
case AssetPropertyType.Boolean:
#else
case AssetPropertyType.APT_Boolean:
#endif
AssetPropertyBoolean boolProp = prop as AssetPropertyBoolean;
objWriter.WriteLine(_priexFix + boolProp.Name + "= " + boolProp.Value);
break;
// When you retrieve the value from the data array property,
// you may need to get which value the property stands for.
// for example, the APT_Double44 may be a transform data.
#if _Revit2018
case AssetPropertyType.Double44:
#else
case AssetPropertyType.APT_Double44:
#endif
AssetPropertyDoubleArray4d transformProp = prop as AssetPropertyDoubleArray4d;
objWriter.WriteLine(_priexFix + transformProp.Name + "= " + transformProp.Value);
break;
// The APT_List contains a list of sub asset properties with same type.
#if _Revit2018
case AssetPropertyType.List:
#else
case AssetPropertyType.APT_List:
#endif
AssetPropertyList propList = prop as AssetPropertyList;
IList <AssetProperty> subProps = propList.GetValue();
if (subProps.Count == 0)
{
break;
}
objWriter.WriteLine(_priexFix + propList.Name + " as propList");
_priexFix += "\t";
foreach (var ap in subProps)
{
ReadAssetProperty(ap, objWriter);
}
_priexFix = _priexFix.Substring(0, _priexFix.Length - 1);
break;
#if _Revit2018
case AssetPropertyType.Asset:
#else
case AssetPropertyType.APT_Asset:
#endif
Asset propAsset = prop as Asset;
objWriter.WriteLine(_priexFix + propAsset.Name + " as Asset");
ReadAsset(propAsset, objWriter);
break;
#if _Revit2018
case AssetPropertyType.Enumeration:
#else
case AssetPropertyType.APT_Enum:
#endif
var propEnum = prop as AssetPropertyEnum;
objWriter.WriteLine(_priexFix + propEnum.Name + "= " + propEnum.Value);
break;
#if _Revit2018
case AssetPropertyType.Reference:
#else
case AssetPropertyType.APT_Reference:
#endif
var propRef = prop as AssetPropertyReference;
objWriter.WriteLine(_priexFix + prop.Name + " as propReference");
break;
default:
objWriter.WriteLine(_priexFix + "居然有啥都不是类型的" + prop.Type);
break;
}
// Get the connected properties.
// please notice that the information of many texture stores here.
if (prop.NumberOfConnectedProperties == 0)
{
return;
}
objWriter.WriteLine(_priexFix + "Connected Property: ");
_priexFix += "\t";
foreach (AssetProperty connectedProp in prop.GetAllConnectedProperties())
{
// Note: Usually, the connected property is an Asset.
ReadAssetProperty(connectedProp, objWriter);
}
_priexFix = _priexFix.Substring(0, _priexFix.Length - 1);
}
/// <summary>
/// 读取Asset中的各种属性
/// </summary>
/// <param name="prop"></param>
/// <param name="ttrgb"></param>
public void ReadAssetProperty(AssetProperty prop, string ttrgb)
{
switch (prop.Type)
{
#if R2016
case AssetPropertyType.APT_Integer:
#elif R2018
case AssetPropertyType.Integer:
#endif
var AssetPropertyInt = prop as AssetPropertyInteger;
break;
#if R2016
case AssetPropertyType.APT_Distance:
#elif R2018
case AssetPropertyType.Distance:
#endif
var AssetPropertyDistance = prop as AssetPropertyDistance;
break;
#if R2016
case AssetPropertyType.APT_Double:
#elif R2018
case AssetPropertyType.Double1:
#endif
var AssetPropertyDouble = prop as AssetPropertyDouble;
break;
#if R2016
case AssetPropertyType.APT_DoubleArray2d:
#elif R2018
case AssetPropertyType.Double2:
#endif
var AssetPropertyDoubleArray2d = prop as AssetPropertyDoubleArray2d;
break;
#if R2016
case AssetPropertyType.APT_DoubleArray4d:
#elif R2018
case AssetPropertyType.Double4:
#endif
var AssetPropertyDoubleArray4d = prop as AssetPropertyDoubleArray4d;
break;
#if R2016
case AssetPropertyType.APT_String:
#elif R2018
case AssetPropertyType.String:
#endif
AssetPropertyString val = prop as AssetPropertyString;
if (val.Name == "unifiedbitmap_Bitmap" && val.Value != "")
{
map.Add(ttrgb);
map.Add(val.Value.Trim().Replace("\\", ""));
}
break;
#if R2016
case AssetPropertyType.APT_Boolean:
#elif R2018
case AssetPropertyType.Boolean:
#endif
AssetPropertyBoolean boolProp = prop as AssetPropertyBoolean;
break;
#if R2016
case AssetPropertyType.APT_Double44:
#elif R2018
case AssetPropertyType.Double44:
#endif
AssetPropertyDoubleArray4d transformProp = prop as AssetPropertyDoubleArray4d;
#if R2016
DoubleArray tranformValue = transformProp.Value;
#elif R2018
DoubleArray tranformValue = (DoubleArray)transformProp.GetValueAsDoubles();
#endif
break;
//APT_Lis包含了一系列的子属性值
#if R2016
case AssetPropertyType.APT_List:
#elif R2018
case AssetPropertyType.List:
#endif
AssetPropertyList propList = prop as AssetPropertyList;
IList <AssetProperty> subProps = propList.GetValue();
if (subProps.Count == 0)
{
break;
}
switch (subProps[0].Type)
{
#if R2016
case AssetPropertyType.APT_Integer:
#elif R2018
case AssetPropertyType.Integer:
#endif
foreach (AssetProperty subProp in subProps)
{
AssetPropertyInteger intProp = subProp as AssetPropertyInteger;
int intValue = intProp.Value;
}
break;
#if R2016
case AssetPropertyType.APT_String:
#elif R2018
case AssetPropertyType.String:
#endif
foreach (AssetProperty subProp in subProps)
{
AssetPropertyString intProp = subProp as AssetPropertyString;
string intValue = intProp.Value;
if (intProp.Name == "unifiedbitmap_Bitmap" && intProp.Value != "")
{
map.Add(ttrgb);
map.Add(intProp.Value.Trim().Replace("\\", ""));
}
}
break;
}
break;
#if R2016
case AssetPropertyType.APT_Asset:
#elif R2018
case AssetPropertyType.Asset:
#endif
Asset propAsset = prop as Asset;
for (int i = 0; i < propAsset.Size; i++)
{
ReadAssetProperty(propAsset[i], ttrgb);
}
break;
#if R2016
case AssetPropertyType.APT_Reference:
#elif R2018
case AssetPropertyType.Reference:
#endif
break;
default:
break;
}
//遍历连接属性，一般位图信息存储在这里
if (prop.NumberOfConnectedProperties == 0)
{
return;
}
foreach (AssetProperty connectedProp in prop.GetAllConnectedProperties())
{
ReadAssetProperty(connectedProp, ttrgb);
}
}
