public AssetProperty(string label, AssetProperties assetProperties, Autodesk.Revit.DB.Visual.AssetProperty val) : base(label) { m_val = val; m_assetProperties = assetProperties; }
private void DrawSelectedAsset(AssetProperties assetProperties) { _selectedAssetStore.Clear(); foreach (var file in assetProperties.Asset.Files) { var row = _selectedAssetStore.AddRow(); _selectedAssetStore.SetValue(row, _selectedAssetNameField, file.ReducedPath); var imageSize = imageService.GetImageSize(file.Path); _selectedAssetStore.SetValue(row, _selectedAssetSizeField, imageSize.Width + "x" + imageSize.Height); _selectedAssetStore.SetValue(row, _selectedAssetImageField, Image.FromFile(file.Path).WithBoxSize(30, 30)); } _selectedAssetResultStore.Clear(); if (assetProperties.Result.Value == null) { return; } foreach (var condition in assetProperties.Result.Value) { var row = _selectedAssetResultStore.AddRow(); var resultImage = condition.IsFulfilled ? Image.FromResource("SwissAddinKnife.Resources.success.png") : Image.FromResource("SwissAddinKnife.Resources.unsuccess.png"); _selectedAssetResultStore.SetValue(row, _selectedAssetResultIconField, resultImage.WithBoxSize(15)); _selectedAssetResultStore.SetValue(row, _selectedAssetResultDescriptionField, condition.Description); } }
/// <summary> /// Used for determing if two AssetProperties are identical. /// </summary> /// <param name="props"></param> /// <returns></returns> public bool Equals(AssetProperties props) { return (props.color.Red == color.Red && props.color.Green == color.Green && props.color.Blue == color.Blue && transparency == props.transparency && translucency == props.translucency && props.specular == specular); }
/// <summary> /// Adds a surface to the output mesh. Not saved as a sub-surface until <see cref="DumpOutput"/> is called. /// </summary> /// <param name="bufferSurface">Surface to add to mesh.</param> /// <param name="asset">Asset for surface.</param> public void AddSurface(ref PartialSurface bufferSurface, AssetProperties asset) { // Create new surface BXDAMesh.BXDASurface newMeshSurface = new BXDAMesh.BXDASurface(); // Apply Asset Properties if (asset == null) { return; } newMeshSurface.hasColor = true; newMeshSurface.color = asset.color; newMeshSurface.transparency = (float)asset.transparency; newMeshSurface.translucency = (float)asset.translucency; newMeshSurface.specular = (float)asset.specular; // Prevent too many vertices if (bufferSurface.verts.count > MAX_VERTS_OR_FACETS) { throw new TooManyVerticesException(); } int indexOffset; lock (outputVerts) { // Prevent too many vertices if (outputVerts.count + bufferSurface.verts.count > MAX_VERTS_OR_FACETS) { DumpOutputInternal(); } // Copy buffer vertices into output Array.Copy(bufferSurface.verts.coordinates, 0, outputVerts.coordinates, outputVerts.count * 3, bufferSurface.verts.count * 3); Array.Copy(bufferSurface.verts.norms, 0, outputVerts.norms, outputVerts.count * 3, bufferSurface.verts.count * 3); // Store length of output verts for later indexOffset = outputVerts.count - 1; outputVerts.count += bufferSurface.verts.count; } // Copy buffer surface into output, incrementing indices relative to where verts where stitched into the vert array newMeshSurface.indicies = new int[bufferSurface.facets.count * 3]; for (int i = 0; i < bufferSurface.facets.count * 3; i++) { newMeshSurface.indicies[i] = bufferSurface.facets.indices[i] + indexOffset; // Why does Inventor start from 1?! } // Add the new surface to the output lock (outputMeshSurfaces) outputMeshSurfaces.Add(newMeshSurface); // Empty buffer bufferSurface.verts.count = 0; bufferSurface.facets.count = 0; }
/// <summary> /// Calculates the facets of a surface, storing them in a <see cref="MeshController"/>. /// </summary> private void CalculateSurfaceFacets(SurfaceBody surf, MeshController outputMesh, bool separateFaces = false) { double tolerance = DEFAULT_TOLERANCE; PartialSurface bufferSurface = new PartialSurface(); // Store a list of faces separate from the Inventor API Faces faces = surf.Faces; // Don't separate if only one color if (separateFaces) { separateFaces = MultipleAssets(faces); } // Do separate if too many faces if (!separateFaces) { surf.CalculateFacets(tolerance, out bufferSurface.verts.count, out bufferSurface.facets.count, out bufferSurface.verts.coordinates, out bufferSurface.verts.norms, out bufferSurface.facets.indices); if (bufferSurface.verts.count > MAX_VERTS_OR_FACETS || bufferSurface.facets.count > MAX_VERTS_OR_FACETS) { separateFaces = true; } } if (separateFaces) { // Add facets for each face of the surface foreach (Face face in faces) { if (face.Appearance != null) { face.CalculateFacets(tolerance, out bufferSurface.verts.count, out bufferSurface.facets.count, out bufferSurface.verts.coordinates, out bufferSurface.verts.norms, out bufferSurface.facets.indices); outputMesh.AddSurface(ref bufferSurface, GetAssetProperties(face.Appearance)); } } } else { // Add facets once for the entire surface AssetProperties asset; try { asset = GetAssetProperties(faces[1].Appearance); } catch (Exception) { asset = new AssetProperties(); } outputMesh.AddSurface(ref bufferSurface, asset); } }
private string GenerateAssetWeightUri(double?loadedWeight, AssetProperties assetProperties) { if (loadedWeight != null && loadedWeight > 0) { return($"&vehicleWeight={loadedWeight}"); } if (assetProperties != null && assetProperties.AssetWeight != null) { return($"&vehicleWeight={assetProperties.AssetWeight}"); } return(""); }
private string GenerateAssetWidthUri(double?loadedWidth, AssetProperties assetProperties) { if (loadedWidth != null && loadedWidth > 0) { return($"&vehicleWidth={loadedWidth}"); } if (assetProperties != null && assetProperties.AssetWidth != null) { return($"&vehicleWidth={assetProperties.AssetWidth}"); } return(""); }
private static string GetAssetInfos(AssetProperties a) { StringBuilder sb = new StringBuilder(); sb.Append( "\n- Name:\t\t" + a.Name + "\n- Path:\t\t" + a.Path + "\n- Checked:\t" + a.IsChecked + "\n- Selected:\tTrue" + "\n" ); return(sb.ToString()); }
private void RC_Properties_Click(object sender, RoutedEventArgs e) { if (AssetsListBox.SelectedIndex >= 0) { AssetProperties a = AssetsListBox.SelectedItem as AssetProperties; string infos = GetAssetInfos(a); if (DarkMessageBox.ShowYesNo(infos, a.Name, "Copy Properties", "OK") == MessageBoxResult.Yes) { Clipboard.SetText(infos); new UpdateMyConsole(a.Name, CColors.Blue).Append(); new UpdateMyConsole("'s properties successfully copied", CColors.White, true).Append(); } } }
/// <summary> /// Copies mesh information from the Inventor API to the temporary mesh buffer, then into the mesh structure. /// </summary> /// <param name="surf">The source mesh</param> /// <param name="tolerance">The chord tolerance for the mesh</param> private void AddFacets(Face surf, double tolerance) { tmpSurface.vertCount = 0; #if USE_TEXTURES surf.GetExistingFacetsAndTextureMap(tolerances[bestIndex], out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies, out tmpSurface.textureCoords); if (tmpSurface.vertCount == 0) { surf.CalculateFacetsAndTextureMap(tolerances[bestIndex], out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies, out tmpSurface.textureCoords); } #else surf.GetExistingFacets(tolerance, out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies); if (tmpSurface.vertCount == 0) { surf.CalculateFacets(tolerance, out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies); } #endif AssetProperties assetProps = AssetProperties.Create(surf); AddFacetsInternal(assetProps); }
/// <summary> /// Moves the mesh currently in the temporary mesh buffer into the mesh structure itself, /// with material information from the asset properties. /// </summary> /// <param name="assetProps">Material information to use</param> private void AddFacetsInternal(AssetProperties assetProps) { if (tmpSurface.vertCount > TMP_VERTICIES) { // This is just bad. It could be fixed by exporting it per-face instead of with a single block. System.Windows.Forms.MessageBox.Show("Warning: Mesh segment exceededed " + TMP_VERTICIES + " verticies. Strange things may begin to happen."); } // If adding this would cause the sub mesh to overflow dump what currently exists. if (tmpSurface.vertCount + postSurface.vertCount >= TMP_VERTICIES) { DumpMeshBuffer(); } Array.Copy(tmpSurface.verts, 0, postSurface.verts, postSurface.vertCount * 3, tmpSurface.vertCount * 3); Array.Copy(tmpSurface.norms, 0, postSurface.norms, postSurface.vertCount * 3, tmpSurface.vertCount * 3); #if USE_TEXTURES Array.Copy(tmpSurface.textureCoords, 0, postSurface.textureCoords, postSurface.vertCount * 2, tmpSurface.vertCount * 2); #endif BXDAMesh.BXDASurface nextSurface = new BXDAMesh.BXDASurface(); nextSurface.color = 0xFFFFFFFF; if (assetProps.color != null) { nextSurface.hasColor = true; nextSurface.color = ((uint)assetProps.color.Red << 0) | ((uint)assetProps.color.Green << 8) | ((uint)assetProps.color.Blue << 16) | ((((uint)(assetProps.color.Opacity * 255)) & 0xFF) << 24); } nextSurface.transparency = (float)assetProps.transparency; nextSurface.translucency = (float)assetProps.translucency; nextSurface.specular = (float)assetProps.specular; nextSurface.indicies = new int[tmpSurface.facetCount * 3]; // Raw copy the indicies for now, then fix the offset in a background thread. Array.Copy(tmpSurface.indicies, nextSurface.indicies, nextSurface.indicies.Length); #region Fix Index Buffer Offset // Make sure we haven't exceeded the maximum number of background tasks. if (waitingThreads.Count > MAX_BACKGROUND_THREADS) { // Console.WriteLine("Got ahead of ourselves...."); System.Threading.WaitHandle.WaitAll(waitingThreads.ToArray()); waitingThreads.Clear(); } { System.Threading.ManualResetEvent lockThing = new System.Threading.ManualResetEvent(false); waitingThreads.Add(lockThing); int offset = postSurface.vertCount; int backingFacetCount = tmpSurface.facetCount; System.Threading.ThreadPool.QueueUserWorkItem(delegate(object obj) { for (int i = 0; i < backingFacetCount * 3; i++) { nextSurface.indicies[i] = nextSurface.indicies[i] + offset - 1; // Inventor has one-based indicies. Zero-based is the way to go for everything except Inventor. } lockThing.Set(); }, waitingThreads.Count); } #endregion postSurfaces.Add(nextSurface); postSurface.facetCount += tmpSurface.facetCount; postSurface.vertCount += tmpSurface.vertCount; }
public string GenerateURL(DispatchingParameters dispatchingParameters, AssetProperties assetProperties, bool isCarRoute = false) { var strBuilder = new StringBuilder("routeAttributes=routePath"); if (dispatchingParameters.WayPoints != null) { strBuilder.Append(GenerateWayPointsUri(dispatchingParameters.WayPoints)); } else { throw new BadArgumentException("WayPoints must be defined"); } if (dispatchingParameters.MaxSolutions != null) { strBuilder.Append(GenerateMaxSolutionsUri(dispatchingParameters.MaxSolutions)); } if (dispatchingParameters.DistanceUnit != null) { strBuilder.Append(GenerateDistanceUnitUri(dispatchingParameters.DistanceUnit)); } if (dispatchingParameters.WeightUnit != null) { strBuilder.Append(GenerateWeightUnitUri(dispatchingParameters.WeightUnit)); } if (dispatchingParameters.DimensionUnit != null) { strBuilder.Append(GenerateDimensionUnitUri(dispatchingParameters.DimensionUnit)); } if (isCarRoute) { return(strBuilder.ToString()); } if (dispatchingParameters.Optimize != null) { strBuilder.Append(GenerateOptimizeUri(dispatchingParameters.Optimize)); } if (dispatchingParameters.Avoid != null && dispatchingParameters.Avoid.Count() > 0) { strBuilder.Append(GenerateAvoidUri(dispatchingParameters.Avoid)); } if (dispatchingParameters.DistanceBeforeFirstTurn != null) { strBuilder.Append($"&distanceBeforeFirstTurn={dispatchingParameters.DistanceBeforeFirstTurn}"); } if (dispatchingParameters.Heading != null) { strBuilder.Append(GenerateHeadingUri(dispatchingParameters.Heading)); } if (dispatchingParameters.Tolerances != null) { strBuilder.Append(GenerateTolerancesUri(dispatchingParameters.Tolerances)); } if (dispatchingParameters.AvoidCrossWind == true) { strBuilder.Append("&vehicleAvoidCrossWind=true"); } if (dispatchingParameters.DateTime != null) { strBuilder.Append("&dateTime=" + dispatchingParameters.DateTime.ToString()); if (dispatchingParameters.TimeType != null) { strBuilder.Append(GenerateTimeTypeUri(dispatchingParameters.TimeType)); } } strBuilder.Append(GenerateAssetHeightUri(dispatchingParameters.LoadedHeight, assetProperties)); strBuilder.Append(GenerateAssetLengthUri(dispatchingParameters.LoadedLength, assetProperties)); strBuilder.Append(GenerateAssetWidthUri(dispatchingParameters.LoadedWidth, assetProperties)); strBuilder.Append(GenerateAssetWeightUri(dispatchingParameters.LoadedWeight, assetProperties)); if (dispatchingParameters.AvoidGroundingRisk == true) { strBuilder.Append("&vehicleAvoidGroundingRisk=true"); } if (dispatchingParameters.HazardousMaterials != null && dispatchingParameters.HazardousMaterials.Count() > 0) { strBuilder.Append(GenerateHazardousMaterialsUri(dispatchingParameters.HazardousMaterials)); } if (dispatchingParameters.HazardousPermits != null && dispatchingParameters.HazardousPermits.Count() > 0) { strBuilder.Append(GenerateHazardousPermitsUri(dispatchingParameters.HazardousPermits)); } if (assetProperties == null) { return(strBuilder.ToString()); } if (assetProperties.AssetAxels != null) { strBuilder.Append($"&vehicleAxles={assetProperties.AssetAxels}"); } if (assetProperties.AssetTrailers != null) { strBuilder.Append($"&vehicleTrailers={assetProperties.AssetTrailers}"); } if (assetProperties.AssetSemi == true) { strBuilder.Append("&vehicleSemi=true"); } if (assetProperties.AssetMaxGradient != null) { strBuilder.Append($"&vehicleMaxGradient={assetProperties.AssetMaxGradient}"); } if (assetProperties.AssetMinTurnRadius != null) { strBuilder.Append($"&vehicleMinTurnRadius={assetProperties.AssetMinTurnRadius}"); } return(strBuilder.ToString()); }
public async Task <IEnumerable <DispatchingResults> > CallRoutingAPI(DispatchingParameters dispatchingParameters, AssetProperties assetProperties) { var url = $"{this.routingUrl}{GenerateURL(dispatchingParameters, assetProperties)}&key={this.bingMapsKey}"; var response = await httpClient.GetAsync(url); if (!response.IsSuccessStatusCode) { throw new BadArgumentException($"Dispatching API returned: {response.StatusCode}"); } var content = await response.Content.ReadAsStringAsync(); var apiResult = JObject.Parse(content); var result = ExtractDispatchingResults(apiResult); if (dispatchingParameters.GetAlternativeCarRoute) { var alternativeUrl = $"{this.routingUrl}{GenerateURL(dispatchingParameters, assetProperties, true)}&key={this.bingMapsKey}"; response = await httpClient.GetAsync(alternativeUrl); if (!response.IsSuccessStatusCode) { throw new BadArgumentException($"Alternative dispatching API returned: {response.StatusCode}"); } content = await response.Content.ReadAsStringAsync(); apiResult = JObject.Parse(content); var alternativePath = ExtractAlternativeDispatchingResult(apiResult); foreach (var dispatchingResult in result) { dispatchingResult.AlternativeCarRoutePoints = alternativePath; } } return(result); }
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"); } }
// public void OnDaylightPortal(DaylightPortalNode node) //{ // Like RPCs, Daylight Portals too have their assets available only. // THere is no other public API for them currently available. // return; //} public void OnMaterial(MaterialNode node) { materialNode = node; MessageBuffer mb = new MessageBuffer(); mb.add(node.MaterialId.IntegerValue); mb.add(node.NodeName); mb.add(node.Color); mb.add((byte)(((100 - (node.Transparency)) / 100.0) * 255)); Asset asset; if (node.HasOverriddenAppearance) { asset = node.GetAppearanceOverride(); } else { asset = node.GetAppearance(); } String textureName = ""; AssetProperties properties = asset as AssetProperties; for (int index = 0; index < asset.Size; index++) { if (properties[index].Type == AssetPropertyType.Reference) { AssetPropertyReference e = properties[index] as AssetPropertyReference; if (e != null) { AssetProperty p = e.GetConnectedProperty(0); if (p.Type == AssetPropertyType.Asset) { Asset a = p as Asset; if (a != null) { Boolean foundValidTexture = false; AssetProperties prop = a as AssetProperties; for (int ind = 0; ind < a.Size; ind++) { if (prop[ind].Name == "unifiedbitmap_Bitmap") { AssetPropertyString ps = prop[ind] as AssetPropertyString; if (ps.Value != "") { textureName = ps.Value; foundValidTexture = true; } } if (prop[ind].Name == "texture_URepeat") { AssetPropertyBoolean ps = prop[ind] as AssetPropertyBoolean; if (foundValidTexture) { } //textureName = ps.Value; } if (prop[ind].Name == "texture_VRepeat") { AssetPropertyBoolean ps = prop[ind] as AssetPropertyBoolean; if (foundValidTexture) { } } } } } } } } mb.add(textureName); OpenCOVERPlugin.COVER.Instance.sendMessage(mb.buf, OpenCOVERPlugin.COVER.MessageTypes.NewMaterial); return; }
private IList <AssetCondition> GetAssetConditions(AssetProperties assetProperties) { List <AssetCondition> assetConditions = new List <AssetCondition>(); if (assetProperties.Asset is AssetAndroid assetAndroid) { if (_androidStandardFileConditionCheckbox.Active) { assetConditions.Add(new AndroidContainsStandardFileCondition(assetAndroid)); } if (_androidLdpiFileConditionCheckbox.Active) { assetConditions.Add(new AndroidContainsLdpiFileCondition(assetAndroid)); } if (_androidMdpiFileConditionCheckbox.Active) { assetConditions.Add(new AndroidContainsMdpiFileCondition(assetAndroid)); } if (_androidHdpiFileConditionCheckbox.Active) { assetConditions.Add(new AndroidContainsHdpiFileCondition(assetAndroid)); } if (_androidXhdpiFileConditionCheckbox.Active) { assetConditions.Add(new AndroidContainsXhdpiFileCondition(assetAndroid)); } if (_androidXxhdpiFileConditionCheckbox.Active) { assetConditions.Add(new AndroidContainsXxhdpiFileCondition(assetAndroid)); } if (_androidXxxhdpiFileConditionCheckbox.Active) { assetConditions.Add(new AndroidContainsXxxhdpiFileCondition(assetAndroid)); } if (_androidResolutionFileConditionCheckbox.Active) { int.TryParse(_androidResolutionMarginTextEntry.Text, out int sizeMargin); assetConditions.Add(new SizesFilesAndroidCondition(assetAndroid, sizeMargin)); } if (_androidDrawableFileConditionCheckbox.Active) { assetConditions.Add(new DrawableAssetAndroidCondition(assetAndroid)); } } else if (assetProperties.Asset is AssetiOS assetiOS) { if (_iosStandardFileConditionCheckbox.Active) { assetConditions.Add(new IOSContainsStandardFileCondition(assetiOS)); } if (_iosX2FileConditionCheckbox.Active) { assetConditions.Add(new IOSContainsX2FileCondition(assetiOS)); } if (_iosX3FileConditionCheckbox.Active) { assetConditions.Add(new IOSContainsX3FileCondition(assetiOS)); } if (_iosResolutionFileConditionCheckbox.Active) { int.TryParse(_iosResolutionMarginTextEntry.Text, out int sizeMargin); assetConditions.Add(new SizesFilesiOSCondition(assetiOS, sizeMargin)); } } return(assetConditions); }
/// <summary> /// Copies mesh information for the given surface body into the mesh storage structure. /// </summary> /// <param name="surf">The surface body to export</param> /// <param name="bestResolution">Use the best possible resolution</param> /// <param name="separateFaces">Separate the surface body into one mesh per face</param> private void AddFacets(SurfaceBody surf, bool bestResolution = false, bool separateFaces = false) { BXDAMesh.BXDASurface nextSurface = new BXDAMesh.BXDASurface(); surf.GetExistingFacetTolerances(out tmpToleranceCount, out tolerances); int bestIndex = -1; for (int i = 0; i < tmpToleranceCount; i++) { if (bestIndex < 0 || ((tolerances[i] < tolerances[bestIndex]) == bestResolution)) { bestIndex = i; } } #region SHOULD_SEPARATE_FACES AssetProperties sharedValue = null; string sharedDisp = null; if (separateFaces) // Only separate if they are actually different colors { separateFaces = false; foreach (Face f in surf.Faces) { try { Asset ast = f.Appearance; if (sharedValue == null) { sharedValue = new AssetProperties(ast); sharedDisp = ast.DisplayName; } else if (!ast.DisplayName.Equals(sharedDisp)) { separateFaces = true; break; } } catch { } } } #endregion #if USE_TEXTURES surf.GetExistingFacetsAndTextureMap(tolerances[bestIndex], out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies, out tmpSurface.textureCoords); if (tmpSurface.vertCount == 0) { surf.CalculateFacetsAndTextureMap(tolerances[bestIndex], out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies, out tmpSurface.textureCoords); } #else surf.GetExistingFacets(tolerances[bestIndex], out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies); if (tmpSurface.vertCount == 0) { surf.CalculateFacets(tolerances[bestIndex], out tmpSurface.vertCount, out tmpSurface.facetCount, out tmpSurface.verts, out tmpSurface.norms, out tmpSurface.indicies); } #endif if (separateFaces || tmpSurface.vertCount > TMP_VERTICIES) { int i = 0; foreach (Face f in surf.Faces) { i++; AddFacets(f, tolerances[bestIndex]); } } else { //Console.WriteLine("Exporting single block for " + surf.Parent.Name + "\t(" + surf.Name + ")"); AssetProperties assetProps = sharedValue; if (sharedValue == null) { assetProps = AssetProperties.Create(surf); } if (assetProps != null) { AddFacetsInternal(assetProps); } } }
public AssetPropertyData(string label, AssetProperties assetProperties) : base(label) { _assetProperties = assetProperties; }