public PreExportProcess(ExportParameters _exportParameters, ILoggingProvider _logger)
{
exportParameters = _exportParameters;
logger = _logger;
}
public static string TryWriteImage(string outputFolder, string sourcePath, string textureName, ILoggingProvider logger, ExportParameters exportParameters)
{
if (sourcePath == null || sourcePath == "")
{
logger?.RaiseWarning("Texture path is missing.", 3);
return(null);
}
var validImageFormat = GetGltfValidImageFormat(Path.GetExtension(sourcePath));
if (validImageFormat == null)
{
// Image format is not supported by the exporter
logger?.RaiseWarning(string.Format("Format of texture {0} is not supported by the exporter. Consider using a standard image format like jpg or png.", Path.GetFileName(sourcePath)), 3);
return(null);
}
// Copy texture to output
var destPath = Path.Combine(outputFolder, textureName);
destPath = Path.ChangeExtension(destPath, validImageFormat);
CopyGltfTexture(sourcePath, destPath, logger, exportParameters);
return(validImageFormat);
}
public bool ExportBabylonExtension <T>(T babylonObject, ExportParameters parameters, ref BabylonScene babylonScene, ILoggingProvider logger)
{
// just skip this extension is ment only for GLTF
return(false);
}
/// <summary>
/// Export to file
/// </summary>
/// <param name="outputDirectory">The directory to store the generated files</param>
/// <param name="outputFileName">The filename to use for the generated files</param>
/// <param name="outputFormat">The format to use for the generated files</param>
/// <param name="generateManifest">Specifies if a manifest file should be generated</param>
/// <param name="onlySelected">Specifies if only the selected objects should be exported</param>
/// <param name="autoSaveMayaFile">Specifies if the Maya scene should be auto-saved</param>
/// <param name="exportHiddenObjects">Specifies if hidden objects should be exported</param>
/// <param name="copyTexturesToOutput">Specifies if textures should be copied to the output directory</param>
/// <param name="optimizeVertices">Specifies if vertices should be optimized on export</param>
/// <param name="exportTangents">Specifies if tangents should be exported</param>
/// <param name="scaleFactor">Scales the scene by this factor</param>
/// <param name="exportSkin">Specifies if skins should be exported</param>
/// <param name="quality">The texture quality</param>
/// <param name="dracoCompression">Specifies if draco compression should be used</param>
/// <param name="exportMorphNormal">Specifies if normals should be exported for morph targets</param>
/// <param name="exportMorphTangent">Specifies if tangents should be exported for morph targets</param>
/// <param name="exportKHRLightsPunctual">Specifies if the KHR_lights_punctual extension should be enabled</param>
/// <param name="exportKHRTextureTransform">Specifies if the KHR_texture_transform extension should be enabled</param>
/// <param name="bakeAnimationFrames">Specifies if animations should be exporting keyframes directly or should manually bake out animations frame by frame</param>
public void Export(ExportParameters exportParameters)
{
this.exportParameters = exportParameters;
// Check if the animation is running
MGlobal.executeCommand("play -q - state", out int isPlayed);
if (isPlayed == 1)
{
RaiseError("Stop the animation before exporting.");
return;
}
RaiseMessage("Export started", Color.Blue);
var progression = 0.0f;
ReportProgressChanged(progression);
// In Maya, system unit does not influence model size
// Ex: 1 meter is converted to 100 cm: the scene is not shrinked
// All values are retreived from API as centimeters regardless of current unit
scaleFactorToMeters = 0.01f;
// Store export options
this.isBabylonExported = exportParameters.outputFormat == "babylon" || exportParameters.outputFormat == "binary babylon";
var outputBabylonDirectory = Path.GetDirectoryName(exportParameters.outputPath);
// Check directory exists
if (!Directory.Exists(outputBabylonDirectory))
{
RaiseError("Export stopped: Output folder does not exist");
ReportProgressChanged(100);
return;
}
var watch = new Stopwatch();
watch.Start();
var babylonScene = new BabylonScene(outputBabylonDirectory);
// Save scene
if (exportParameters.autoSaveSceneFile)
{
RaiseMessage("Saving Maya file");
// Query expand file name
string fileName = MGlobal.executeCommandStringResult($@"file -q -exn;");
// If scene has already been saved previously
if (fileName.EndsWith(".ma") || fileName.EndsWith(".mb"))
{
// Name is already specified and this line will not fail
MFileIO.save();
}
else
{
// Open SaveAs dialog window
MGlobal.executeCommand($@"fileDialog2;");
}
}
// Force output file extension to be babylon
var outputFileName = Path.ChangeExtension(Path.GetFileName(exportParameters.outputPath), "babylon");
// Store selected nodes
MSelectionList selectedNodes = new MSelectionList();
MGlobal.getActiveSelectionList(selectedNodes);
selectedNodeFullPaths = new List <string>();
MItSelectionList mItSelectionList = new MItSelectionList(selectedNodes);
while (!mItSelectionList.isDone)
{
MDagPath mDagPath = new MDagPath();
try
{
mItSelectionList.getDagPath(mDagPath);
selectedNodeFullPaths.Add(mDagPath.fullPathName);
} catch
{
// selected object is not a DAG object
// fail silently
}
mItSelectionList.next();
}
if (selectedNodeFullPaths.Count > 0)
{
RaiseMessage("Selected nodes full path");
foreach (string selectedNodeFullPath in selectedNodeFullPaths)
{
RaiseMessage(selectedNodeFullPath, 1);
}
}
// Producer
babylonScene.producer = new BabylonProducer
{
name = "Maya",
version = "2018",
exporter_version = exporterVersion,
file = outputFileName
};
// Global
babylonScene.autoClear = true;
// TODO - Retreive colors from Maya
//babylonScene.clearColor = Loader.Core.GetBackGround(0, Tools.Forever).ToArray();
//babylonScene.ambientColor = Loader.Core.GetAmbient(0, Tools.Forever).ToArray();
babylonScene.TimelineStartFrame = Loader.GetMinTime();
babylonScene.TimelineEndFrame = Loader.GetMaxTime();
babylonScene.TimelineFramesPerSecond = Loader.GetFPS();
// TODO - Add custom properties
_exportQuaternionsInsteadOfEulers = true;
PrintDAG(true);
PrintDAG(false);
// Store the current frame. It can be change to find a proper one for the node/bone export
double currentTime = Loader.GetCurrentTime();
// --------------------
// ------ Nodes -------
// --------------------
RaiseMessage("Exporting nodes");
// It makes each morph target manager export starts from id = 0.
BabylonMorphTargetManager.Reset();
// Clear materials
referencedMaterials.Clear();
multiMaterials.Clear();
// Get all nodes
var dagIterator = new MItDag(MItDag.TraversalType.kDepthFirst, MFn.Type.kTransform);
List <MDagPath> nodes = new List <MDagPath>();
while (!dagIterator.isDone)
{
MDagPath mDagPath = new MDagPath();
dagIterator.getPath(mDagPath);
// Check if one of its descendant (direct or not) is a mesh/camera/light/locator
if (isNodeRelevantToExportRec(mDagPath)
// Ensure it's not one of the default cameras used as viewports in Maya
&& defaultCameraNames.Contains(mDagPath.partialPathName) == false)
{
nodes.Add(mDagPath);
}
else
{
// Skip descendants
dagIterator.prune();
}
dagIterator.next();
}
// Export all nodes
var progressionStep = 100.0f / nodes.Count;
foreach (MDagPath mDagPath in nodes)
{
BabylonNode babylonNode = null;
try
{
if (exportParameters.exportAnimationsOnly == false)
{
switch (getApiTypeOfDirectDescendants(mDagPath))
{
case MFn.Type.kMesh:
babylonNode = ExportMesh(mDagPath, babylonScene);
break;
case MFn.Type.kCamera:
babylonNode = ExportCamera(mDagPath, babylonScene);
break;
case MFn.Type.kLight: // Lights api type are actually kPointLight, kSpotLight...
babylonNode = ExportLight(mDagPath, babylonScene);
break;
case MFn.Type.kLocator: // Camera target
babylonNode = ExportDummy(mDagPath, babylonScene);
break;
}
}
else
{
switch (getApiTypeOfDirectDescendants(mDagPath))
{
case MFn.Type.kMesh:
babylonNode = ExportMesh(mDagPath, babylonScene);
break;
case MFn.Type.kCamera:
case MFn.Type.kLight: // Lights api type are actually kPointLight, kSpotLight...
case MFn.Type.kLocator: // Camera target
babylonNode = ExportDummy(mDagPath, babylonScene);
break;
}
}
}
catch (Exception e)
{
this.RaiseWarning(String.Format("Exception raised during export. Node will be exported as dummy node. \r\nMessage: \r\n{0} \r\n{1}", e.Message, e.InnerException), 2);
}
// If node is not exported successfully
if (babylonNode == null)
{
// Create a dummy (empty mesh)
babylonNode = ExportDummy(mDagPath, babylonScene);
}
;
// Update progress bar
progression += progressionStep;
ReportProgressChanged(progression);
CheckCancelled();
}
RaiseMessage(string.Format("Total meshes: {0}", babylonScene.MeshesList.Count), Color.Gray, 1);
// if nothing is enlightened, exclude all meshes
foreach (BabylonLight light in babylonScene.LightsList)
{
if (light.includedOnlyMeshesIds.Length == 0)
{
light.excludedMeshesIds = babylonScene.MeshesList.Select(m => m.id).ToArray();
}
}
/*
* Switch coordinate system at global level
*
* Add a root node with negative scaling
* Pros - It's safer to use a root node
* Cons - It's cleaner to switch at object level (as it is done now)
* Use root node method when you want to be 100% sure of the output
* Don't forget to also inverse winding order of mesh indices
*/
//// Switch from right to left handed coordinate system
//MUuid mUuid = new MUuid();
//mUuid.generate();
//var rootNode = new BabylonMesh
//{
// name = "root",
// id = mUuid.asString(),
// scaling = new float[] { 1, 1, -1 }
//};
//foreach(var babylonMesh in babylonScene.MeshesList)
//{
// // Add root meshes as child to root node
// if (babylonMesh.parentId == null)
// {
// babylonMesh.parentId = rootNode.id;
// }
//}
//babylonScene.MeshesList.Add(rootNode);
// Main camera
BabylonCamera babylonMainCamera = null;
if (babylonScene.CamerasList.Count > 0)
{
// Set first camera as main one
babylonMainCamera = babylonScene.CamerasList[0];
babylonScene.activeCameraID = babylonMainCamera.id;
RaiseMessage("Active camera set to " + babylonMainCamera.name, Color.Green, 1, true);
}
if (babylonMainCamera == null)
{
RaiseWarning("No camera defined", 1);
}
else
{
RaiseMessage(string.Format("Total cameras: {0}", babylonScene.CamerasList.Count), Color.Gray, 1);
}
if (exportParameters.exportAnimationsOnly == false)
{
// Default light
if (!exportParameters.pbrNoLight && babylonScene.LightsList.Count == 0)
{
RaiseWarning("No light defined", 1);
RaiseWarning("A default ambient light was added for your convenience", 1);
ExportDefaultLight(babylonScene);
}
else
{
RaiseMessage(string.Format("Total lights: {0}", babylonScene.LightsList.Count), Color.Gray, 1);
}
}
var sceneScaleFactor = exportParameters.scaleFactor;
if (sceneScaleFactor != 1.0f)
{
RaiseMessage(String.Format("A root node is added to globally scale the scene by {0}", sceneScaleFactor), 1);
// Create root node for scaling
BabylonMesh rootNode = new BabylonMesh {
name = "root", id = Tools.GenerateUUID()
};
rootNode.isDummy = true;
float rootNodeScale = sceneScaleFactor;
rootNode.scaling = new float[3] {
rootNodeScale, rootNodeScale, rootNodeScale
};
if (ExportQuaternionsInsteadOfEulers)
{
rootNode.rotationQuaternion = new float[] { 0, 0, 0, 1 };
}
else
{
rootNode.rotation = new float[] { 0, 0, 0 };
}
// Update all top nodes
var babylonNodes = new List <BabylonNode>();
babylonNodes.AddRange(babylonScene.MeshesList);
babylonNodes.AddRange(babylonScene.CamerasList);
babylonNodes.AddRange(babylonScene.LightsList);
foreach (BabylonNode babylonNode in babylonNodes)
{
if (babylonNode.parentId == null)
{
babylonNode.parentId = rootNode.id;
}
}
// Store root node
babylonScene.MeshesList.Add(rootNode);
}
// --------------------
// ----- Materials ----
// --------------------
if (exportParameters.exportAnimationsOnly == false && exportParameters.exportMaterials == true)
{
RaiseMessage("Exporting materials");
GenerateMaterialDuplicationDatas(babylonScene);
foreach (var mat in referencedMaterials)
{
ExportMaterial(mat, babylonScene, exportParameters.pbrFull);
CheckCancelled();
}
foreach (var mat in multiMaterials)
{
ExportMultiMaterial(mat.Key, mat.Value, babylonScene, exportParameters.pbrFull);
CheckCancelled();
}
UpdateMeshesMaterialId(babylonScene);
RaiseMessage(string.Format("Total: {0}", babylonScene.MaterialsList.Count + babylonScene.MultiMaterialsList.Count), Color.Gray, 1);
}
// Export skeletons
if (exportParameters.exportSkins && skins.Count > 0)
{
progressSkin = 0;
progressSkinStep = 100 / skins.Count;
ReportProgressChanged(progressSkin);
RaiseMessage("Exporting skeletons");
foreach (var skin in skins)
{
ExportSkin(skin, babylonScene);
}
}
// set back the frame
Loader.SetCurrentTime(currentTime);
// ----------------------------
// ----- Animation groups -----
// ----------------------------
if (exportParameters.exportAnimations)
{
RaiseMessage("Export animation groups");
// add animation groups to the scene
babylonScene.animationGroups = ExportAnimationGroups(babylonScene);
}
if (isBabylonExported)
{
// if we are exporting to .Babylon then remove animations from nodes if there are animation groups.
if (babylonScene.animationGroups != null && babylonScene.animationGroups.Count > 0)
{
// add animations of each nodes in the animGroup
List <BabylonNode> babylonNodes = new List <BabylonNode>();
babylonNodes.AddRange(babylonScene.MeshesList);
babylonNodes.AddRange(babylonScene.CamerasList);
babylonNodes.AddRange(babylonScene.LightsList);
foreach (BabylonNode node in babylonNodes)
{
node.animations = null;
}
foreach (BabylonSkeleton skel in babylonScene.SkeletonsList)
{
foreach (BabylonBone bone in skel.bones)
{
bone.animation = null;
}
}
}
if (exportParameters.exportAnimationsOnly == false)
{
// setup a default skybox for the scene for .Babylon export.
var sourcePath = exportParameters.pbrEnvironment;
if (!string.IsNullOrEmpty(sourcePath))
{
babylonScene.createDefaultSkybox = exportParameters.createDefaultSkybox;
var fileName = Path.GetFileName(sourcePath);
// Allow only dds file format
if (!fileName.EndsWith(".dds"))
{
RaiseWarning("Failed to export defauenvironment texture: only .dds format is supported.");
}
else
{
RaiseMessage($"texture id = Max_Babylon_Default_Environment");
babylonScene.environmentTexture = fileName;
if (exportParameters.writeTextures)
{
try
{
var destPath = Path.Combine(babylonScene.OutputPath, fileName);
if (File.Exists(sourcePath) && sourcePath != destPath)
{
File.Copy(sourcePath, destPath, true);
}
}
catch
{
// silently fails
RaiseMessage($"Fail to export the default env texture", 3);
}
}
}
}
}
}
// Output
babylonScene.Prepare(false, false);
if (isBabylonExported)
{
Write(babylonScene, outputBabylonDirectory, outputFileName, exportParameters.outputFormat, exportParameters.generateManifest);
}
ReportProgressChanged(100);
// Export glTF
if (exportParameters.outputFormat == "gltf" || exportParameters.outputFormat == "glb")
{
bool generateBinary = exportParameters.outputFormat == "glb";
GLTFExporter gltfExporter = new GLTFExporter();
gltfExporter.ExportGltf(this.exportParameters, babylonScene, outputBabylonDirectory, outputFileName, generateBinary, this);
}
watch.Stop();
RaiseMessage(string.Format("Export done in {0:0.00}s", watch.ElapsedMilliseconds / 1000.0), Color.Blue);
}
private void CreateFiles(ClaimsPrincipal user,
ExportParameters exportParameters,
SparseProjectInfo sparseProject,
string directoryPath,
CancellationToken cancellationToken)
{
var channelDescriptionSet = sparseProject.ToChannelDescriptions();
var singleFile = exportParameters.FileGranularity == FileGranularity.SingleFile;
TimeSpan filePeriod;
if (singleFile)
{
filePeriod = exportParameters.End - exportParameters.Begin;
}
else
{
filePeriod = TimeSpan.FromSeconds((int)exportParameters.FileGranularity);
}
DataWriterExtensionSettingsBase settings;
DataWriterExtensionLogicBase dataWriter;
switch (exportParameters.FileFormat)
{
case FileFormat.CSV:
settings = new CsvSettings()
{
FilePeriod = filePeriod,
SingleFile = singleFile,
RowIndexFormat = exportParameters.CsvRowIndexFormat,
SignificantFigures = exportParameters.CsvSignificantFigures,
};
dataWriter = new CsvWriter((CsvSettings)settings, NullLogger.Instance);
break;
case FileFormat.FAMOS:
settings = new FamosSettings()
{
FilePeriod = filePeriod,
SingleFile = singleFile,
};
dataWriter = new FamosWriter((FamosSettings)settings, NullLogger.Instance);
break;
case FileFormat.MAT73:
settings = new Mat73Settings()
{
FilePeriod = filePeriod,
SingleFile = singleFile,
};
dataWriter = new Mat73Writer((Mat73Settings)settings, NullLogger.Instance);
break;
default:
throw new NotImplementedException();
}
// create custom meta data
var customMetadataEntrySet = new List <CustomMetadataEntry>();
//customMetadataEntrySet.Add(new CustomMetadataEntry("system_name", "Nexus Explorer", CustomMetadataEntryLevel.File));
if (!string.IsNullOrWhiteSpace(sparseProject.License.FileMessage))
{
customMetadataEntrySet.Add(new CustomMetadataEntry("license", sparseProject.License.FileMessage, CustomMetadataEntryLevel.Project));
}
// initialize data writer
var projectName_splitted = sparseProject.Id.Split('/');
var dataWriterContext = new DataWriterContext("Nexus Explorer", directoryPath, new NexusProjectDescription(Guid.Empty, 0, projectName_splitted[1], projectName_splitted[2], projectName_splitted[3]), customMetadataEntrySet);
dataWriter.Configure(dataWriterContext, channelDescriptionSet);
try
{
// create temp files
this.CreateFiles(user, dataWriter, exportParameters, sparseProject, cancellationToken);
dataWriter.Dispose();
}
finally
{
dataWriter.Dispose();
}
}
public Task <string> ExportDataAsync(ExportParameters exportParameters,
List <DatasetInfo> datasets,
CancellationToken cancellationToken)
{
if (!datasets.Any() || exportParameters.Begin == exportParameters.End)
{
return(Task.FromResult(string.Empty));
}
var username = _userIdService.GetUserId();
// find sample rate
var sampleRates = datasets.Select(dataset => dataset.GetSampleRate());
if (sampleRates.Select(sampleRate => sampleRate.SamplesPerSecond).Distinct().Count() > 1)
{
throw new ValidationException("Channels with different sample rates have been requested.");
}
return(Task.Run(() =>
{
var sampleRate = sampleRates.First();
// log
var message = $"User '{username}' exports data: {exportParameters.Begin.ToISO8601()} to {exportParameters.End.ToISO8601()} ... ";
_logger.LogInformation(message);
try
{
// convert datasets into projects
var projectIds = datasets.Select(dataset => dataset.Parent.Parent.Id).Distinct();
var projectContainers = _databaseManager.Database.ProjectContainers
.Where(projectContainer => projectIds.Contains(projectContainer.Id));
var sparseProjects = projectContainers.Select(projectContainer =>
{
var currentDatasets = datasets.Where(dataset => dataset.Parent.Parent.Id == projectContainer.Id).ToList();
return projectContainer.ToSparseProject(currentDatasets);
});
// start
var zipFilePath = Path.Combine(_options.ExportDirectoryPath, $"Nexus_{exportParameters.Begin.ToString("yyyy-MM-ddTHH-mm")}_{sampleRate.ToUnitString(underscore: true)}_{Guid.NewGuid().ToString().Substring(0, 8)}.zip");
using var zipArchive = ZipFile.Open(zipFilePath, ZipArchiveMode.Create);
// create tmp/target directory
var directoryPath = exportParameters.ExportMode switch
{
ExportMode.Web => Path.Combine(Path.GetTempPath(), "Nexus", Guid.NewGuid().ToString()),
ExportMode.Local => Path.Combine(_options.ExportDirectoryPath, $"Nexus_{exportParameters.Begin.ToString("yyyy-MM-ddTHH-mm")}_{sampleRate.ToUnitString(underscore: true)}_{Guid.NewGuid().ToString().Substring(0, 8)}"),
_ => throw new Exception("Unsupported export mode.")
};
Directory.CreateDirectory(directoryPath);
foreach (var sparseProject in sparseProjects)
{
this.CreateFiles(_userIdService.User, exportParameters, sparseProject, directoryPath, cancellationToken);
}
switch (exportParameters.ExportMode)
{
case ExportMode.Web:
this.WriteZipArchiveEntries(zipArchive, directoryPath, cancellationToken);
break;
case ExportMode.Local:
break;
default:
break;
}
_logger.LogInformation($"{message} Done.");
return $"export/{Path.GetFileName(zipFilePath)}";
}
catch (Exception ex)
{
_logger.LogError($"{message} Fail. Reason: {ex.GetFullMessage()}");
throw;
}
}, cancellationToken));
}
public World()
{
ExportParameters = new ExportParameters();
Parameters = new WorldParameters();
BaseField = new FieldObjects.BaseField();
}
/// <summary>
/// Have a dummy export manager - we just need the DLLs to be exported
/// </summary>
/// <param name="exportParameters"></param>
/// <returns></returns>
public override ExportManager GenerateExportManager(ExportParameters exportParameters)
{
return(new SiteLicenseExportManager(exportParameters));
}
public void RunExport(ExportParameters parameters)
{
ExportStrings(parameters);
}
public void ParseXml()
{
XmlDocument xmlDoc = XmlReaderWriterHelper.ParseXmlDocument(m_ConfigurationFilePath, false, false);
XmlNode importNode = XmlDocumentHelper.GetFirstChildElementOrSelfWithName(xmlDoc.DocumentElement, true, "import", xmlDoc.DocumentElement.NamespaceURI);
foreach (XmlNode n in importNode.ChildNodes)
{
string innerText = n.InnerText;
if (n.LocalName == "obiprojectdirectory")
{
m_ObiProjectDirectoryPath = innerText.Trim();
}
else if (n.LocalName == "audiosamplerate")
{
string strSampleRate = innerText.Trim();
m_ImportSampleRate = int.Parse(strSampleRate);
m_ImportSampleRateEnum = strSampleRate == "44100" ? AudioLib.SampleRate.Hz44100 :
strSampleRate == "22050" ? AudioLib.SampleRate.Hz22050
: AudioLib.SampleRate.Hz11025;
}
else if (n.LocalName == "audiochannels")
{
string strChannels = innerText.Trim();
m_ImportChannels = int.Parse(strChannels.Trim());
}
}
foreach (XmlNode exportNode in XmlDocumentHelper.GetChildrenElementsOrSelfWithName(xmlDoc.DocumentElement, true, "export", xmlDoc.DocumentElement.NamespaceURI, false))
{
ExportFormat exportStandards = ExportFormat.DAISY3_0;
string exportDirectory = null;
bool encodeExportedAudioFiles = false;
AudioLib.AudioFileFormats encodingAudioFileFormat = AudioLib.AudioFileFormats.WAV;
AudioLib.SampleRate exportSampleRate = AudioLib.SampleRate.Hz44100;
int exportChannels = 1;
double exportEncodingBitrate = 64;
foreach (XmlNode n in exportNode.ChildNodes)
{
if (n.LocalName == "directory")
{
exportDirectory = n.InnerText.Trim();
}
else if (n.LocalName == "standard")
{
string strStandard = n.InnerText.Trim();
exportStandards = strStandard == "daisy2.02" ? ExportFormat.DAISY2_02 :
strStandard == "daisy3" ? ExportFormat.DAISY3_0 :
ExportFormat.EPUB3;
}
else if (n.LocalName == "audioencoding")
{
string strEncoding = n.InnerText.Trim();
encodeExportedAudioFiles = strEncoding.ToLower() != "wav";
if (encodeExportedAudioFiles)
{
encodingAudioFileFormat = (strEncoding.ToLower() == "mp4" || strEncoding.ToLower() == "m4a") ? AudioLib.AudioFileFormats.MP4 :
AudioLib.AudioFileFormats.MP3;
}
}
else if (n.LocalName == "bitrate")
{
string strBitrate = n.InnerText.Trim();
exportEncodingBitrate = int.Parse(strBitrate);
}
else if (n.LocalName == "audiosamplerate")
{
string strSampleRate = n.InnerText;
exportSampleRate = strSampleRate == "44100" ? AudioLib.SampleRate.Hz44100 :
strSampleRate == "22050" ? AudioLib.SampleRate.Hz22050
: AudioLib.SampleRate.Hz11025;
}
else if (n.LocalName == "audiochannels")
{
string strChannels = n.InnerText;
exportChannels = int.Parse(strChannels.Trim());
}
}
ExportParameters exportObject = new ExportParameters(exportStandards,
exportDirectory,
encodeExportedAudioFiles,
encodingAudioFileFormat,
exportSampleRate,
exportChannels,
exportEncodingBitrate);
// assign export parameters to respective properties
if (exportObject.ExportStandards == ExportFormat.DAISY3_0)
{
m_DAISY3ExportParameters = exportObject;
}
else if (exportObject.ExportStandards == ExportFormat.DAISY2_02)
{
m_DAISY202ExportParameters = exportObject;
}
else if (exportObject.ExportStandards == ExportFormat.EPUB3)
{
m_EPUB3ExportParameters = exportObject;
}
Console.WriteLine("Config file export parameters: " + exportObject.ExportStandards);
Console.WriteLine("export channels: " + exportObject.ExportChannels + ", directory:" + exportObject.ExportDirectory);
Console.WriteLine("encoding: " + exportObject.EncodeExportedAudioFiles + " " + exportObject.EncodingAudioFileFormat + ", bit rate:" + exportObject.ExportEncodingBitrate + ", sample rate:" + exportObject.ExportSampleRate);
}
xmlDoc = null;
}
/// <summary>
/// Have a dummy export manager - we just need the DLLs to be exported
/// </summary>
/// <param name="exportParameters"></param>
/// <returns></returns>
public override ExportManager GenerateExportManager(ExportParameters exportParameters)
{
return(new TimelineViewItemExportManager(exportParameters));
}
public ActionResult <ExportJob> CreateExportJob(ExportParameters parameters)
{
if (_databaseManager.Database == null)
{
return(this.StatusCode(503, "The database has not been loaded yet."));
}
parameters.Begin = parameters.Begin.ToUniversalTime();
parameters.End = parameters.End.ToUniversalTime();
// translate channel paths to datasets
List <DatasetInfo> datasets;
try
{
datasets = parameters.ChannelPaths.Select(channelPath =>
{
if (!_databaseManager.Database.TryFindDataset(channelPath, out var dataset))
{
throw new ValidationException($"Could not find the channel with path '{channelPath}'.");
}
return(dataset);
}).ToList();
}
catch (ValidationException ex)
{
return(this.UnprocessableEntity(ex.GetFullMessage(includeStackTrace: false)));
}
// check that there is anything to export
if (!datasets.Any())
{
return(this.BadRequest("The list of channel paths is empty."));
}
// security check
var projectIds = datasets.Select(dataset => dataset.Parent.Parent.Id).Distinct();
foreach (var projectId in projectIds)
{
if (!Utilities.IsProjectAccessible(this.HttpContext.User, projectId, _databaseManager.Database))
{
return(this.Unauthorized($"The current user is not authorized to access project '{projectId}'."));
}
}
//
var job = new ExportJob()
{
Owner = this.User.Identity.Name,
Parameters = parameters
};
var dataService = _serviceProvider.GetRequiredService <DataService>();
try
{
var jobControl = _exportJobService.AddJob(job, dataService.Progress, (jobControl, cts) =>
{
var userIdService = _serviceProvider.GetRequiredService <UserIdService>();
var task = dataService.ExportDataAsync(parameters, datasets, cts.Token);
return(task);
});
return(this.Accepted($"{this.GetBasePath()}{this.Request.Path}/{jobControl.Job.Id}/status", jobControl.Job));
}
catch (ValidationException ex)
{
return(this.UnprocessableEntity(ex.GetFullMessage(includeStackTrace: false)));
}
}
public TimelineViewItemExportManager(ExportParameters exportParameters)
: base(exportParameters)
{
}
private static void CopyGltfTexture(string sourcePath, string destPath, ILoggingProvider logger, ExportParameters exportParameters)
{
TextureUtilities.CopyTexture(sourcePath, destPath, exportParameters.txtQuality, logger);
}
private async Task <bool> DoExport()
{
Loader.SetBoolProperty(chkCopyTexturesProperty, chkCopyTextures.Checked);
Loader.SetBoolProperty(chkHiddenProperty, chkHidden.Checked);
Loader.SetBoolProperty(chkOnlySelectedProperty, chkOnlySelected.Checked);
Loader.SetBoolProperty(chkManifestProperty, chkManifest.Checked);
Loader.SetBoolProperty(chkAutoSaveProperty, chkAutoSave.Checked);
Loader.SetBoolProperty(chkOptimizeVerticesProperty, chkOptimizeVertices.Checked);
Loader.SetBoolProperty(chkExportTangentsProperty, chkExportTangents.Checked);
Loader.SetBoolProperty(chkDracoCompressionProperty, chkDracoCompression.Checked);
Loader.SetBoolProperty(chkExportSkinProperty, chkExportSkin.Checked);
Loader.SetBoolProperty(chkExportMorphNormalProperty, chkExportMorphNormal.Checked);
Loader.SetBoolProperty(chkExportMorphTangentProperty, chkExportMorphTangent.Checked);
Loader.SetBoolProperty(chkExportKHRLightsPunctualProperty, chkExportKHRLightsPunctual.Checked);
Loader.SetBoolProperty(chkExportKHRTextureTransformProperty, chkExportKHRTextureTransform.Checked);
Loader.SetBoolProperty(chkExportKHRMaterialsUnlitProperty, chkExportKHRMaterialsUnlit.Checked);
Loader.SetBoolProperty(chkBakeAnimationFramesProperty, chkBakeAnimationFrames.Checked);
Loader.SetBoolProperty(chkExportAnimationsProperty, chkExportAnimations.Checked);
Loader.SetBoolProperty(chkExportAnimationsOnlyProperty, chkExportAnimationsOnly.Checked);
Loader.SetBoolProperty(chkExportMaterialsProperty, chkExportMaterials.Checked);
Loader.SetBoolProperty(chkExportTexturesProperty, chkExportTextures.Checked);
Loader.SetBoolProperty(PBRFullPropertyName, chkFullPBR.Checked);
Loader.SetBoolProperty(PBRNoLightPropertyName, chkNoAutoLight.Checked);
Loader.SetBoolProperty(PBRDefaultSkyboxName, chkDefaultSkybox.Checked);
/*Tools.UpdateComboBox(comboOutputFormat, Loader.Core.RootNode, "babylonjs_outputFormat");
*
* Loader.Core.RootNode.SetLocalData(txtFilename.Text);*/
exporter = new BabylonExporter();
treeView.Nodes.Clear();
exporter.OnExportProgressChanged += progress =>
{
progressBar.Value = progress;
Application.DoEvents();
};
exporter.OnWarning += (warning, rank) =>
{
try
{
currentNode = CreateTreeNode(rank, warning, Color.DarkOrange);
currentNode.EnsureVisible();
}
catch
{
}
Application.DoEvents();
};
exporter.OnError += (error, rank) =>
{
try
{
currentNode = CreateTreeNode(rank, error, Color.Red);
currentNode.EnsureVisible();
}
catch
{
}
Application.DoEvents();
};
exporter.OnMessage += (message, color, rank, emphasis) =>
{
try
{
currentNode = CreateTreeNode(rank, message, color);
if (emphasis)
{
currentNode.EnsureVisible();
}
}
catch
{
}
Application.DoEvents();
};
exporter.OnVerbose += (message, color, rank, emphasis) =>
{
try
{
currentNode = CreateTreeNode(rank, message, color);
if (emphasis)
{
currentNode.EnsureVisible();
}
}
catch
{
}
Application.DoEvents();
};
butExport.Enabled = false;
butExportAndRun.Enabled = false;
butCancel.Enabled = true;
bool success = true;
try
{
var scaleFactorParsed = 1.0f;
var textureQualityParsed = 100L;
try
{
scaleFactorParsed = float.Parse(txtScaleFactor.Text);
}
catch (Exception e)
{
throw new InvalidDataException(String.Format("Invalid Scale Factor value: {0}", txtScaleFactor.Text));
}
try
{
textureQualityParsed = long.Parse(txtQuality.Text);
}
catch (Exception e)
{
throw new InvalidDataException(String.Format("Invalid Texture Quality value: {0}", txtScaleFactor.Text));
}
var exportParameters = new ExportParameters
{
outputPath = txtFilename.Text,
outputFormat = comboOutputFormat.SelectedItem.ToString(),
generateManifest = chkManifest.Checked,
exportOnlySelected = chkOnlySelected.Checked,
autoSaveSceneFile = chkAutoSave.Checked,
exportHiddenObjects = chkHidden.Checked,
writeTextures = chkCopyTextures.Checked,
overwriteTextures = chkCopyTextures.Checked,
optimizeVertices = chkOptimizeVertices.Checked,
exportTangents = chkExportTangents.Checked,
scaleFactor = scaleFactorParsed,
exportSkins = chkExportSkin.Checked,
txtQuality = textureQualityParsed,
dracoCompression = chkDracoCompression.Checked,
exportMaterials = chkExportMaterials.Checked,
exportMorphNormals = chkExportMorphNormal.Checked,
exportMorphTangents = chkExportMorphTangent.Checked,
exportTextures = chkExportTextures.Checked,
enableKHRLightsPunctual = chkExportKHRLightsPunctual.Checked,
enableKHRTextureTransform = chkExportKHRTextureTransform.Checked,
enableKHRMaterialsUnlit = chkExportKHRMaterialsUnlit.Checked,
bakeAnimationFrames = chkBakeAnimationFrames.Checked,
exportAnimations = chkExportAnimations.Checked,
exportAnimationsOnly = chkExportAnimationsOnly.Checked,
pbrFull = chkFullPBR.Checked,
pbrNoLight = chkNoAutoLight.Checked,
createDefaultSkybox = chkDefaultSkybox.Checked,
pbrEnvironment = txtEnvironmentName.Text
};
exporter.Export(exportParameters);
}
catch (OperationCanceledException)
{
progressBar.Value = 0;
success = false;
}
catch (Exception ex)
{
currentNode = CreateTreeNode(0, "Export cancelled: " + ex.Message, Color.Red);
currentNode = CreateTreeNode(1, ex.ToString(), Color.Red);
currentNode.EnsureVisible();
progressBar.Value = 0;
success = false;
}
butCancel.Enabled = false;
butExport.Enabled = true;
butExportAndRun.Enabled = WebServer.IsSupported;
BringToFront();
return(success);
}
public void ExportGltf(ExportParameters exportParameters, BabylonScene babylonScene, string outputDirectory, string outputFileName, bool generateBinary, ILoggingProvider logger)
{
this.exportParameters = exportParameters;
this.logger = logger;
logger.RaiseMessage("GLTFExporter | Exportation started", Color.Blue);
#if DEBUG
var watch = new Stopwatch();
watch.Start();
#endif
this.babylonScene = babylonScene;
// Force output file extension to be gltf
outputFileName = Path.ChangeExtension(outputFileName, "gltf");
// Update path of output .gltf file to include subdirectory
var outputFile = Path.Combine(outputDirectory, outputFileName);
float progressionStep;
var progression = 0.0f;
logger.ReportProgressChanged((int)progression);
babylonMaterialsToExport = new List <BabylonMaterial>();
var gltf = new GLTF(outputFile);
// Asset
gltf.asset = new GLTFAsset
{
version = "2.0"
// no minVersion
};
var softwarePackageName = babylonScene.producer != null ? babylonScene.producer.name : "";
var softwareVersion = babylonScene.producer != null ? babylonScene.producer.version : "";
var exporterVersion = babylonScene.producer != null ? babylonScene.producer.exporter_version : "";
gltf.asset.generator = $"babylon.js glTF exporter for {softwarePackageName} {softwareVersion} v{exporterVersion}";
// Scene
gltf.scene = 0;
// Scenes
GLTFScene scene = new GLTFScene();
ExportGLTFExtension(babylonScene, ref scene, gltf);
GLTFScene[] scenes = { scene };
gltf.scenes = scenes;
// Initialization
initBabylonNodes(babylonScene, gltf);
// Root nodes
logger.RaiseMessage("GLTFExporter | Exporting nodes");
progression = 30.0f;
logger.ReportProgressChanged((int)progression);
List <BabylonNode> babylonRootNodes = babylonNodes.FindAll(node => node.parentId == null);
progressionStep = 30.0f / babylonRootNodes.Count;
alreadyExportedSkeletons = new Dictionary <BabylonSkeleton, BabylonSkeletonExportData>();
nodeToGltfNodeMap = new Dictionary <BabylonNode, GLTFNode>();
NbNodesByName = new Dictionary <string, int>();
babylonRootNodes.ForEach(babylonNode =>
{
exportNodeRec(babylonNode, gltf, babylonScene);
progression += progressionStep;
logger.ReportProgressChanged((int)progression);
logger.CheckCancelled();
});
// Meshes
logger.RaiseMessage("GLTFExporter | Exporting meshes");
progression = 10.0f;
logger.ReportProgressChanged((int)progression);
progressionStep = 40.0f / babylonScene.meshes.Length;
foreach (var babylonMesh in babylonScene.meshes)
{
ExportMesh(babylonMesh, gltf, babylonScene);
progression += progressionStep;
logger.ReportProgressChanged((int)progression);
logger.CheckCancelled();
}
#if DEBUG
var meshesExportTime = watch.ElapsedMilliseconds / 1000.0;
logger.RaiseMessage(string.Format("GLTFMeshes exported in {0:0.00}s", meshesExportTime), Color.Blue);
#endif
//Mesh Skins, light and Cameras
logger.RaiseMessage("GLTFExporter | Exporting skins, lights and cameras");
progression = 50.0f;
logger.ReportProgressChanged((int)progression);
progressionStep = 50.0f / babylonRootNodes.Count;
babylonRootNodes.ForEach(babylonNode =>
{
exportNodeTypeRec(babylonNode, gltf, babylonScene);
progression += progressionStep;
logger.ReportProgressChanged((int)progression);
logger.CheckCancelled();
});
#if DEBUG
var nodesExportTime = watch.ElapsedMilliseconds / 1000.0 - meshesExportTime;
logger.RaiseMessage(string.Format("GLTFNodes exported in {0:0.00}s", nodesExportTime), Color.Blue);
#endif
// Materials
progression = 70.0f;
logger.ReportProgressChanged((int)progression);
logger.RaiseMessage("GLTFExporter | Exporting materials");
foreach (var babylonMaterial in babylonMaterialsToExport)
{
ExportMaterial(babylonMaterial, gltf);
logger.CheckCancelled();
}
;
logger.RaiseMessage(string.Format("GLTFExporter | Nb materials exported: {0}", gltf.MaterialsList.Count), Color.Gray, 1);
#if DEBUG
var materialsExportTime = watch.ElapsedMilliseconds / 1000.0 - nodesExportTime;
logger.RaiseMessage(string.Format("GLTFMaterials exported in {0:0.00}s", materialsExportTime), Color.Blue);
#endif
// Animations
progression = 90.0f;
logger.ReportProgressChanged((int)progression);
logger.RaiseMessage("GLTFExporter | Exporting Animations");
ExportAnimationGroups(gltf, babylonScene);
#if DEBUG
var animationGroupsExportTime = watch.ElapsedMilliseconds / 1000.0 - materialsExportTime;
logger.RaiseMessage(string.Format("GLTFAnimations exported in {0:0.00}s", animationGroupsExportTime), Color.Blue);
#endif
// Prepare buffers
gltf.BuffersList.ForEach(buffer =>
{
buffer.BufferViews.ForEach(bufferView =>
{
bufferView.Accessors.ForEach(accessor =>
{
// Chunk must be padded with trailing zeros (0x00) to satisfy alignment requirements
accessor.bytesList = new List <byte>(padChunk(accessor.bytesList.ToArray(), 4, 0x00));
// Update byte properties
accessor.byteOffset = bufferView.byteLength;
bufferView.byteLength += accessor.bytesList.Count;
// Merge bytes
bufferView.bytesList.AddRange(accessor.bytesList);
});
// Update byte properties
bufferView.byteOffset = buffer.byteLength;
buffer.byteLength += bufferView.bytesList.Count;
// Merge bytes
buffer.bytesList.AddRange(bufferView.bytesList);
});
});
// Cast lists to arrays
gltf.Prepare();
// Output
logger.RaiseMessage("GLTFExporter | Saving to output file");
if (!generateBinary)
{
// Write .gltf file
string outputGltfFile = Path.ChangeExtension(outputFile, "gltf");
File.WriteAllText(outputGltfFile, gltfToJson(gltf));
// Write .bin file
string outputBinaryFile = Path.ChangeExtension(outputFile, "bin");
using (BinaryWriter writer = new BinaryWriter(File.Open(outputBinaryFile, FileMode.Create)))
{
gltf.BuffersList.ForEach(buffer =>
{
buffer.bytesList.ForEach(b => writer.Write(b));
});
}
}
else
{
// Export glTF data to binary format .glb
// Header
UInt32 magic = 0x46546C67; // ASCII code for glTF
UInt32 version = 2;
UInt32 length = 12; // Header length
// --- JSON chunk ---
UInt32 chunkTypeJson = 0x4E4F534A; // ASCII code for JSON
// Remove buffers uri
foreach (GLTFBuffer gltfBuffer in gltf.BuffersList)
{
gltfBuffer.uri = null;
}
// Switch images to binary
var imageBufferViews = SwitchImagesFromUriToBinary(gltf);
imageBufferViews.ForEach(imageBufferView =>
{
imageBufferView.Buffer.bytesList.AddRange(imageBufferView.bytesList);
});
gltf.Prepare();
// Serialize gltf data to JSON string then convert it to bytes
byte[] chunkDataJson = Encoding.ASCII.GetBytes(gltfToJson(gltf));
// JSON chunk must be padded with trailing Space chars (0x20) to satisfy alignment requirements
chunkDataJson = padChunk(chunkDataJson, 4, 0x20);
UInt32 chunkLengthJson = (UInt32)chunkDataJson.Length;
length += chunkLengthJson + 8; // 8 = JSON chunk header length
// bin chunk
UInt32 chunkTypeBin = 0x004E4942; // ASCII code for BIN
UInt32 chunkLengthBin = 0;
if (gltf.BuffersList.Count > 0)
{
foreach (GLTFBuffer gltfBuffer in gltf.BuffersList)
{
chunkLengthBin += (uint)gltfBuffer.byteLength;
}
length += chunkLengthBin + 8; // 8 = bin chunk header length
}
// Write binary file
string outputGlbFile = Path.ChangeExtension(outputFile, "glb");
using (BinaryWriter writer = new BinaryWriter(File.Open(outputGlbFile, FileMode.Create)))
{
// Header
writer.Write(magic);
writer.Write(version);
writer.Write(length);
// JSON chunk
writer.Write(chunkLengthJson);
writer.Write(chunkTypeJson);
writer.Write(chunkDataJson);
// bin chunk
if (gltf.BuffersList.Count > 0)
{
writer.Write(chunkLengthBin);
writer.Write(chunkTypeBin);
gltf.BuffersList[0].bytesList.ForEach(b => writer.Write(b));
}
};
}
// Draco compression
if (exportParameters.dracoCompression)
{
logger.RaiseMessage("GLTFExporter | Draco compression");
try
{
Process gltfPipeline = new Process();
// Hide the cmd window that show the gltf-pipeline result
//gltfPipeline.StartInfo.UseShellExecute = false;
//gltfPipeline.StartInfo.CreateNoWindow = true;
gltfPipeline.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
string arg;
if (generateBinary)
{
string outputGlbFile = Path.ChangeExtension(outputFile, "glb");
arg = $" -i {outputGlbFile} -o {outputGlbFile} -d";
}
else
{
string outputGltfFile = Path.ChangeExtension(outputFile, "gltf");
arg = $" -i {outputGltfFile} -o {outputGltfFile} -d -s";
}
gltfPipeline.StartInfo.FileName = "gltf-pipeline.cmd";
gltfPipeline.StartInfo.Arguments = arg;
gltfPipeline.Start();
gltfPipeline.WaitForExit();
}
catch
{
logger.RaiseError("gltf-pipeline module not found.", 1);
logger.RaiseError("The exported file wasn't compressed.");
}
}
logger.ReportProgressChanged(100);
}
public Exporter(MainModel model, ExportParameters parameters)
{
this.Data = new ExportData(model, parameters);
}