private bool ImportFromLocalFolder()
{
bool failed = false;
// Import the (copied and mapped) files this importer previously requested to handle
this.output = new List <AssetImportOutput>();
for (int assignmentIndex = 0; assignmentIndex < this.inputMapping.Count; assignmentIndex++)
{
ImportInputAssignment assignment = this.inputMapping.Data[assignmentIndex];
AssetImportEnvironment importEnv = new AssetImportEnvironment(this.targetDir, this.sourceDir, assignment.HandledInputInSourceMedia);
if (!this.RunImporter(importEnv, assignment, this.output))
{
failed = true;
}
}
// Save the newly imported Resources
foreach (AssetImportOutput item in this.output)
{
item.Resource.Res.Save();
}
return(!failed);
}
private bool DoesOverwriteData()
{
for (int assignmentIndex = 0; assignmentIndex < this.inputMapping.Count; assignmentIndex++)
{
ImportInputAssignment assignment = this.inputMapping.Data[assignmentIndex];
// Determine if we'll be overwriting any Resource files
for (int i = 0; i < assignment.ExpectedOutput.Length; i++)
{
if (File.Exists(assignment.ExpectedOutput[i].Resource.Path))
{
return(true);
}
}
// Determine if we'll be overwriting any source / media files
for (int i = 0; i < assignment.HandledInput.Length; i++)
{
if (File.Exists(assignment.HandledInputInSourceMedia[i].Path))
{
if (!PathHelper.FilesEqual(assignment.HandledInput[i].Path, assignment.HandledInputInSourceMedia[i].Path))
{
return(true);
}
}
}
}
return(false);
}
protected bool RunImporter(AssetImportEnvironment env, ImportInputAssignment assignment, IList <AssetImportOutput> outputCollection)
{
try
{
assignment.Importer.Import(env);
// Get a list on properly registered output Resources and report warnings on the rest
List <AssetImportOutput> expectedOutput = new List <AssetImportOutput>();
foreach (AssetImportOutput output in env.Output)
{
if (!assignment.ExpectedOutput.Any(item => item.Resource == output.Resource))
{
Log.Editor.WriteWarning(
"AssetImporter '{0}' created an unpredicted output Resource: '{1}'. " + Environment.NewLine +
"This may cause problems in the Asset Management system, especially during Asset re-import. " + Environment.NewLine +
"Please fix the implementation of the PrepareImport method so it properly calls AddOutput for each predicted output Resource.",
Log.Type(assignment.Importer.GetType()),
output.Resource);
}
else
{
expectedOutput.Add(output);
}
}
// Collect references to the imported Resources and save them
foreach (AssetImportOutput output in expectedOutput)
{
Resource resource = output.Resource.Res;
AssetInfo assetInfo = resource.AssetInfo ?? new AssetInfo();
assetInfo.ImporterId = assignment.Importer.Id;
assetInfo.NameHint = resource.Name;
resource.AssetInfo = assetInfo;
outputCollection.Add(output);
}
}
catch (Exception ex)
{
Log.Editor.WriteError("An error occurred while trying to import files using '{1}': {0}",
Log.Exception(ex),
Log.Type(assignment.Importer.GetType()));
return(false);
}
return(true);
}
private void CopySourceToLocalFolder()
{
for (int assignmentIndex = 0; assignmentIndex < this.inputMapping.Count; assignmentIndex++)
{
ImportInputAssignment assignment = this.inputMapping.Data[assignmentIndex];
// Copy all handled files to the media / source directory
try
{
// Copy each handled file into source / media, while preserving the original relative structure
for (int i = 0; i < assignment.HandledInput.Length; i++)
{
string filePath = assignment.HandledInput[i].Path;
string filePathInSourceMedia = assignment.HandledInputInSourceMedia[i].Path;
string dirPathInSourceMedia = Path.GetDirectoryName(filePathInSourceMedia);
// If the file is already where it needs to be, skip it
if (PathOp.ArePathsEqual(filePath, filePathInSourceMedia))
{
continue;
}
// If there already is a similarly named file in the source directory, delete it.
if (File.Exists(filePathInSourceMedia))
{
File.Delete(filePathInSourceMedia);
}
// Assure the media / source directory exists
Directory.CreateDirectory(dirPathInSourceMedia);
// Copy file from its original location to the source / media directory
File.Copy(filePath, filePathInSourceMedia);
// Let the editor know that this was an internal operation - don't handle it like an external operation
FileEventManager.FlagPathEditorModified(filePathInSourceMedia);
}
}
catch (Exception ex)
{
Logs.Editor.WriteError("Can't copy source files to the media / source directory: {0}", LogFormat.Exception(ex));
this.inputMapping.RemoveAt(assignmentIndex);
assignmentIndex--;
}
}
}
private bool ImportFromLocalFolder()
{
bool failed = false;
// Import all files this importer previously requested to handle
this.output = new List <AssetImportOutput>();
for (int assignmentIndex = 0; assignmentIndex < this.inputMapping.Count; assignmentIndex++)
{
ImportInputAssignment assignment = this.inputMapping.Data[assignmentIndex];
AssetImportEnvironment importEnv = new AssetImportEnvironment(
DualityApp.DataDirectory,
EditorHelper.SourceMediaDirectory,
assignment.HandledInputInSourceMedia);
importEnv.IsReImport = true;
if (!this.RunImporter(importEnv, assignment, this.output))
{
failed = true;
}
}
return(!failed);
}
private void DetermineLocalInputFilePaths()
{
for (int assignmentIndex = 0; assignmentIndex < this.inputMapping.Count; assignmentIndex++)
{
ImportInputAssignment assignment = inputMapping.Data[assignmentIndex];
// Create a relative mapping for each of the handled files
AssetImportInput[] handledInputInSourceMedia = new AssetImportInput[assignment.HandledInput.Length];
for (int i = 0; i < assignment.HandledInput.Length; i++)
{
string oldFullName = assignment.HandledInput[i].AssetName;
string newFullName;
// If there was an automatic rename of output Resources, reflect that with local source / media paths
if (this.assetRenameMap.TryGetValue(oldFullName, out newFullName))
{
string ext = Path.GetExtension(assignment.HandledInput[i].Path);
string newRelativePath = newFullName + ext;
handledInputInSourceMedia[i] = new AssetImportInput(
Path.Combine(sourceDir, newRelativePath),
newRelativePath,
newFullName);
}
// Otherwise, perform a regular mapping from original input location to local source / media
else
{
handledInputInSourceMedia[i] = new AssetImportInput(
Path.Combine(sourceDir, assignment.HandledInput[i].RelativePath),
assignment.HandledInput[i].RelativePath,
assignment.HandledInput[i].AssetName);
}
}
// Assign the determined paths back to the input mapping
this.inputMapping.Data[assignmentIndex].HandledInputInSourceMedia = handledInputInSourceMedia;
}
}
protected bool RunImporter(AssetImportEnvironment env, ImportInputAssignment assignment, IList<AssetImportOutput> outputCollection)
{
try
{
assignment.Importer.Import(env);
// Get a list on properly registered output Resources and report warnings on the rest
List<AssetImportOutput> expectedOutput = new List<AssetImportOutput>();
foreach (AssetImportOutput output in env.Output)
{
if (!assignment.ExpectedOutput.Any(item => item.Resource == output.Resource))
{
Log.Editor.WriteWarning(
"AssetImporter '{0}' created an unpredicted output Resource: '{1}'. " + Environment.NewLine +
"This may cause problems in the Asset Management system, especially during Asset re-import. " + Environment.NewLine +
"Please fix the implementation of the PrepareImport method so it properly calls AddOutput for each predicted output Resource.",
Log.Type(assignment.Importer.GetType()),
output.Resource);
}
else
{
expectedOutput.Add(output);
}
}
// Collect references to the imported Resources and save them
foreach (AssetImportOutput output in expectedOutput)
{
Resource resource = output.Resource.Res;
string sourceMediaBaseDir = AssetInternalHelper.GetSourceMediaBaseDir(resource);
string[] sourceFileHints = new string[output.InputPaths.Count];
for (int i = 0; i < sourceFileHints.Length; i++)
{
string fileName = Path.GetFileName(output.InputPaths[i]);
string directory = Path.GetDirectoryName(output.InputPaths[i]);
fileName = fileName.Replace(resource.Name, AssetInfo.FileHintNameVariable);
sourceFileHints[i] = PathHelper.MakeFilePathRelative(
Path.Combine(directory, fileName),
sourceMediaBaseDir);
}
AssetInfo assetInfo = resource.AssetInfo ?? new AssetInfo();
assetInfo.ImporterId = assignment.Importer.Id;
assetInfo.NameHint = resource.Name;
assetInfo.SourceFileHint = sourceFileHints;
resource.AssetInfo = assetInfo;
outputCollection.Add(output);
}
}
catch (Exception ex)
{
Log.Editor.WriteError("An error occurred while trying to import files using '{1}': {0}",
Log.Exception(ex),
Log.Type(assignment.Importer.GetType()));
return false;
}
return true;
}
public ConflictData(ImportInputAssignment[] conflicts, int defaultIndex)
{
this.conflicts = conflicts;
this.defaultIndex = defaultIndex;
}
private int ResolveMappingConflict(ImportInputAssignment[] conflictingAssignments)
{
// Determine the preferred importer based on existing output Resources
string preferredImporterId = null;
{
// Check each importer assignment individually, as each one represents a conflicting import operation
for (int i = 0; i < conflictingAssignments.Length; i++)
{
preferredImporterId = null;
// Find out whether all output Resources of this importer assignment exist and share the same preferred importer
AssetImportOutput[] output = conflictingAssignments[i].ExpectedOutput;
for (int j = 0; j < output.Length; j++)
{
Resource existingRes = output[j].Resource.Res;
if (existingRes == null)
{
preferredImporterId = null;
break;
}
// If at least one Resource doesn't have a preference, that's ambiuous. Cancel it.
string resImporterPref = existingRes.AssetInfo != null ? existingRes.AssetInfo.ImporterId : null;
if (resImporterPref == null)
{
preferredImporterId = null;
break;
}
// Set up the shared importer preference
if (preferredImporterId == null)
{
preferredImporterId = resImporterPref;
}
// If different outputs from this mapping report different preferred importers, that's ambiguous. Cancel it.
else if (preferredImporterId != resImporterPref)
{
preferredImporterId = null;
break;
}
}
// If this importer assignment's Resources have full confidence in a preferred importer, we have a match
if (preferredImporterId != null)
{
break;
}
}
}
// If we have a preferred ID, see if it's an option
if (preferredImporterId != null)
{
for (int i = 0; i < conflictingAssignments.Length; i++)
{
// If we have a match with the preferred importer, this is definitely the correct assignment to handle this.
if (conflictingAssignments[i].Importer.Id == preferredImporterId)
return i;
}
}
// By default, fall back on simply prefering the highest-priority importer
int keepIndex = -1;
int highestPrio = int.MinValue;
for (int i = 0; i < conflictingAssignments.Length; i++)
{
if (conflictingAssignments[i].Importer.Priority > highestPrio)
{
highestPrio = conflictingAssignments[i].Importer.Priority;
keepIndex = i;
}
}
// If there is a conflict handler (such as "spawn a user dialog"), see if that can deal with it.
if (this.conflictHandler != null)
{
ConflictData data = new ConflictData(conflictingAssignments, keepIndex);
IAssetImporter selectedImporter = this.conflictHandler(data);
int selectedIndex = conflictingAssignments.IndexOfFirst(assignment => assignment.Importer == selectedImporter);
return selectedIndex;
}
return keepIndex;
}
protected bool RunImporter(AssetImportEnvironment env, ImportInputAssignment assignment, IList<AssetImportOutput> outputCollection)
{
try
{
assignment.Importer.Import(env);
// Get a list on properly registered output Resources and report warnings on the rest
List<AssetImportOutput> expectedOutput = new List<AssetImportOutput>();
foreach (AssetImportOutput output in env.Output)
{
if (!assignment.ExpectedOutput.Any(item => item.Resource == output.Resource))
{
Log.Editor.WriteWarning(
"AssetImporter '{0}' created an unpredicted output Resource: '{1}'. " + Environment.NewLine +
"This may cause problems in the Asset Management system, especially during Asset re-import. " + Environment.NewLine +
"Please fix the implementation of the PrepareImport method so it properly calls AddOutput for each predicted output Resource.",
Log.Type(assignment.Importer.GetType()),
output.Resource);
}
else
{
expectedOutput.Add(output);
}
}
// Collect references to the imported Resources and save them
foreach (AssetImportOutput output in expectedOutput)
{
Resource resource = output.Resource.Res;
AssetInfo assetInfo = resource.AssetInfo ?? new AssetInfo();
assetInfo.ImporterId = assignment.Importer.Id;
assetInfo.NameHint = resource.Name;
resource.AssetInfo = assetInfo;
outputCollection.Add(output);
}
}
catch (Exception ex)
{
Log.Editor.WriteError("An error occurred while trying to import files using '{1}': {0}",
Log.Exception(ex),
Log.Type(assignment.Importer.GetType()));
return false;
}
return true;
}
protected RawList <ImportInputAssignment> SelectImporter(AssetImportEnvironment env)
{
if (!env.IsPrepareStep)
{
throw new ArgumentException(
"The specified import environment must be configured as a preparation environment.",
"env");
}
// Find an importer to handle some or all of the unhandled input files
RawList <ImportInputAssignment> candidateMapping = new RawList <ImportInputAssignment>();
foreach (IAssetImporter importer in AssetManager.Importers)
{
env.ResetAcquiredData();
try
{
importer.PrepareImport(env);
}
catch (Exception ex)
{
Log.Editor.WriteError("An error occurred in the preparation step of '{1}': {0}",
Log.Exception(ex),
Log.Type(importer.GetType()));
continue;
}
if (env.HandledInput.Any())
{
candidateMapping.Add(new ImportInputAssignment
{
Importer = importer,
HandledInput = env.HandledInput.ToArray(),
ExpectedOutput = env.Output.ToArray()
});
}
}
// Sort candidate mapping from most files to least files, so we can solve the biggest conflicts first
candidateMapping.Sort((a, b) => b.HandledInput.Length - a.HandledInput.Length);
// Determine if multiple importers intend to handle the same files and resolve conflicts
List <int> conflictingIndices = new List <int>();
List <string> conflictingFiles = new List <string>();
for (int mainIndex = 0; mainIndex < candidateMapping.Count; mainIndex++)
{
ImportInputAssignment assignment = candidateMapping[mainIndex];
// Find all conflicts related to this assignment
conflictingIndices.Clear();
conflictingFiles.Clear();
for (int secondIndex = 0; secondIndex < candidateMapping.Count; secondIndex++)
{
if (secondIndex == mainIndex)
{
continue;
}
ImportInputAssignment conflictAssignment = candidateMapping[secondIndex];
IEnumerable <string> mainFiles = assignment.HandledInput.Select(item => item.Path);
IEnumerable <string> secondFiles = conflictAssignment.HandledInput.Select(item => item.Path);
string[] conflicts = mainFiles.Intersect(secondFiles).ToArray();
if (conflicts.Length > 0)
{
if (conflictingIndices.Count == 0)
{
conflictingIndices.Add(mainIndex);
}
conflictingIndices.Add(secondIndex);
conflictingFiles.AddRange(conflicts);
}
}
// Resolve conflicts with this assignment
if (conflictingIndices.Count > 0)
{
// Determine which importer to prefer for this conflict
ImportInputAssignment[] conflictingAssignments = conflictingIndices.Select(i => candidateMapping[i]).ToArray();
int keepIndex = this.ResolveMappingConflict(conflictingAssignments);
// If we somehow decided that none of the options is viable, abort the operation
if (keepIndex == -1)
{
candidateMapping.Clear();
return(candidateMapping);
}
// Sort indices to remove in declining order and remove their mappings
conflictingIndices.Remove(keepIndex);
conflictingIndices.Sort((a, b) => b - a);
foreach (int index in conflictingIndices)
{
candidateMapping.RemoveAt(index);
}
// Start over with the conflict search
mainIndex = -1;
continue;
}
}
return(candidateMapping);
}
protected bool RunImporter(AssetImportEnvironment env, ImportInputAssignment assignment, IList <AssetImportOutput> outputCollection)
{
try
{
assignment.Importer.Import(env);
// Get a list on properly registered output Resources and report warnings on the rest
List <AssetImportOutput> expectedOutput = new List <AssetImportOutput>();
foreach (AssetImportOutput output in env.Output)
{
if (!assignment.ExpectedOutput.Any(item => item.Resource == output.Resource))
{
Log.Editor.WriteWarning(
"AssetImporter '{0}' created an unpredicted output Resource: '{1}'. " + Environment.NewLine +
"This may cause problems in the Asset Management system, especially during Asset re-import. " + Environment.NewLine +
"Please fix the implementation of the PrepareImport method so it properly calls AddOutput for each predicted output Resource.",
Log.Type(assignment.Importer.GetType()),
output.Resource);
}
else
{
expectedOutput.Add(output);
}
}
// Collect references to the imported Resources and save them
foreach (AssetImportOutput output in expectedOutput)
{
Resource resource = output.Resource.Res;
string sourceMediaBaseDir = AssetInternalHelper.GetSourceMediaBaseDir(resource);
string[] sourceFileHints = new string[output.InputPaths.Count];
for (int i = 0; i < sourceFileHints.Length; i++)
{
string fileName = Path.GetFileName(output.InputPaths[i]);
string directory = Path.GetDirectoryName(output.InputPaths[i]);
fileName = fileName.Replace(resource.Name, AssetInfo.FileHintNameVariable);
sourceFileHints[i] = PathHelper.MakeFilePathRelative(
Path.Combine(directory, fileName),
sourceMediaBaseDir);
}
AssetInfo assetInfo = resource.AssetInfo ?? new AssetInfo();
assetInfo.ImporterId = assignment.Importer.Id;
assetInfo.NameHint = resource.Name;
assetInfo.SourceFileHint = sourceFileHints;
resource.AssetInfo = assetInfo;
outputCollection.Add(output);
}
}
catch (Exception ex)
{
Log.Editor.WriteError("An error occurred while trying to import files using '{1}': {0}",
Log.Exception(ex),
Log.Type(assignment.Importer.GetType()));
return(false);
}
return(true);
}
