public override string GetFontPath(AssetCompilerResult result = null)
{
using (var factory = new Factory())
{
Font font;
using (var fontCollection = factory.GetSystemFontCollection(false))
{
int index;
if (!fontCollection.FindFamilyName(FontName, out index))
{
result?.Error($"Cannot find system font '{FontName}'. Make sure it is installed on this machine.");
return(null);
}
using (var fontFamily = fontCollection.GetFontFamily(index))
{
var weight = Style.IsBold() ? FontWeight.Bold : FontWeight.Regular;
var style = Style.IsItalic() ? SharpDX.DirectWrite.FontStyle.Italic : SharpDX.DirectWrite.FontStyle.Normal;
font = fontFamily.GetFirstMatchingFont(weight, FontStretch.Normal, style);
if (font == null)
{
result?.Error($"Cannot find style '{Style}' for font family {FontName}. Make sure it is installed on this machine.");
return(null);
}
}
}
var fontFace = new FontFace(font);
// get the font path on the hard drive
var file = fontFace.GetFiles().First();
var referenceKey = file.GetReferenceKey();
var originalLoader = (FontFileLoaderNative)file.Loader;
var loader = originalLoader.QueryInterface <LocalFontFileLoader>();
return(loader.GetFilePath(referenceKey));
}
}
private static string GetFontPath(SpriteFontAsset asset, AssetCompilerResult result)
{
using (var factory = new Factory())
{
Font font;
using (var fontCollection = factory.GetSystemFontCollection(false))
{
int index;
if (!fontCollection.FindFamilyName(asset.FontName, out index))
{
result.Error("Can't find font '{0}'.", asset.FontName);
return(null);
}
using (var fontFamily = fontCollection.GetFontFamily(index))
{
var weight = asset.Style.IsBold() ? FontWeight.Bold : FontWeight.Regular;
var style = asset.Style.IsItalic() ? SharpDX.DirectWrite.FontStyle.Italic : SharpDX.DirectWrite.FontStyle.Normal;
font = fontFamily.GetFirstMatchingFont(weight, FontStretch.Normal, style);
if (font == null)
{
result.Error("Cannot find style '{0}' for font family {1}.", asset.Style, asset.FontName);
return(null);
}
}
}
var fontFace = new FontFace(font);
// get the font path on the hard drive
var file = fontFace.GetFiles().First();
var referenceKey = file.GetReferenceKey();
var originalLoader = (FontFileLoaderNative)file.Loader;
var loader = originalLoader.QueryInterface <LocalFontFileLoader>();
return(loader.GetFilePath(referenceKey));
}
}
/// <summary>
/// Generates a <see cref="ListBuildStep"/> to compile the thumbnail of the given asset.
/// </summary>
/// <param name="assetItem">The asset to compile.</param>
/// <param name="gameSettings">The current game settings</param>
/// <param name="staticThumbnail">If the asset has to be compiled as well in the case of non static thumbnail</param>
/// <returns>A <see cref="ListBuildStep"/> containing the build steps to generate the thumbnail of the given asset.</returns>
public ListBuildStep Compile(AssetItem assetItem, GameSettingsAsset gameSettings, bool staticThumbnail)
{
if (assetItem == null)
{
throw new ArgumentNullException(nameof(assetItem));
}
using (var context = new ThumbnailCompilerContext
{
Platform = PlatformType.Windows
})
{
context.SetGameSettingsAsset(gameSettings);
context.CompilationContext = typeof(PreviewCompilationContext);
context.Properties.Set(ThumbnailGenerator.Key, generator);
context.ThumbnailBuilt += builtAction;
var result = new AssetCompilerResult();
if (!staticThumbnail)
{
//compile the actual asset
result = dependenciesCompiler.Prepare(context, assetItem);
}
//compile the actual thumbnail
var thumbnailStep = CompileItem(context, result, assetItem);
foreach (var buildStep in result.BuildSteps)
{
BuildStep.LinkBuildSteps(buildStep, thumbnailStep);
}
result.BuildSteps.Add(thumbnailStep);
return(result.BuildSteps);
}
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
result.BuildSteps.Add(new DummyAssetCommand <SoundAsset, Sound>(assetItem));
}
protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, SoundAsset asset, AssetCompilerResult result)
{
if (!EnsureSourcesExist(result, asset, assetAbsolutePath))
{
return;
}
result.BuildSteps = new AssetBuildStep(AssetItem)
{
new DecodeSoundFileCommand(urlInStorage, asset)
};
}
protected override void CompileThumbnail(ThumbnailCompilerContext context, string thumbnailStorageUrl, AssetItem assetItem, Package originalPackage, AssetCompilerResult result)
{
result.BuildSteps.Add(new ThumbnailBuildStep(new SpriteSheetThumbnailCommand(context, assetItem, originalPackage, thumbnailStorageUrl,
new ThumbnailCommandParameters(assetItem.Asset, thumbnailStorageUrl, context.ThumbnailResolution))));
}
/// <inheritdoc/>
public void Check(EntityComponent component, Entity entity, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var modelComponent = component as ModelComponent;
if (modelComponent.Model is null)
{
result.Warning($"The entity [{targetUrlInStorage}:{entity.Name}] has a model component that does not reference any model.");
}
else
{
var modelAttachedReference = AttachedReferenceManager.GetAttachedReference(modelComponent.Model);
var modelId = modelAttachedReference.Id;
// Compute the full path to the source asset
var modelAssetItem = assetItem.Package.Session.FindAsset(modelId);
if (modelAssetItem is null)
{
result.Error($"The entity [{targetUrlInStorage}:{entity.Name}] is referencing an unreachable model.");
}
}
}
protected override void CompileThumbnail(ThumbnailCompilerContext context, string thumbnailStorageUrl, AssetItem assetItem, Package originalPackage, AssetCompilerResult result)
{
result.BuildSteps.Add(new ThumbnailBuildStep(new HeightmapThumbnailCommand(context, assetItem, originalPackage, thumbnailStorageUrl,
new ThumbnailCommandParameters(assetItem.Asset, thumbnailStorageUrl, context.ThumbnailResolution))
{
InputFilesGetter = () => GetInputFiles(assetItem)
}));
}
protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, PrecompiledSpriteFontAsset asset, AssetCompilerResult result)
{
if (!EnsureSourceExists(result, asset, assetAbsolutePath))
{
return;
}
result.BuildSteps = new AssetBuildStep(AssetItem)
{
new PrecompiledSpriteFontCommand(urlInStorage, asset)
};
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var url = EffectCompilerBase.DefaultSourceShaderFolder + "/" + Path.GetFileName(assetItem.FullPath);
var originalSourcePath = assetItem.FullPath;
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new ImportStreamCommand {
SourcePath = originalSourcePath, Location = url, SaveSourcePath = true
});
var shaderLocations = (ConcurrentDictionary <string, string>)context.Properties.GetOrAdd(ShaderLocationsKey, key => new ConcurrentDictionary <string, string>());
// Store directly this into the context TODO this this temporary
shaderLocations[url] = originalSourcePath;
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (MaterialAsset)assetItem.Asset;
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new MaterialCompileCommand(targetUrlInStorage, assetItem, asset, context));
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (AnimationAsset)assetItem.Asset;
var assetAbsolutePath = assetItem.FullPath;
// Get absolute path of asset source on disk
var assetDirectory = assetAbsolutePath.GetParent();
var assetSource = GetAbsolutePath(assetItem, asset.Source);
var extension = assetSource.GetFileExtension();
var buildStep = new AssetBuildStep(assetItem);
// Find skeleton asset, if any
AssetItem skeleton = null;
if (asset.Skeleton != null)
{
skeleton = assetItem.Package.FindAssetFromProxyObject(asset.Skeleton);
}
var sourceBuildCommand = ImportModelCommand.Create(extension);
if (sourceBuildCommand == null)
{
result.Error($"No importer found for model extension '{extension}. The model '{assetSource}' can't be imported.");
return;
}
sourceBuildCommand.Mode = ImportModelCommand.ExportMode.Animation;
sourceBuildCommand.SourcePath = assetSource;
sourceBuildCommand.Location = targetUrlInStorage;
sourceBuildCommand.AnimationRepeatMode = asset.RepeatMode;
sourceBuildCommand.AnimationRootMotion = asset.RootMotion;
sourceBuildCommand.ImportCustomAttributes = asset.ImportCustomAttributes;
if (asset.ClipDuration.Enabled)
{
sourceBuildCommand.StartFrame = asset.ClipDuration.StartAnimationTime;
sourceBuildCommand.EndFrame = asset.ClipDuration.EndAnimationTime;
}
else
{
sourceBuildCommand.StartFrame = TimeSpan.Zero;
sourceBuildCommand.EndFrame = AnimationAsset.LongestTimeSpan;
}
sourceBuildCommand.ScaleImport = asset.ScaleImport;
sourceBuildCommand.PivotPosition = asset.PivotPosition;
if (skeleton != null)
{
sourceBuildCommand.SkeletonUrl = skeleton.Location;
// Note: skeleton override values
sourceBuildCommand.ScaleImport = ((SkeletonAsset)skeleton.Asset).ScaleImport;
sourceBuildCommand.PivotPosition = ((SkeletonAsset)skeleton.Asset).PivotPosition;
}
if (asset.Type.Type == AnimationAssetTypeEnum.AnimationClip)
{
// Import the main animation
buildStep.Add(sourceBuildCommand);
}
else if (asset.Type.Type == AnimationAssetTypeEnum.DifferenceClip)
{
var diffAnimationAsset = ((DifferenceAnimationAssetType)asset.Type);
var referenceClip = diffAnimationAsset.BaseSource;
var rebaseMode = diffAnimationAsset.Mode;
var baseUrlInStorage = targetUrlInStorage + RefClipSuffix;
var sourceUrlInStorage = targetUrlInStorage + SrcClipSuffix;
var baseAssetSource = UPath.Combine(assetDirectory, referenceClip);
var baseExtension = baseAssetSource.GetFileExtension();
sourceBuildCommand.Location = sourceUrlInStorage;
var baseBuildCommand = ImportModelCommand.Create(extension);
if (baseBuildCommand == null)
{
result.Error($"No importer found for model extension '{baseExtension}. The model '{baseAssetSource}' can't be imported.");
return;
}
baseBuildCommand.FailOnEmptyAnimation = false;
baseBuildCommand.Mode = ImportModelCommand.ExportMode.Animation;
baseBuildCommand.SourcePath = baseAssetSource;
baseBuildCommand.Location = baseUrlInStorage;
baseBuildCommand.AnimationRepeatMode = asset.RepeatMode;
baseBuildCommand.AnimationRootMotion = asset.RootMotion;
if (diffAnimationAsset.ClipDuration.Enabled)
{
baseBuildCommand.StartFrame = diffAnimationAsset.ClipDuration.StartAnimationTimeBox;
baseBuildCommand.EndFrame = diffAnimationAsset.ClipDuration.EndAnimationTimeBox;
}
else
{
baseBuildCommand.StartFrame = TimeSpan.Zero;
baseBuildCommand.EndFrame = AnimationAsset.LongestTimeSpan;
}
baseBuildCommand.ScaleImport = asset.ScaleImport;
baseBuildCommand.PivotPosition = asset.PivotPosition;
if (skeleton != null)
{
baseBuildCommand.SkeletonUrl = skeleton.Location;
// Note: skeleton override values
baseBuildCommand.ScaleImport = ((SkeletonAsset)skeleton.Asset).ScaleImport;
baseBuildCommand.PivotPosition = ((SkeletonAsset)skeleton.Asset).PivotPosition;
}
// Import base and main animation
var sourceStep = new CommandBuildStep(sourceBuildCommand);
buildStep.Add(sourceStep);
var baseStep = new CommandBuildStep(baseBuildCommand);
buildStep.Add(baseStep);
IEnumerable <ObjectUrl> InputFilesGetter()
{
yield return(new ObjectUrl(UrlType.File, GetAbsolutePath(assetItem, diffAnimationAsset.BaseSource)));
}
var diffCommand = new AdditiveAnimationCommand(targetUrlInStorage, new AdditiveAnimationParameters(baseUrlInStorage, sourceUrlInStorage, rebaseMode), assetItem.Package)
{
InputFilesGetter = InputFilesGetter
};
var diffStep = new CommandBuildStep(diffCommand);
BuildStep.LinkBuildSteps(sourceStep, diffStep);
BuildStep.LinkBuildSteps(baseStep, diffStep);
// Generate the diff of those two animations
buildStep.Add(diffStep);
}
else
{
throw new NotImplementedException("This type of animation asset is not supported yet!");
}
result.BuildSteps = buildStep;
}
protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, SkyboxAsset asset, AssetCompilerResult result)
{
result.ShouldWaitForPreviousBuilds = true;
result.BuildSteps = new AssetBuildStep(AssetItem)
{
new SkyboxCompileCommand(urlInStorage, asset, context.Package)
};
}
protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, EntityAsset asset, AssetCompilerResult result)
{
foreach (var entityData in asset.Hierarchy.Entities)
{
// TODO: How to make this code pluggable?
var modelComponent = entityData.Components.Get(ModelComponent.Key);
var spriteComponent = entityData.Components.Get(SpriteComponent.Key);
var scriptComponent = entityData.Components.Get(ScriptComponent.Key);
// determine the underlying source asset exists
if (modelComponent != null)
{
if (modelComponent.Model == null)
{
result.Warning(string.Format("The entity [{0}:{1}] has a model component that does not reference any model.", urlInStorage, entityData.Name));
continue;
}
var modelAttachedReference = AttachedReferenceManager.GetAttachedReference(modelComponent.Model);
var modelId = modelAttachedReference.Id;
// compute the full path to the source asset.
var assetItem = AssetItem.Package.Session.FindAsset(modelId);
if (assetItem == null)
{
result.Error(string.Format("The entity [{0}:{1}] is referencing an unreachable model.", urlInStorage, entityData.Name));
continue;
}
}
if (spriteComponent != null && spriteComponent.SpriteProvider == null)
{
result.Warning(string.Format("The entity [{0}:{1}] has a sprite component that does not reference any sprite group.", urlInStorage, entityData.Name));
}
if (scriptComponent != null)
{
foreach (var script in scriptComponent.Scripts)
{
if (script is UnloadableScript)
{
result.Error(string.Format("The entity [{0}:{1}] reference an invalid script '{2}'.", urlInStorage, entityData.Name, script.GetType().Name));
}
}
}
}
result.BuildSteps = new AssetBuildStep(AssetItem)
{
new EntityCombineCommand(urlInStorage, AssetItem.Package, context, asset)
};
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (ModelAsset)assetItem.Asset;
// Get absolute path of asset source on disk
var assetDirectory = assetItem.FullPath.GetParent();
var assetSource = UPath.Combine(assetDirectory, asset.Source);
var gameSettingsAsset = context.GetGameSettingsAsset();
var renderingSettings = gameSettingsAsset.GetOrCreate <RenderingSettings>();
var allow32BitIndex = renderingSettings.DefaultGraphicsProfile >= GraphicsProfile.Level_9_2;
var maxInputSlots = renderingSettings.DefaultGraphicsProfile >= GraphicsProfile.Level_10_1 ? 32 : 16;
var allowUnsignedBlendIndices = true; //context.GetGraphicsPlatform(assetItem.Package) != GraphicsPlatform.OpenGLES;
var extension = asset.Source.GetFileExtension();
// Find skeleton asset, if any
AssetItem skeleton = null;
if (asset.Skeleton != null)
{
skeleton = assetItem.Package.FindAssetFromProxyObject(asset.Skeleton);
}
var importModelCommand = ImportModelCommand.Create(extension);
if (importModelCommand == null)
{
result.Error($"No importer found for model extension '{extension}. The model '{assetSource}' can't be imported.");
return;
}
importModelCommand.InputFilesGetter = () => GetInputFiles(assetItem);
importModelCommand.Mode = ImportModelCommand.ExportMode.Model;
importModelCommand.SourcePath = assetSource;
importModelCommand.Location = targetUrlInStorage;
importModelCommand.Allow32BitIndex = allow32BitIndex;
importModelCommand.MaxInputSlots = maxInputSlots;
importModelCommand.AllowUnsignedBlendIndices = allowUnsignedBlendIndices;
importModelCommand.Materials = asset.Materials;
importModelCommand.ScaleImport = asset.ScaleImport;
importModelCommand.PivotPosition = asset.PivotPosition;
importModelCommand.MergeMeshes = asset.MergeMeshes;
importModelCommand.DeduplicateMaterials = asset.DeduplicateMaterials;
importModelCommand.ModelModifiers = asset.Modifiers;
if (skeleton != null)
{
importModelCommand.SkeletonUrl = skeleton.Location;
// Note: skeleton override values
importModelCommand.ScaleImport = ((SkeletonAsset)skeleton.Asset).ScaleImport;
importModelCommand.PivotPosition = ((SkeletonAsset)skeleton.Asset).PivotPosition;
}
importModelCommand.Package = assetItem.Package;
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(importModelCommand);
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (SkyboxAsset)assetItem.Asset;
var colorSpace = context.GetColorSpace();
result.BuildSteps = new AssetBuildStep(assetItem);
var prereqs = new Queue <BuildStep>();
// build the textures for windows (needed for skybox compilation)
foreach (var dependency in asset.GetDependencies())
{
var dependencyItem = assetItem.Package.Assets.Find(dependency.Id);
if (dependencyItem?.Asset is TextureAsset)
{
var textureAsset = (TextureAsset)dependencyItem.Asset;
// Get absolute path of asset source on disk
var assetSource = GetAbsolutePath(dependencyItem, textureAsset.Source);
// Create a synthetic url
var textureUrl = SkyboxGenerator.BuildTextureForSkyboxGenerationLocation(dependencyItem.Location);
var gameSettingsAsset = context.GetGameSettingsAsset();
var renderingSettings = gameSettingsAsset.GetOrCreate <RenderingSettings>(context.Platform);
// Select the best graphics profile
var graphicsProfile = renderingSettings.DefaultGraphicsProfile >= GraphicsProfile.Level_10_0 ? renderingSettings.DefaultGraphicsProfile : GraphicsProfile.Level_10_0;
var textureAssetItem = new AssetItem(textureUrl, textureAsset);
// Create and add the texture command.
var textureParameters = new TextureConvertParameters(assetSource, textureAsset, PlatformType.Windows, GraphicsPlatform.Direct3D11, graphicsProfile, gameSettingsAsset.GetOrCreate <TextureSettings>().TextureQuality, colorSpace);
var prereqStep = new AssetBuildStep(textureAssetItem);
prereqStep.Add(new TextureAssetCompiler.TextureConvertCommand(textureUrl, textureParameters, assetItem.Package));
result.BuildSteps.Add(prereqStep);
prereqs.Enqueue(prereqStep);
}
}
// add the skybox command itself.
IEnumerable <ObjectUrl> InputFilesGetter()
{
var skyboxAsset = (SkyboxAsset)assetItem.Asset;
foreach (var dependency in skyboxAsset.GetDependencies())
{
var dependencyItem = assetItem.Package.Assets.Find(dependency.Id);
if (dependencyItem?.Asset is TextureAsset)
{
yield return(new ObjectUrl(UrlType.Content, dependency.Location));
}
}
}
var assetStep = new CommandBuildStep(new SkyboxCompileCommand(targetUrlInStorage, asset, assetItem.Package)
{
InputFilesGetter = InputFilesGetter
});
result.BuildSteps.Add(assetStep);
while (prereqs.Count > 0)
{
var prereq = prereqs.Dequeue();
BuildStep.LinkBuildSteps(prereq, assetStep);
}
}
public CompileDefaultSceneEffectCommand(AssetCompilerContext context, Package package, AssetCompilerResult compilerResult)
{
this.context = context;
this.package = package;
this.compilerResult = compilerResult;
}
protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, ColliderShapeAsset asset, AssetCompilerResult result)
{
result.BuildSteps = new AssetBuildStep(AssetItem)
{
new ColliderShapeCombineCommand(urlInStorage, asset, context.Package),
};
result.ShouldWaitForPreviousBuilds = asset.ColliderShapes.Any(shape => shape != null && shape.GetType() == typeof(ConvexHullColliderShapeDesc));
}
protected override void CompileThumbnail(ThumbnailCompilerContext context, string thumbnailStorageUrl, AssetItem assetItem, Package originalPackage, AssetCompilerResult result)
{
UFile fontPathOnDisk = Asset.FontSource.GetFontPath();
bool sourceIsValid = (fontPathOnDisk != null && File.Exists(fontPathOnDisk));
if (sourceIsValid)
{
result.BuildSteps.Add(new ThumbnailBuildStep(new FontThumbnailBuildCommand(context, thumbnailStorageUrl, assetItem, originalPackage,
new ThumbnailCommandParameters(assetItem.Asset, thumbnailStorageUrl, context.ThumbnailResolution))));
}
else
{
var thumbnailSize = context.ThumbnailResolution;
var isLinear = context.GetGameSettingsAsset().GetOrCreate <RenderingSettings>().ColorSpace == ColorSpace.Linear;
result.Error($"Source is null or unreachable for Texture Asset [{Asset}]");
result.BuildSteps.Add(new StaticThumbnailCommand <SpriteFontAsset>(thumbnailStorageUrl, DefaultThumbnails.AssetBrokenThumbnail, thumbnailSize, isLinear, assetItem.Package));
}
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (NavigationMeshAsset)assetItem.Asset;
// Compile the navigation mesh itself
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new NavmeshBuildCommand(targetUrlInStorage, assetItem, asset, context)
{
InputFilesGetter = () => GetInputFiles(assetItem)
});
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (SpriteSheetAsset)assetItem.Asset;
var gameSettingsAsset = context.GetGameSettingsAsset();
var renderingSettings = gameSettingsAsset.GetOrCreate <RenderingSettings>(context.Platform);
result.BuildSteps = new ListBuildStep();
var prereqSteps = new Queue <BuildStep>();
// create the registry containing the sprite assets texture index association
var imageToTextureUrl = new Dictionary <SpriteInfo, string>();
var colorSpace = context.GetColorSpace();
// create and add import texture commands
if (asset.Sprites != null && !asset.Packing.Enabled)
{
// sort sprites by referenced texture.
var spriteByTextures = asset.Sprites.GroupBy(x => x.Source).ToArray();
for (int i = 0; i < spriteByTextures.Length; i++)
{
// skip the texture if the file is not valid.
var textureFile = spriteByTextures[i].Key;
if (!TextureFileIsValid(textureFile))
{
continue;
}
var textureUrl = SpriteSheetAsset.BuildTextureUrl(assetItem.Location, i);
var spriteAssetArray = spriteByTextures[i].ToArray();
foreach (var spriteAsset in spriteAssetArray)
{
imageToTextureUrl[spriteAsset] = textureUrl;
}
// create an texture asset.
var textureAsset = new TextureAsset
{
Id = AssetId.Empty, // CAUTION: It is important to use an empty GUID here, as we don't want the command to be rebuilt (by default, a new asset is creating a new guid)
IsStreamable = asset.IsStreamable && asset.Type != SpriteSheetType.UI,
IsCompressed = asset.IsCompressed,
GenerateMipmaps = asset.GenerateMipmaps,
Type = new ColorTextureType
{
Alpha = asset.Alpha,
PremultiplyAlpha = asset.PremultiplyAlpha,
ColorKeyColor = asset.ColorKeyColor,
ColorKeyEnabled = asset.ColorKeyEnabled,
UseSRgbSampling = true,
}
};
// Get absolute path of asset source on disk
var assetDirectory = assetItem.FullPath.GetParent();
var assetSource = UPath.Combine(assetDirectory, spriteAssetArray[0].Source);
// add the texture build command.
var textureConvertParameters = new TextureConvertParameters(assetSource, textureAsset, context.Platform, context.GetGraphicsPlatform(assetItem.Package), renderingSettings.DefaultGraphicsProfile, gameSettingsAsset.GetOrCreate <TextureSettings>().TextureQuality, colorSpace);
var textureConvertCommand = new TextureAssetCompiler.TextureConvertCommand(textureUrl, textureConvertParameters, assetItem.Package);
var assetBuildStep = new AssetBuildStep(new AssetItem(textureUrl, textureAsset));
assetBuildStep.Add(textureConvertCommand);
prereqSteps.Enqueue(assetBuildStep);
result.BuildSteps.Add(assetBuildStep);
}
}
if (!result.HasErrors)
{
var parameters = new SpriteSheetParameters(asset, imageToTextureUrl, context.Platform, context.GetGraphicsPlatform(assetItem.Package), renderingSettings.DefaultGraphicsProfile, gameSettingsAsset.GetOrCreate <TextureSettings>().TextureQuality, colorSpace);
var assetBuildStep = new AssetBuildStep(assetItem);
assetBuildStep.Add(new SpriteSheetCommand(targetUrlInStorage, parameters, assetItem.Package));
result.BuildSteps.Add(assetBuildStep);
while (prereqSteps.Count > 0)
{
var prereq = prereqSteps.Dequeue();
BuildStep.LinkBuildSteps(prereq, assetBuildStep);
}
}
}
protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, EffectLogAsset asset, AssetCompilerResult result)
{
var originalSourcePath = asset.AbsoluteSourceLocation;
result.ShouldWaitForPreviousBuilds = true;
result.BuildSteps = new AssetBuildStep(AssetItem)
{
new EffectLogBuildStep(context, originalSourcePath, AssetItem.Package)
};
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var originalSourcePath = assetItem.FullPath;
result.BuildSteps = new AssetBuildStep(assetItem);
var urlRoot = originalSourcePath.GetParent();
var stream = new MemoryStream(Encoding.UTF8.GetBytes(((EffectLogAsset)assetItem.Asset).Text));
using (var recordedEffectCompile = new EffectLogStore(stream))
{
recordedEffectCompile.LoadNewValues();
foreach (var entry in recordedEffectCompile.GetValues())
{
result.BuildSteps.Add(EffectCompileCommand.FromRequest(context, assetItem.Package, urlRoot, entry.Key));
}
}
}
protected override void CompileThumbnail(ThumbnailCompilerContext context, string thumbnailStorageUrl, AssetItem assetItem, Package originalPackage, AssetCompilerResult result)
{
// A model asset should have been generated during CompileWithDependencies()
var modelAssetItem = AnimationPreviewViewModel.FindModelForPreview(assetItem);
if (modelAssetItem != null)
{
result.BuildSteps.Add(new ThumbnailBuildStep(new AnimationThumbnailBuildCommand(context, thumbnailStorageUrl, assetItem, modelAssetItem, originalPackage,
new ThumbnailCommandParameters(assetItem.Asset, thumbnailStorageUrl, context.ThumbnailResolution))));
}
else
{
// If no model could be found, uses default thumbnail instead
var gameSettings = context.GetGameSettingsAsset();
result.BuildSteps.Add(new StaticThumbnailCommand <AnimationAsset>(thumbnailStorageUrl, StaticThumbnails.AnimationThumbnail, context.ThumbnailResolution, gameSettings.GetOrCreate <RenderingSettings>().ColorSpace == ColorSpace.Linear, assetItem.Package));
}
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (SoundAsset)assetItem.Asset;
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new DecodeSoundFileCommand(targetUrlInStorage, asset, assetItem.Package));
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (GameSettingsAsset)assetItem.Asset;
// TODO: We should ignore game settings stored in dependencies
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new GameSettingsCompileCommand(targetUrlInStorage, assetItem.Package, context.Platform, context.GetCompilationMode(), asset));
}
protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, TextureAsset asset, AssetCompilerResult result)
{
if (asset.Source == null)
{
result.Error("Source cannot be null for Texture Asset [{0}]", asset);
return;
}
// Get absolute path of asset source on disk
var assetDirectory = assetAbsolutePath.GetParent();
var assetSource = UPath.Combine(assetDirectory, asset.Source);
result.BuildSteps = new ListBuildStep {
new TextureConvertCommand(urlInStorage,
new TextureConvertParameters(assetSource, asset, context.Platform, context.GetGraphicsPlatform(), context.GetGraphicsProfile(), context.GetTextureQuality(), false))
};
}
protected sealed override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (T)assetItem.Asset;
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(Create(targetUrlInStorage, asset, assetItem.Package));
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (PrefabModelAsset)assetItem.Asset;
var renderingSettings = context.GetGameSettingsAsset().GetOrCreate <RenderingSettings>();
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new PrefabModelAssetCompileCommand(targetUrlInStorage, asset, assetItem, renderingSettings));
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (SpriteFontAsset)assetItem.Asset;
UFile assetAbsolutePath = assetItem.FullPath;
var colorSpace = context.GetColorSpace();
var fontTypeSdf = asset.FontType as SignedDistanceFieldSpriteFontType;
if (fontTypeSdf != null)
{
// copy the asset and transform the source and character set file path to absolute paths
var assetClone = AssetCloner.Clone(asset);
var assetDirectory = assetAbsolutePath.GetParent();
assetClone.FontSource = asset.FontSource;
fontTypeSdf.CharacterSet = !string.IsNullOrEmpty(fontTypeSdf.CharacterSet) ? UPath.Combine(assetDirectory, fontTypeSdf.CharacterSet) : null;
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new SignedDistanceFieldFontCommand(targetUrlInStorage, assetClone, assetItem.Package));
}
else
if (asset.FontType is RuntimeRasterizedSpriteFontType)
{
UFile fontPathOnDisk = asset.FontSource.GetFontPath(result);
if (fontPathOnDisk == null)
{
result.Error($"Runtime rasterized font compilation failed. Font {asset.FontSource.GetFontName()} was not found on this machine.");
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new FailedFontCommand());
return;
}
var fontImportLocation = FontHelper.GetFontPath(asset.FontSource.GetFontName(), asset.FontSource.Style);
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new ImportStreamCommand {
SourcePath = fontPathOnDisk, Location = fontImportLocation
});
result.BuildSteps.Add(new RuntimeRasterizedFontCommand(targetUrlInStorage, asset, assetItem.Package));
}
else
{
var fontTypeStatic = asset.FontType as OfflineRasterizedSpriteFontType;
if (fontTypeStatic == null)
{
throw new ArgumentException("Tried to compile a non-offline rasterized sprite font with the compiler for offline resterized fonts!");
}
// copy the asset and transform the source and character set file path to absolute paths
var assetClone = AssetCloner.Clone(asset);
var assetDirectory = assetAbsolutePath.GetParent();
assetClone.FontSource = asset.FontSource;
fontTypeStatic.CharacterSet = !string.IsNullOrEmpty(fontTypeStatic.CharacterSet) ? UPath.Combine(assetDirectory, fontTypeStatic.CharacterSet): null;
result.BuildSteps = new AssetBuildStep(assetItem);
result.BuildSteps.Add(new OfflineRasterizedFontCommand(targetUrlInStorage, assetClone, colorSpace, assetItem.Package));
}
}
