public void PrepareImport(IAssetImportEnvironment env)
{
// Ask to handle all input that matches the conditions in AcceptsInput
foreach (AssetImportInput input in env.HandleAllInput(this.AcceptsInput))
{
// For all handled input items, specify which Resource the importer intends to create / modify
string ext = Path.GetExtension(input.Path);
if (string.Equals(ext, SourceFileExtVertex, StringComparison.InvariantCultureIgnoreCase))
env.AddOutput<VertexShader>(input.AssetName, input.Path);
else
env.AddOutput<FragmentShader>(input.AssetName, input.Path);
}
}
public void PrepareImport(IAssetImportEnvironment env)
{
// File all fnt files with allocated png files
var importFiles = from file in env.HandleAllInput(f => Path.GetExtension(f.Path).ToLower() == ".fnt" || Path.GetExtension(f.Path).ToLower() == ".xml")
select file;
foreach (var input in importFiles)
{
var fileFormat = FigureOutFontFileFormat(input.Path);
switch (fileFormat)
{
case FontFileFormat.None:
{
// Not a file format we support, ignore
continue;
}
case FontFileFormat.BMFont:
{
var fontData = LoadBMFontData(input.Path);
if (fontData.Pages.Count() > 1)
{
Log.Editor.WriteError("Only single page bitmap font files are allowed");
continue; //skip this file
}
env.AddOutput <Duality.Resources.Font>(input.AssetName, input.Path);
foreach (var page in fontData.Pages)
{
var fullPath = Path.Combine(Path.GetDirectoryName(input.Path), page.File);
if (File.Exists(fullPath))
{
env.AddOutput <Pixmap>(input.AssetName, fullPath);
}
else
{
Log.Editor.WriteError("Corresponding bitmap font page file '{0}' not found ", fullPath);
continue; //skip this file
}
}
break;
}
}
}
}
public void Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
string ext = Path.GetExtension(input.Path);
// Request a target Resource with a name matching the input
IContentRef targetRef;
if (string.Equals(ext, SourceFileExtVertex, StringComparison.InvariantCultureIgnoreCase))
{
targetRef = env.GetOutput <VertexShader>(input.AssetName);
}
else
{
targetRef = env.GetOutput <FragmentShader>(input.AssetName);
}
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
AbstractShader target = targetRef.Res as AbstractShader;
// Update shader data from the input file
target.Source = File.ReadAllText(input.Path);
target.Compile();
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
public void Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
string ext = Path.GetExtension(input.Path);
// Request a target Resource with a name matching the input
IContentRef targetRef;
if (string.Equals(ext, SourceFileExtVertex, StringComparison.InvariantCultureIgnoreCase))
targetRef = env.GetOutput<VertexShader>(input.AssetName);
else
targetRef = env.GetOutput<FragmentShader>(input.AssetName);
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
AbstractShader target = targetRef.Res as AbstractShader;
// Update shader data from the input file
target.Source = File.ReadAllText(input.Path);
target.Compile();
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
public void PrepareImport(IAssetImportEnvironment env)
{
foreach (AssetImportInput input in env.HandleAllInput(AcceptsInput))
{
env.AddOutput <PythonScript>(input.AssetName, input.Path);
}
}
public void PrepareImport(IAssetImportEnvironment env)
{
// Ask to handle all input that matches the conditions in AcceptsInput
foreach (AssetImportInput input in env.HandleAllInput(this.AcceptsInput))
{
// For all handled input items, specify which Resource the importer intends to create / modify
string ext = Path.GetExtension(input.Path);
if (string.Equals(ext, SourceFileExtVertex, StringComparison.InvariantCultureIgnoreCase))
{
env.AddOutput <VertexShader>(input.AssetName, input.Path);
}
else
{
env.AddOutput <FragmentShader>(input.AssetName, input.Path);
}
}
}
public void PrepareImport(IAssetImportEnvironment env)
{
// Ask to handle all input that matches the conditions in AcceptsInput
foreach (AssetImportInput input in env.HandleAllInput(this.AcceptsInput))
{
// For all handled input items, specify which Resource the importer intends to create / modify
env.AddOutput <DualityFont>(input.AssetName, input.Path);
}
}
public void PrepareImport(IAssetImportEnvironment env)
{
// Ask to handle all input that matches the conditions in AcceptsInput
foreach (AssetImportInput input in env.HandleAllInput(this.AcceptsInput))
{
// For all handled input items, specify which Resource the importer intends to create / modify
env.AddOutput<Pixmap>(input.AssetName, input.Path);
}
}
public void PrepareImport(IAssetImportEnvironment env)
{
// Ask to handle all input that matches the conditions in AcceptsInput
foreach (AssetImportInput input in env.HandleAllInput(this.AcceptsInput))
{
// For all handled input items, specify which Resource the importer intends to create / modify
env.AddOutput <PlainTextData>(input.AssetName, input.Path);
global::Duality.Log.Editor.WriteWarning("");
}
}
public void Import(IAssetImportEnvironment env)
{
foreach (AssetImportInput input in env.Input)
{
ContentRef <PythonScript> targetRef = env.GetOutput <PythonScript>(input.AssetName);
if (targetRef.IsAvailable)
{
PythonScript target = targetRef.Res;
string fileData = File.ReadAllText(input.Path);
target.UpdateContent(fileData);
env.AddOutput(targetRef, input.Path);
}
}
}
public void Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
// Request a target Resource with a name matching the input
ContentRef <DualityFont> targetRef = env.GetOutput <DualityFont>(input.AssetName);
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
DualityFont target = targetRef.Res;
// Retrieve import parameters
float size = env.GetOrInitParameter(targetRef, "Size", 16.0f);
FontStyle style = env.GetOrInitParameter(targetRef, "Style", FontStyle.Regular);
string extendedCharSet = env.GetOrInitParameter(targetRef, "ExtendedCharSet", string.Empty);
bool antialiasing = env.GetOrInitParameter(targetRef, "AntiAlias", true);
bool monospace = env.GetOrInitParameter(targetRef, "Monospace", false);
// Load the TrueType Font and render all the required glyphs
byte[] trueTypeData = File.ReadAllBytes(input.Path);
RenderedFontData fontData = this.RenderGlyphs(
trueTypeData,
size,
style,
!string.IsNullOrEmpty(extendedCharSet) ? new FontCharSet(extendedCharSet) : null,
antialiasing,
monospace);
// Transfer our rendered Font data to the Font Resource
target.SetGlyphData(
fontData.Bitmap,
fontData.Atlas,
fontData.GlyphData,
fontData.Metrics);
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
public void Import(IAssetImportEnvironment env)
{
foreach (AssetImportInput input in env.Input)
{
// Request a target Resource with a name matching the input
ContentRef <Duality.Resources.Font> targetRef = env.GetOutput <Duality.Resources.Font>(input.AssetName);
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
Duality.Resources.Font target = targetRef.Res;
var fileFormat = FigureOutFontFileFormat(input.Path);
switch (fileFormat)
{
case FontFileFormat.BMFont:
{
var fontData = LoadBMFontData(input.Path);
var textureData = LoadPixelData(fontData, Path.GetFullPath(Path.GetDirectoryName(input.Path)));
target.SetGlyphData(textureData,
fontData.Atlas.ToArray(),
fontData.Glyps.ToArray(),
fontData.Height,
fontData.Ascent,
fontData.BodyAscent,
fontData.Descent,
fontData.Baseline);
target.Size = fontData.Size;
//target.Kerning = true;
env.AddOutput(targetRef, input.Path);
break;
}
}
}
}
}
void IAssetImporter.Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
// Request a target Resource with a name matching the input
ContentRef <T> targetRef = env.GetOutput <T>(this.GetResourceNameFromInput(input));
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
this.ImportResource(targetRef, input, env);
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
internal static void Import <T>(IAssetImportEnvironment env) where T : TextFile, new()
{
foreach (AssetImportInput input in env.Input)
{
ContentRef <T> targetRef = env.GetOutput <T>(input.AssetName);
if (targetRef.IsAvailable)
{
T target = targetRef.Res;
if (!String.IsNullOrWhiteSpace(input.Path))
{
using (System.IO.StreamReader sr = new StreamReader(input.Path))
{
string content = sr.ReadToEnd();
target.SetData(content, sr.CurrentEncoding.GetByteCount(content), sr.CurrentEncoding);
}
}
env.AddOutput(targetRef, input.Path);
}
}
}
public void Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
// Request a target Resource with a name matching the input
ContentRef <AudioData> targetRef = env.GetOutput <AudioData>(input.AssetName);
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
AudioData target = targetRef.Res;
// Update audio data from the input file
target.OggVorbisData = File.ReadAllBytes(input.Path);
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
public void Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
// Request a target Resource with a name matching the input
ContentRef<AudioData> targetRef = env.GetOutput<AudioData>(input.AssetName);
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
AudioData target = targetRef.Res;
// Update audio data from the input file
target.OggVorbisData = File.ReadAllBytes(input.Path);
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
public void Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
// Request a target Resource with a name matching the input
ContentRef<DualityFont> targetRef = env.GetOutput<DualityFont>(input.AssetName);
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
DualityFont target = targetRef.Res;
// Retrieve import parameters
float size = env.GetOrInitParameter(targetRef, "Size" , 16.0f );
FontStyle style = env.GetOrInitParameter(targetRef, "Style" , FontStyle.Regular);
string extendedCharSet = env.GetOrInitParameter(targetRef, "ExtendedCharSet", string.Empty );
bool antialiasing = env.GetOrInitParameter(targetRef, "AntiAlias" , true );
bool monospace = env.GetOrInitParameter(targetRef, "Monospace" , false );
// Load the TrueType Font and render all the required glyphs
byte[] trueTypeData = File.ReadAllBytes(input.Path);
RenderedFontData fontData = this.RenderGlyphs(
trueTypeData,
size,
style,
!string.IsNullOrEmpty(extendedCharSet) ? new FontCharSet(extendedCharSet) : null,
antialiasing,
monospace);
// Transfer our rendered Font data to the Font Resource
target.SetGlyphData(
fontData.Bitmap,
fontData.Atlas,
fontData.GlyphData,
fontData.Metrics);
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
/// <summary>
/// Submits the specified <see cref="Duality.Resource"/> as a generated output of the current importer.
/// </summary>
/// <param name="resource">A reference to the generated output <see cref="Duality.Resource"/>.</param>
/// <param name="inputPath">The input path that is used to generate this output <see cref="Duality.Resource"/>.</param>
public static void AddOutput(this IAssetImportEnvironment env, IContentRef resource, string inputPath)
{
env.AddOutput(resource, new string[] { inputPath });
}
public void Import(IAssetImportEnvironment env)
{
// Handle all available input. No need to filter or ask for this anymore, as
// the preparation step already made a selection with AcceptsInput. We won't
// get any input here that didn't match.
foreach (AssetImportInput input in env.Input)
{
// Request a target Resource with a name matching the input
ContentRef <DualityFont> targetRef = env.GetOutput <DualityFont>(input.AssetName);
// If we successfully acquired one, proceed with the import
if (targetRef.IsAvailable)
{
DualityFont target = targetRef.Res;
// Retrieve import parameters
float size = env.GetOrInitParameter(targetRef, "Size", 16.0f);
FontStyle style = env.GetOrInitParameter(targetRef, "Style", FontStyle.Regular);
string customCharSet = env.GetOrInitParameter(targetRef, "CustomCharSet", string.Empty);
List <UnicodeBlock> unicodeBlocks = env.GetOrInitParameter(targetRef, "UnicodeBlocks", new List <UnicodeBlock>(DefaultBlocks));
bool antialiasing = env.GetOrInitParameter(targetRef, "AntiAlias", true);
bool monospace = env.GetOrInitParameter(targetRef, "Monospace", false);
HashSet <char> fullCharSet = new HashSet <char>();
if (!string.IsNullOrWhiteSpace(customCharSet))
{
string[] blocks = customCharSet.Split(',');
ulong start = 0;
ulong end = 0;
foreach (string block in blocks)
{
string[] limits = block.Split(new[] { '-' }, 3);
if (!ulong.TryParse(limits[0], NumberStyles.HexNumber, null, out start))
{
Log.Editor.WriteError("Cannot parse value " + limits[0] + "; CustomCharSet will be ignored. Please verify the value and repeat the import.");
}
if (limits.Length == 1)
{
end = start;
}
else
{
if (limits.Length == 2 && !ulong.TryParse(limits[1], NumberStyles.HexNumber, null, out end))
{
Log.Editor.WriteError("Cannot parse value " + limits[1] + "; CustomCharSet will be ignored. Please verify the value and repeat the import.");
}
else if (limits.Length > 2)
{
Log.Editor.WriteError("Unexpected values " + limits[2] + " in range " + block + " will be ignored. Please verify the value and repeat the import.");
}
if (start > end)
{
Log.Editor.WriteWarning(start + " is bigger than " + end + "; block will be ignored. Please verify the value and repeat the import.");
}
}
for (char c = (char)start; c <= (char)end; c++)
{
if (!char.IsControl(c))
{
fullCharSet.Add(c);
}
}
}
}
if (unicodeBlocks != null)
{
Type unicodeBlockType = typeof(UnicodeBlock);
Type unicodeRangeAttrType = typeof(UnicodeRangeAttribute);
foreach (UnicodeBlock block in unicodeBlocks)
{
UnicodeRangeAttribute range = unicodeBlockType.GetMember(block.ToString())
.First()
.GetCustomAttributes(unicodeRangeAttrType, false)
.FirstOrDefault() as UnicodeRangeAttribute;
if (range != null)
{
for (char c = (char)range.CharStart; c <= (char)range.CharEnd; c++)
{
if (!char.IsControl(c))
{
fullCharSet.Add(c);
}
}
}
}
}
// Load the TrueType Font and render all the required glyphs
byte[] trueTypeData = File.ReadAllBytes(input.Path);
RenderedFontData fontData = this.RenderGlyphs(
trueTypeData,
size,
style,
new FontCharSet(new string(fullCharSet.ToArray())),
antialiasing,
monospace);
// Transfer our rendered Font data to the Font Resource
target.SetGlyphData(
fontData.Bitmap,
fontData.Atlas,
fontData.GlyphData,
fontData.Metrics);
// Add the requested output to signal that we've done something with it
env.AddOutput(targetRef, input.Path);
}
}
}
/// <summary>
/// Specifies that the current importer will create or modify a <see cref="Duality.Resource"/> with
/// the specified name (see <see cref="Duality.Editor.AssetManagement.AssetImportInput.AssetName"/>).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="assetName">The name of the generated output <see cref="Duality.Resource"/> (see <see cref="Duality.Editor.AssetManagement.AssetImportInput.AssetName"/>).</param>
/// <param name="inputPath">The input path that is used to generate this output <see cref="Duality.Resource"/>.</param>
public static void AddOutput <T>(this IAssetImportEnvironment env, string assetName, string inputPath) where T : Resource
{
env.AddOutput <T>(assetName, new string[] { inputPath });
}