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;
}
}
