private async Task <object> ExportForTranslation(IProgress <string> progress, CancellationToken cancelToken) { List <ExportResult> resultsList = new List <ExportResult>(); foreach (var culture in __Cultures) { if (culture.IsSelected) { string fileName = System.IO.Path.Combine(ExportFolder.Text, culture.FileName); progress.Report(StringUtils.String("ExportingStrings", culture.CountryCode, culture.FileName)); try { ExportResult exportResult = await App.MainWindow.Document.ExportApi.ExportStrings( fileName, culture.Culture.CultureCode, IncludeTranslated.IsChecked == true); resultsList.Add(exportResult); } catch (Exception e) { ExportResult result = new ExportResult(fileName, culture.Culture.CultureCode, ExportCSVResult.Fail, 0, e.Message); resultsList.Add(result); } } } return(resultsList); }
private static void CreateNodeListRecursive(Transform transform, List <ExportResult> nodes) { ExportResult node = new ExportResult(); node.name = transform.name; node.translation = transform.localPosition; node.rotation = transform.localRotation; node.scale = transform.localScale; node.renderer = transform.gameObject.GetComponent <MeshRenderer>(); node.filter = transform.gameObject.GetComponent <MeshFilter>(); node.skinnedRenderer = transform.gameObject.GetComponent <SkinnedMeshRenderer>(); nodes.Add(node); if (transform.childCount > 0) { if (transform.childCount > 0) { node.children = new int[transform.childCount]; for (int i = 0; i < node.children.Length; i++) { Transform child = transform.GetChild(i); node.children[i] = nodes.Count; CreateNodeListRecursive(child, nodes); } } } }
public ActionResult Import(ExportResult importData) { ExportImportService <T> tempService = new ExportImportService <T>(_context); tempService.SetImportResult(importData); return(Ok()); }
public void TestExportError() { var filename = "testError.unitypackage"; var baseFolderPath = "Assets/VitDeck/Exporter/Tests/TestBaseFolder"; var setting = new ExportSetting(); setting.SettingName = ""; setting.Description = ""; setting.ExportFolderPath = testExportFolder; setting.fileNameFormat = filename; setting.ruleSetName = ""; Exporter.Export(baseFolderPath, setting, false); //ファイル重複していた場合 ExportResult willFailResult = new ExportResult(); willFailResult.exportResult = true; LogAssert.Expect(LogType.Error, new Regex(@"^System\.IO\.IOException.*")); Assert.DoesNotThrow(() => willFailResult = Exporter.Export(baseFolderPath, setting, false)); Assert.That(willFailResult.exportResult, Is.False); Assert.That(willFailResult.exportFilePath, Is.Null); Assert.That(willFailResult.log, Is.Not.Empty); var willPassResult = Exporter.Export(baseFolderPath, setting, true); Assert.That(willPassResult.exportResult, Is.True); }
public void GivenAnExportResult_WhenSettingAContentTypeHeader_ThenExportResultHasAContentTypeHeader() { string contentTypeValue = "application/json"; var exportResult = ExportResult.Accepted().SetContentTypeHeader(contentTypeValue); Assert.Equal(contentTypeValue, exportResult.Headers[HeaderNames.ContentType]); }
public async ValueTask <ExportResult> TrackAsync(IEnumerable <TelemetryItem> telemetryItems, bool async, CancellationToken cancellationToken) { ExportResult result = ExportResult.Failure; if (cancellationToken.IsCancellationRequested) { return(result); } try { using var httpMessage = async ? await _applicationInsightsRestClient.InternalTrackAsync(telemetryItems, cancellationToken).ConfigureAwait(false) : _applicationInsightsRestClient.InternalTrackAsync(telemetryItems, cancellationToken).Result; result = IsSuccess(httpMessage); if (result == ExportResult.Failure && _storage != null) { result = HandleFailures(httpMessage); } else { AzureMonitorExporterEventSource.Log.WriteInformational("TransmissionSuccess", "Successfully transmitted a batch of telemetry Items."); } } catch (Exception ex) { AzureMonitorExporterEventSource.Log.WriteError("FailedToTransmit", ex); } return(result); }
private async Task ConvertHalcyonPrimToBabylon(HttpListenerContext context, HttpListenerRequest request) { //halcyon gemoetry is coming in as a primitive flatbuffer object //as binary in the body. deserialize and convert using the prim exporter ByteBuffer body = await StreamUtil.ReadStreamFullyAsync(request.InputStream); ExportResult babylonExport = null; Tuple <byte[], int, int> babylonFlatbuffer = null; //The actual conversion is CPU intensive. Use a thread task await Task.Run(() => { var prim = HalcyonPrimitive.GetRootAsHalcyonPrimitive(body); var part = Mapper.MapFlatbufferPrimToPart(prim); var displayData = GroupLoader.Instance.ExtractPrimMesh(part, new GroupLoader.LoaderParams(), null); BabylonFlatbufferFormatter formatter = new BabylonFlatbufferFormatter(); babylonExport = formatter.Export(displayData); babylonFlatbuffer = babylonExport.FaceBlob; }); context.Response.StatusCode = 200; context.Response.AddHeader("Content-Type", "application/octet-stream"); context.Response.AddHeader("Etag", babylonExport.Hash.ToString()); await context.Response.OutputStream.WriteAsync(babylonFlatbuffer.Item1, babylonFlatbuffer.Item2, babylonFlatbuffer.Item3); await context.Response.OutputStream.FlushAsync(); context.Response.Close(); }
public static ExportResult SetContentTypeHeader(this ExportResult exportResult, string contentTypeValue) { EnsureArg.IsNotNullOrWhiteSpace(contentTypeValue); exportResult.Headers.Add(HeaderNames.ContentType, contentTypeValue); return(exportResult); }
private ContractExecutionResult ProcessWithRaptor(ExportReport request) { var raptorFilter = RaptorConverters.ConvertFilter(request.Filter, request.ProjectId, raptorClient); bool success = raptorClient.GetProductionDataExport(request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID, ASNodeRPC.__Global.Construct_TASNodeRequestDescriptor(request.CallId ?? Guid.NewGuid(), 0, TASNodeCancellationDescriptorType.cdtProdDataExport), RaptorConverters.convertToRaptorUserPreferences(request.UserPrefs), (int)request.ExportType, request.CallerId, raptorFilter, RaptorConverters.ConvertLift(request.LiftBuildSettings, raptorFilter.LayerMethod), request.TimeStampRequired, request.CellSizeRequired, request.RawData, request.RestrictSize, true, request.Tolerance, request.IncludeSurveydSurface, request.Precheckonly, request.Filename, RaptorConverters.convertToRaptorMachines(request.MachineList), (int)request.CoordType, (int)request.OutputType, request.DateFromUTC, request.DateToUTC, RaptorConverters.convertToRaptorTranslations(request.Translations), RaptorConverters.convertToRaptorProjectExtents(request.ProjectExtents), out var dataexport); if (success) { try { return(ExportResult.Create( File.ReadAllBytes(BuildFilePath(request.ProjectId ?? VelociraptorConstants.NO_PROJECT_ID, request.CallerId, request.Filename, true)), dataexport.ReturnCode)); } catch (Exception ex) { throw new ServiceException(HttpStatusCode.NoContent, new ContractExecutionResult(ContractExecutionStatesEnum.ValidationError, "Failed to retrieve received export data: " + ex.Message)); } } throw CreateServiceException <ExportReportExecutor>(dataexport.ReturnCode); }
/// <summary> /// Imports two sets of data and logs all statements and returns them /// </summary> /// <param name="initialData"></param> /// <param name="newData"></param> /// <returns></returns> public List <LogEntry> ExportSQLScripts(ExportResult initialData, ExportResult newData) { SetImportResult(initialData); Logger.DatabaseCaseExtractorLogger.ClearLogs(); SetImportResult(newData, false, true); return(Logger.DatabaseCaseExtractorLogger.LogEntries); }
public async ValueTask <ExportResult> TrackAsync(IEnumerable <TelemetryItem> telemetryItems, bool async, CancellationToken cancellationToken) { ExportResult result = ExportResult.Failure; if (cancellationToken.IsCancellationRequested) { return(result); } try { using var httpMessage = async ? await _applicationInsightsRestClient.InternalTrackAsync(telemetryItems, cancellationToken).ConfigureAwait(false) : _applicationInsightsRestClient.InternalTrackAsync(telemetryItems, cancellationToken).Result; result = IsSuccess(httpMessage); if (result == ExportResult.Failure && _storage != null) { result = HandleFailures(httpMessage); } } catch (Exception ex) { AzureMonitorExporterEventSource.Log.Write($"FailedToTransmit{EventLevelSuffix.Error}", ex.LogAsyncException()); } return(result); }
private async Task <IActionResult> SendExportRequest( ExportJobType exportType, PartialDateTime since, string resourceType = null, string groupId = null, string containerName = null, string formatName = null, string anonymizationConfigLocation = null, string anonymizationConfigFileETag = null) { CreateExportResponse response = await _mediator.ExportAsync( _fhirRequestContextAccessor.FhirRequestContext.Uri, exportType, resourceType, since, groupId, containerName, formatName, anonymizationConfigLocation, anonymizationConfigFileETag, HttpContext.RequestAborted); var exportResult = ExportResult.Accepted(); exportResult.SetContentLocationHeader(_urlResolver, OperationsConstants.Export, response.JobId); return(exportResult); }
public static ContainerBuilder SaveExportedFilesTo(this ContainerBuilder builder, string fileName) { var fileChooser = Substitute.For <IFileSaveChooser>(); fileChooser.GetFileSaveLocation().Returns(Task.FromResult(ExportResult.Success(fileName))); builder.Register(_ => fileChooser).As <IFileSaveChooser>(); return(builder); }
private ExportResult HandleFailures(HttpMessage httpMessage) { ExportResult result = ExportResult.Failure; byte[] content; int retryInterval; if (!httpMessage.HasResponse) { // HttpRequestException content = HttpPipelineHelper.GetRequestContent(httpMessage.Request.Content); result = _storage.SaveTelemetry(content, HttpPipelineHelper.MinimumRetryInterval); } else { switch (httpMessage.Response.Status) { case ResponseStatusCodes.PartialSuccess: // Parse retry-after header // Send Failed Messages To Storage TrackResponse trackResponse = HttpPipelineHelper.GetTrackResponse(httpMessage); content = HttpPipelineHelper.GetPartialContentForRetry(trackResponse, httpMessage.Request.Content); if (content != null) { retryInterval = HttpPipelineHelper.GetRetryInterval(httpMessage.Response); result = _storage.SaveTelemetry(content, retryInterval); } break; case ResponseStatusCodes.RequestTimeout: case ResponseStatusCodes.ResponseCodeTooManyRequests: case ResponseStatusCodes.ResponseCodeTooManyRequestsAndRefreshCache: // Parse retry-after header // Send Messages To Storage content = HttpPipelineHelper.GetRequestContent(httpMessage.Request.Content); retryInterval = HttpPipelineHelper.GetRetryInterval(httpMessage.Response); result = _storage.SaveTelemetry(content, retryInterval); break; case ResponseStatusCodes.InternalServerError: case ResponseStatusCodes.BadGateway: case ResponseStatusCodes.ServiceUnavailable: case ResponseStatusCodes.GatewayTimeout: // Send Messages To Storage content = HttpPipelineHelper.GetRequestContent(httpMessage.Request.Content); result = _storage.SaveTelemetry(content, HttpPipelineHelper.MinimumRetryInterval); break; default: // Log Non-Retriable Status and don't retry or store; break; } } return(result); }
/// <summary> /// Imports data into an context. If clear = true the hole contet will be cleared first /// </summary> /// <param name="importData"></param> /// <param name="clear"></param> /// <returns></returns> public void SetImportResult(ExportResult importData, bool clear = true, bool doUpdate = false) { if (doUpdate) { _updatedEntries = new List <string>(); } SetImportResultWithoutSave(importData, doUpdate); _context.SaveChanges(); }
private async Task <IActionResult> SendExportRequest(PartialDateTime since, string type = null) { CreateExportResponse response = await _mediator.ExportAsync(_fhirRequestContextAccessor.FhirRequestContext.Uri, type, since, HttpContext.RequestAborted); var exportResult = ExportResult.Accepted(); exportResult.SetContentLocationHeader(_urlResolver, OperationsConstants.Export, response.JobId); return(exportResult); }
public static ExportResult Export(Mesh mesh) { ExportResult result = new ExportResult(); result.name = mesh.name; result.primitives = new List<GLTFPrimitive>(); for (int i = 0; i < mesh.subMeshCount; i++) { GLTFPrimitive primitive = new GLTFPrimitive(); result.primitives.Add(primitive); } return result; }
public async Task <ExportResult> Execute() { _managerEventSource.StartToExport(); var result = new ExportResult { Clients = await _getClientsAction.Execute() }; _managerEventSource.FinishToExport(); return(result); }
// Generates the url to be included in the response based on the operation and sets the content location header. public static ExportResult SetContentLocationHeader(this ExportResult exportResult, IUrlResolver urlResolver, string operationName, string id) { EnsureArg.IsNotNull(urlResolver, nameof(urlResolver)); EnsureArg.IsNotNullOrWhiteSpace(operationName, nameof(operationName)); EnsureArg.IsNotNullOrWhiteSpace(id, nameof(id)); var url = urlResolver.ResolveOperationResultUrl(operationName, id); exportResult.Headers.Add(HeaderNames.ContentLocation, url.ToString()); return(exportResult); }
public static ExportResponse ToDto(this ExportResult export) { if (export == null) { throw new ArgumentNullException(nameof(export)); } return(new ExportResponse { Clients = export.Clients == null ? null : export.Clients.Select(c => c.ToClientResponseDto()) }); }
private void Initialize() { AppSettings.ExportPanelSettngs exportPanelSettngs; switch (libgenObjectType) { case LibgenObjectType.NON_FICTION_BOOK: exportPanelSettngs = mainModel.AppSettings.NonFiction.ExportPanel; break; case LibgenObjectType.FICTION_BOOK: exportPanelSettngs = mainModel.AppSettings.Fiction.ExportPanel; break; case LibgenObjectType.SCIMAG_ARTICLE: exportPanelSettngs = mainModel.AppSettings.SciMag.ExportPanel; break; default: throw new Exception($"Unknown object type: {libgenObjectType}."); } cancellationTokenSource = null; isSettingsPanelVisible = true; isXlsxSelected = exportPanelSettngs.Format == AppSettings.ExportPanelSettngs.ExportFormat.XLSX; isCsvSelected = exportPanelSettngs.Format == AppSettings.ExportPanelSettngs.ExportFormat.CSV; isSeparatorPanelVisible = isCsvSelected; isCommaSeparatorSelected = exportPanelSettngs.Separator == AppSettings.ExportPanelSettngs.CsvSeparator.COMMA; isSemicolonSeparatorSelected = exportPanelSettngs.Separator == AppSettings.ExportPanelSettngs.CsvSeparator.SEMICOLON; isTabSeparatorSelected = exportPanelSettngs.Separator == AppSettings.ExportPanelSettngs.CsvSeparator.TAB; filePathTemplate = (exportPanelSettngs.ExportDirectory ?? Environment.AppDataDirectory) + @"\"; isExportButtonEnabled = false; if (mainModel.AppSettings.Search.LimitResults) { isLimitPanelVisible = true; isLimitSelected = exportPanelSettngs.LimitSearchResults; isNoLimitSelected = !isLimitSelected; limitString = $"только первые {mainModel.AppSettings.Search.MaximumResultCount.ToFormattedString()} результатов"; } else { isLimitPanelVisible = false; isLimitSelected = false; isNoLimitSelected = true; limitString = String.Empty; } isProgressPanelVisible = false; progressStatus = String.Empty; cancelExportButtonText = "ПРЕРВАТЬ"; isCancelExportButtonEnabled = true; isCancelExportButtonVisible = false; areExportResultButtonsVisible = false; isShowResultButtonVisible = false; exportResult = null; }
public void GivenAnExportResult_WhenSettingAContentLocationHeader_TheExportResultHasAContentLocationHeader() { string opName = OperationsConstants.Export; string id = Guid.NewGuid().ToString(); var exportOperationUrl = new Uri($"http://localhost/{OperationsConstants.Operations}/{opName}/{id}"); var urlResolver = Substitute.For <IUrlResolver>(); urlResolver.ResolveOperationResultUrl(Arg.Any <string>(), Arg.Any <string>()).Returns(exportOperationUrl); var exportResult = ExportResult.Accepted().SetContentLocationHeader(urlResolver, opName, id); Assert.Equal(exportOperationUrl.AbsoluteUri, exportResult.Headers[HeaderNames.ContentLocation]); }
public async Task <IActionResult> Export([FromQuery(Name = KnownQueryParameterNames.Since)] PartialDateTime since) { if (!_exportConfig.Enabled) { throw new RequestNotValidException(string.Format(Resources.OperationNotEnabled, OperationsConstants.Export)); } CreateExportResponse response = await _mediator.ExportAsync(_fhirRequestContextAccessor.FhirRequestContext.Uri, since, HttpContext.RequestAborted); var exportResult = ExportResult.Accepted(); exportResult.SetContentLocationHeader(_urlResolver, OperationsConstants.Export, response.JobId); return(exportResult); }
public async Task <IActionResult> Export() { if (!_exportConfig.Enabled) { throw new RequestNotValidException(string.Format(Resources.UnsupportedOperation, OperationsConstants.Export)); } CreateExportResponse response = await _mediator.ExportAsync(_fhirRequestContextAccessor.FhirRequestContext.Uri, HttpContext.RequestAborted); var exportResult = ExportResult.Accepted(); exportResult.SetContentLocationHeader(_urlResolver, OperationsConstants.Export, response.JobId); return(exportResult); }
private ExportResult GetValue() { using (var dialog = new SaveFileDialog { Filter = "Excel spreadsheet|*.xlsx;*.xls;|All files|*.*" }) { shower.ShowDialog(dialog); if (!String.IsNullOrWhiteSpace(dialog.FileName)) { return(ExportResult.Success(dialog.FileName)); } return(ExportResult.Incomplete()); } }
public async Task <IActionResult> Export( [FromQuery(Name = KnownQueryParameterNames.DestinationType)] string destinationType, [FromQuery(Name = KnownQueryParameterNames.DestinationConnectionSettings)] string destinationConnectionString) { if (!_exportConfig.Enabled) { throw new RequestNotValidException(string.Format(Resources.UnsupportedOperation, OperationsConstants.Export)); } CreateExportResponse response = await _mediator.ExportAsync(_fhirRequestContextAccessor.FhirRequestContext.Uri, destinationType, destinationConnectionString); var exportResult = ExportResult.Accepted(); exportResult.SetContentLocationHeader(_urlResolver, OperationsConstants.Export, response.JobId); return(exportResult); }
public async Task <IActionResult> GetExportStatusById(string id) { var getExportResult = await _mediator.GetExportStatusAsync(_fhirRequestContextAccessor.FhirRequestContext.Uri, id); // If the job is complete, we need to return 200 along the completed data to the client. // Else we need to return 202. ExportResult exportActionResult; if (getExportResult.StatusCode == HttpStatusCode.OK) { exportActionResult = ExportResult.Ok(getExportResult.JobResult); exportActionResult.SetContentTypeHeader(OperationsConstants.ExportContentTypeHeaderValue); } else { exportActionResult = ExportResult.Accepted(); } return(exportActionResult); }
public int AddDocument(SPOList list, string documentPath, string filePath, List <SPOField> fields) { string folder = string.Join("/", documentPath.Split('/').Reverse().Skip(1).Reverse()); if (!folders.ContainsKey(folder)) { folders[folder] = 0; } folders[folder]++; LastExportResult = new ExportResult() { ListTitle = list.Title, DocumentPath = documentPath, Folder = folder, FilePath = filePath, Fields = fields, }; return(fields.Count); }
public string ReExport(string articleNumber) { try { //Use the NlmExportService to reExport the NLM feed ExportResult result = _nlmExportService.ExportNlm(_searcher.GetArticleByNumber(articleNumber), ExportType.Manual, PublicationType.Ecorrected); if (result.ExportSuccessful) { return(string.Empty); } else { return(result.Exception.ToString()); } } catch (Exception ex) { Sitecore.Diagnostics.Log.Error("Error while ReExporting Article Nlm: " + ex.ToString(), this.GetType()); return(ex.ToString()); } }
/// <summary> /// Export /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnExport_Click(object sender, EventArgs e) { if (CheckUserInput() == false) { return; } ExportEngine engine = new ExportEngine(); Dictionary <string, string> paramList = new Dictionary <string, string>(); paramList["OrderId"] = txtOrderId.Text.Trim(); ExportResult result = engine.Export(txtTemplate.Text.Trim(), paramList); string folder = "Temp"; string ext = Path.GetExtension(result.FileDisplayName); string filePath = GenerateFilePath(folder, ext); SaveFile(result.FileContent, filePath); txtExportFileName.Text = result.FileDisplayName; txtExportFilePath.Text = filePath; }
/// <summary> /// Graba una escena a XML, en base a información de varios TgcMesh. /// También crea una carpeta Textures relativa al XML y copia ahí todas las texturas utilizadas por las Mallas. /// Lo mismo para LightMaps. /// </summary> /// <param name="sceneName">Nombre de la escena</param> /// <param name="sceneBoundingBox">BoundingBox de toda la escena</param> /// <param name="meshesExport">Array de datos de Mallas que se quieren exportar</param> /// <param name="saveFolderPath">Carpeta en la que se quiera guardar el XML</param> /// <returns>Resultado de exportacion</returns> public ExportResult saveSceneToXml(string sceneName, TgcBoundingBox sceneBoundingBox, MeshExport[] meshesExport, string saveFolderPath) { ExportResult result = new ExportResult(); try { //Ver si la escena tiene Lightmaps bool hasLightmaps = true; foreach (MeshExport mExp in meshesExport) { if (mExp.MeshData.lightmap == null) { hasLightmaps = false; break; } } //Crear XML XmlDocument doc = new XmlDocument(); XmlNode root = doc.CreateElement("tgcScene"); //name XmlElement nameNode = doc.CreateElement("name"); nameNode.InnerText = sceneName; root.AppendChild(nameNode); //texturesExport XmlElement texturesExportNode = doc.CreateElement("texturesExport"); texturesExportNode.SetAttribute("enabled", true.ToString()); texturesExportNode.SetAttribute("dir", DEFAULT_TEXTURES_DIR); root.AppendChild(texturesExportNode); //lightmapExport XmlElement lightmapExportNode = doc.CreateElement("lightmapExport"); lightmapExportNode.SetAttribute("enabled", hasLightmaps.ToString()); lightmapExportNode.SetAttribute("dir", DEFAULT_LIGHTMAPS_DIR); root.AppendChild(lightmapExportNode); //sceneBoundingBox XmlElement sceneBoundingBoxNode = doc.CreateElement("sceneBoundingBox"); sceneBoundingBoxNode.SetAttribute("min", TgcParserUtils.printVector3(sceneBoundingBox.PMin)); sceneBoundingBoxNode.SetAttribute("max", TgcParserUtils.printVector3(sceneBoundingBox.PMax)); root.AppendChild(sceneBoundingBoxNode); //materials XmlElement materialsNode = doc.CreateElement("materials"); List<MeshExport> unifiedMaterialsData = new List<MeshExport>(); foreach (MeshExport mExp in meshesExport) { if (mExp.MaterialsData != null) { //Buscar si ya exportamos un Material igual int existingMatId = searchSameMaterial(mExp, unifiedMaterialsData); //Nuevo Material if (existingMatId == -1) { //Standardmaterial if (mExp.MaterialsData.Length == 1) { //Crear Material XmlElement mNode = createMaterialXmlNode(doc, mExp.MaterialsData[0], "m"); materialsNode.AppendChild(mNode); } //Multimaterial else { //Crear Multimaterial XmlElement mNode = doc.CreateElement("m"); mNode.SetAttribute("name", TgcMaterialData.MultiMaterial); mNode.SetAttribute("type", TgcMaterialData.MultiMaterial); //Crear SubMaterials foreach (TgcMaterialData materialData in mExp.MaterialsData) { XmlElement subMNode = createMaterialXmlNode(doc, materialData, "subM"); mNode.AppendChild(subMNode); } materialsNode.AppendChild(mNode); } //Actualizar indice de material del mesh unifiedMaterialsData.Add(mExp); mExp.MeshData.materialId = unifiedMaterialsData.Count - 1; } //Material repetido else { mExp.MeshData.materialId = existingMatId; } } } materialsNode.SetAttribute("count", unifiedMaterialsData.Count.ToString()); root.AppendChild(materialsNode); //meshes XmlElement meshesNode = doc.CreateElement("meshes"); meshesNode.SetAttribute("count", meshesExport.Length.ToString()); foreach (MeshExport mExp in meshesExport) { TgcMeshData meshData = mExp.MeshData; //mesh XmlElement meshNode = doc.CreateElement("mesh"); meshNode.SetAttribute("name", meshData.name); meshNode.SetAttribute("layer", meshData.layerName); meshNode.SetAttribute("type", TgcMeshData.ORIGINAL); meshNode.SetAttribute("matId", meshData.materialId.ToString()); meshNode.SetAttribute("color", meshData.color != null ? TgcParserUtils.printFloat3Array(meshData.color) : TgcParserUtils.printFloat3Array(new float[]{1,1,1})); meshNode.SetAttribute("visibility", meshData.alphaBlending ? "0" : "1.0"); meshNode.SetAttribute("lightmap", meshData.lightmap != null ? meshData.lightmap : ""); //boundingBox XmlElement boundingBoxNode = doc.CreateElement("boundingBox"); boundingBoxNode.SetAttribute("min", TgcParserUtils.printFloat3Array(meshData.pMin)); boundingBoxNode.SetAttribute("max", TgcParserUtils.printFloat3Array(meshData.pMax)); meshNode.AppendChild(boundingBoxNode); //Malla original if (meshData.instanceType.Equals(TgcMeshData.ORIGINAL)) { //coordinatesIdx XmlElement coordinatesIdxNode = doc.CreateElement("coordinatesIdx"); coordinatesIdxNode.SetAttribute("count", meshData.coordinatesIndices.Length.ToString()); coordinatesIdxNode.InnerText = TgcParserUtils.printIntStream(meshData.coordinatesIndices); meshNode.AppendChild(coordinatesIdxNode); //textCoordsIdx XmlElement textCoordsIdxNode = doc.CreateElement("textCoordsIdx"); textCoordsIdxNode.SetAttribute("count", meshData.texCoordinatesIndices.Length.ToString()); textCoordsIdxNode.InnerText = TgcParserUtils.printIntStream(meshData.texCoordinatesIndices); meshNode.AppendChild(textCoordsIdxNode); //colorsIdx XmlElement colorsIdxNode = doc.CreateElement("colorsIdx"); colorsIdxNode.SetAttribute("count", meshData.colorIndices.Length.ToString()); colorsIdxNode.InnerText = TgcParserUtils.printIntStream(meshData.colorIndices); meshNode.AppendChild(colorsIdxNode); //matIds XmlElement matIdsNode = doc.CreateElement("matIds"); matIdsNode.SetAttribute("count", meshData.materialsIds.Length.ToString()); matIdsNode.InnerText = TgcParserUtils.printIntStream(meshData.materialsIds); meshNode.AppendChild(matIdsNode); //textCoordsLightMapIdx XmlElement textCoordsLightMapIdxNode = doc.CreateElement("textCoordsLightMapIdx"); textCoordsLightMapIdxNode.SetAttribute("count", meshData.texCoordinatesIndicesLightMap.Length.ToString()); textCoordsLightMapIdxNode.InnerText = TgcParserUtils.printIntStream(meshData.texCoordinatesIndicesLightMap); meshNode.AppendChild(textCoordsLightMapIdxNode); //vertices XmlElement verticesNode = doc.CreateElement("vertices"); verticesNode.SetAttribute("count", meshData.verticesCoordinates.Length.ToString()); verticesNode.InnerText = TgcParserUtils.printFloatStream(meshData.verticesCoordinates); meshNode.AppendChild(verticesNode); //normals XmlElement normalsNode = doc.CreateElement("normals"); normalsNode.SetAttribute("count", meshData.verticesNormals.Length.ToString()); normalsNode.InnerText = TgcParserUtils.printFloatStream(meshData.verticesNormals); meshNode.AppendChild(normalsNode); //texCoords XmlElement texCoordsNode = doc.CreateElement("texCoords"); texCoordsNode.SetAttribute("count", meshData.textureCoordinates.Length.ToString()); texCoordsNode.InnerText = TgcParserUtils.printFloatStream(meshData.textureCoordinates); meshNode.AppendChild(texCoordsNode); //colors XmlElement colorsNode = doc.CreateElement("colors"); colorsNode.SetAttribute("count", meshData.verticesColors.Length.ToString()); colorsNode.InnerText = TgcParserUtils.printIntStream(meshData.verticesColors); meshNode.AppendChild(colorsNode); //texCoordsLightMap XmlElement texCoordsLightMapNode = doc.CreateElement("texCoordsLightMap"); texCoordsLightMapNode.SetAttribute("count", meshData.textureCoordinatesLightMap.Length.ToString()); texCoordsLightMapNode.InnerText = TgcParserUtils.printFloatStream(meshData.textureCoordinatesLightMap); meshNode.AppendChild(texCoordsLightMapNode); } //Malla instancia else { meshNode.Attributes["type"].InnerText = TgcMeshData.INSTANCE; //originalMesh XmlElement originalMeshNode = doc.CreateElement("originalMesh"); originalMeshNode.InnerText = meshData.originalMesh.ToString(); meshNode.AppendChild(originalMeshNode); //transform XmlElement transformNode = doc.CreateElement("transform"); transformNode.SetAttribute("pos", TgcParserUtils.printFloat3Array(meshData.position)); transformNode.SetAttribute("rotQuat", TgcParserUtils.printFloat4Array(meshData.rotation)); transformNode.SetAttribute("scale", TgcParserUtils.printFloat3Array(meshData.scale)); meshNode.AppendChild(transformNode); } //userProps if (meshData.userProperties != null) { XmlElement userPropsNode = doc.CreateElement("userProps"); userPropsNode.SetAttribute("count", meshData.userProperties.Count.ToString()); foreach (KeyValuePair<string,string> entry in meshData.userProperties) { XmlElement propNode = doc.CreateElement(entry.Key); propNode.InnerText = entry.Value; userPropsNode.AppendChild(propNode); } meshNode.AppendChild(userPropsNode); } meshesNode.AppendChild(meshNode); } root.AppendChild(meshesNode); //Guardar XML, borrar si ya existe doc.AppendChild(root); string sceneFileName = sceneName + "-TgcScene.xml"; string sceneFilePath = saveFolderPath + "\\" + sceneFileName; result.filePath = sceneFilePath; if (File.Exists(sceneFilePath)) { File.Delete(sceneFilePath); } doc.Save(sceneFilePath); //Crear directorio de texturas string texturesDir = saveFolderPath + "\\" + DEFAULT_TEXTURES_DIR; if (!Directory.Exists(texturesDir)) { //Directory.Delete(texturesDir, true); Directory.CreateDirectory(texturesDir); } //Copiar todos los DiffuseMap a la carpeta de texturas foreach (MeshExport mExp in meshesExport) { if (mExp.diffuseMapsAbsolutePath != null) { for (int i = 0; i < mExp.diffuseMapsAbsolutePath.Length; i++) { try { copyFile(mExp.diffuseMapsAbsolutePath[i], texturesDir + "\\" + mExp.MaterialsData[i].fileName); } catch (Exception tEx) { result.secondaryErrors = true; result.errors.Add("Error al copiar textura: " + mExp.diffuseMapsAbsolutePath[i] + ". " + tEx.Message); } } } } //Crear directorio de lightmaps, borrar si ya existe if (hasLightmaps) { string lightmapsDir = saveFolderPath + "\\" + DEFAULT_LIGHTMAPS_DIR; if (Directory.Exists(lightmapsDir)) { Directory.Delete(lightmapsDir, true); } Directory.CreateDirectory(lightmapsDir); //Copiar todos los lightmaps a la carpeta de lightmaps foreach (MeshExport mExp in meshesExport) { try { copyFile(mExp.lightmapAbsolutePath, lightmapsDir + "\\" + mExp.MeshData.lightmap); } catch (Exception tEx) { result.secondaryErrors = true; result.errors.Add("Error al copiar lightmap: " + mExp.lightmapAbsolutePath + ". " + tEx.Message); } } } return result; } catch (Exception ex) { result.result = false; result.errors.Add("Hubo un error inesperado al crear XML de escena: " + sceneName + ". " + ex.Message); return result; } }