protected override void Compile(AssetCompilerContext context, string urlInStorage, UFile assetAbsolutePath, SkyboxAsset asset, AssetCompilerResult result)
{
result.BuildSteps = new AssetBuildStep(AssetItem);
result.ShouldWaitForPreviousBuilds = true;
// build the textures for windows (needed for skybox compilation)
foreach (var dependency in asset.Model.GetDependencies())
{
var assetItem = context.Package.Assets.Find(dependency.Id);
if (assetItem != null && assetItem.Asset is TextureAsset)
{
var textureAsset = (TextureAsset)assetItem.Asset;
// Get absolute path of asset source on disk
var assetSource = GetAbsolutePath(assetItem.Location.GetDirectoryAndFileName(), textureAsset.Source);
// Create a synthetic url
var textureUrl = SkyboxGenerator.BuildTextureForSkyboxGenerationLocation(assetItem.Location);
var gameSettingsAsset = context.GetGameSettingsAsset();
// Create and add the texture command.
var textureParameters = new TextureConvertParameters(assetSource, textureAsset, PlatformType.Windows, GraphicsPlatform.Direct3D11, GraphicsProfile.Level_10_0, gameSettingsAsset.TextureQuality);
result.BuildSteps.Add(new AssetBuildStep(AssetItem)
{
new TextureAssetCompiler.TextureConvertCommand(textureUrl, textureParameters)
});
}
}
// add the skybox command itself.
result.BuildSteps.Add(new WaitBuildStep());
result.BuildSteps.Add(new SkyboxCompileCommand(urlInStorage, asset));
}
protected override void Prepare(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (SpriteStudioModelAsset)assetItem.Asset;
var gameSettingsAsset = context.GetGameSettingsAsset();
var renderingSettings = gameSettingsAsset.GetOrCreate <RenderingSettings>(context.Platform);
var colorSpace = renderingSettings.ColorSpace;
var cells = new List <SpriteStudioCell>();
var images = new List <UFile>();
if (!SpriteStudioXmlImport.ParseCellMaps(asset.Source, images, cells))
{
throw new Exception("Failed to parse SpriteStudio cell textures.");
}
var texIndex = 0;
asset.BuildTextures.Clear();
foreach (var texture in images)
{
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 = false,
IsCompressed = false,
GenerateMipmaps = true,
Type = new ColorTextureType
{
Alpha = AlphaFormat.Auto,
PremultiplyAlpha = true,
UseSRgbSampling = true,
}
};
var textureConvertParameters = new TextureConvertParameters(texture, textureAsset, context.Platform, context.GetGraphicsPlatform(assetItem.Package), renderingSettings.DefaultGraphicsProfile, gameSettingsAsset.GetOrCreate <TextureSettings>().TextureQuality, colorSpace);
var textureConvertCommand = new TextureAssetCompiler.TextureConvertCommand(targetUrlInStorage + texIndex, textureConvertParameters, assetItem.Package);
result.BuildSteps.Add(textureConvertCommand);
asset.BuildTextures.Add(targetUrlInStorage + texIndex);
texIndex++;
}
var step = new AssetBuildStep(assetItem);
step.Add(new SpriteStudioModelAssetCommand(targetUrlInStorage, asset, colorSpace, assetItem.Package));
result.BuildSteps.Add(step);
}
protected override void Compile(AssetCompilerContext context, AssetItem assetItem, string targetUrlInStorage, AssetCompilerResult result)
{
var asset = (SkyboxAsset)assetItem.Asset;
result.BuildSteps = new ListBuildStep();
result.ShouldWaitForPreviousBuilds = true;
var colorSpace = context.GetColorSpace();
// build the textures for windows (needed for skybox compilation)
foreach (var dependency in asset.Model.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.Get <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.Get <TextureSettings>().TextureQuality, colorSpace);
result.BuildSteps.Add(new AssetBuildStep(textureAssetItem)
{
new TextureAssetCompiler.TextureConvertCommand(textureUrl, textureParameters)
});
}
}
// add the skybox command itself.
result.BuildSteps.Add(new AssetBuildStep(assetItem)
{
new SkyboxCompileCommand(targetUrlInStorage, asset)
});
}
public ImportParameters(TextureConvertParameters textureParameters)
{
var asset = textureParameters.Texture;
IsSRgb = asset.SRgb;
DesiredSize = new Size2((int)asset.Width, (int)asset.Height);
IsSizeInPercentage = asset.IsSizeInPercentage;
DesiredFormat = asset.Format;
DesiredAlpha = asset.Alpha;
TextureHint = asset.Hint;
GenerateMipmaps = asset.GenerateMipmaps;
PremultiplyAlpha = asset.PremultiplyAlpha;
ColorKeyColor = asset.ColorKeyColor;
ColorKeyEnabled = asset.ColorKeyEnabled;
TextureQuality = textureParameters.TextureQuality;
GraphicsPlatform = textureParameters.GraphicsPlatform;
GraphicsProfile = textureParameters.GraphicsProfile;
Platform = textureParameters.Platform;
}
public ImportParameters(TextureConvertParameters textureParameters)
{
var asset = textureParameters.Texture;
// Compute SRgb usage
// If Texture is in auto mode, use the global settings, else use the settings overridden by the texture asset.
IsSRgb = textureParameters.Texture.ColorSpace.ToColorSpace(textureParameters.ColorSpace, asset.Hint) == ColorSpace.Linear;
DesiredSize = new Size2((int)asset.Width, (int)asset.Height);
IsSizeInPercentage = asset.IsSizeInPercentage;
DesiredFormat = asset.Format;
DesiredAlpha = asset.Alpha;
TextureHint = asset.Hint;
GenerateMipmaps = asset.GenerateMipmaps;
PremultiplyAlpha = asset.PremultiplyAlpha;
ColorKeyColor = asset.ColorKeyColor;
ColorKeyEnabled = asset.ColorKeyEnabled;
TextureQuality = textureParameters.TextureQuality;
GraphicsPlatform = textureParameters.GraphicsPlatform;
GraphicsProfile = textureParameters.GraphicsProfile;
Platform = textureParameters.Platform;
}
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 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 static ResultStatus ImportAndSaveTextureImage(UFile sourcePath, string outputUrl, TextureAsset textureAsset, TextureConvertParameters parameters, CancellationToken cancellationToken, Logger logger)
{
var assetManager = new AssetManager();
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(sourcePath, textureAsset.SRgb))
{
// Apply transformations
texTool.Decompress(texImage, textureAsset.SRgb);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
var fromSize = new Size2(texImage.Width, texImage.Height);
var targetSize = new Size2((int)textureAsset.Width, (int)textureAsset.Height);
// Resize the image
if (textureAsset.IsSizeInPercentage)
{
targetSize = new Size2((int)(fromSize.Width * (float)textureAsset.Width / 100.0f), (int)(fromSize.Height * (float) textureAsset.Height / 100.0f));
}
// Find the target size
targetSize = FindBestTextureSize(textureAsset.Format, parameters.GraphicsPlatform, parameters.GraphicsProfile, fromSize, targetSize, textureAsset.GenerateMipmaps, logger);
// Resize the image only if needed
if (targetSize != fromSize)
{
texTool.Resize(texImage, targetSize.Width, targetSize.Height, Filter.Rescaling.Lanczos3);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// texture size is now determined, we can cache it
var textureSize = new Int2(texImage.Width, texImage.Height);
// Apply the color key
if (textureAsset.ColorKeyEnabled)
texTool.ColorKey(texImage, textureAsset.ColorKeyColor);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Pre-multiply alpha
if (textureAsset.PremultiplyAlpha)
texTool.PreMultiplyAlpha(texImage);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Generate mipmaps
if (textureAsset.GenerateMipmaps)
{
var boxFilteringIsSupported = texImage.Format != PixelFormat.B8G8R8A8_UNorm_SRgb || (IsPowerOfTwo(textureSize.X) && IsPowerOfTwo(textureSize.Y));
texTool.GenerateMipMaps(texImage, boxFilteringIsSupported? Filter.MipMapGeneration.Box: Filter.MipMapGeneration.Linear);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Convert/Compress to output format
// TODO: Change alphaFormat depending on actual image content (auto-detection)?
var outputFormat = DetermineOutputFormat(textureAsset, parameters, textureSize, texImage.Format, parameters.Platform, parameters.GraphicsPlatform, parameters.GraphicsProfile);
texTool.Compress(texImage, outputFormat, (TextureConverter.Requests.TextureQuality)parameters.TextureQuality);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Save the texture
using (var outputImage = texTool.ConvertToParadoxImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
assetManager.Save(outputUrl, outputImage.ToSerializableVersion());
logger.Info("Compression successful [{3}] to ({0}x{1},{2})", outputImage.Description.Width, outputImage.Description.Height, outputImage.Description.Format, outputUrl);
}
}
return ResultStatus.Successful;
}
/// <summary>
/// Determine the output format of the texture depending on the platform and asset properties.
/// </summary>
/// <param name="parameters">The conversion request parameters</param>
/// <param name="graphicsPlatform">The graphics platform</param>
/// <param name="graphicsProfile">The graphics profile</param>
/// <param name="imageSize">The texture output size</param>
/// <param name="inputImageFormat">The pixel format of the input image</param>
/// <param name="textureAsset">The texture asset</param>
/// <returns>The pixel format to use as output</returns>
public static PixelFormat DetermineOutputFormat(TextureAsset textureAsset, TextureConvertParameters parameters, Int2 imageSize, PixelFormat inputImageFormat, PlatformType platform, GraphicsPlatform graphicsPlatform,
GraphicsProfile graphicsProfile)
{
if (textureAsset.SRgb && ((int)parameters.GraphicsProfile < (int)GraphicsProfile.Level_9_2 && parameters.GraphicsPlatform != GraphicsPlatform.Direct3D11))
throw new NotSupportedException("sRGB is not supported on OpenGl profile level {0}".ToFormat(parameters.GraphicsProfile));
var hint = textureAsset.Hint;
// Default output format
var outputFormat = PixelFormat.R8G8B8A8_UNorm;
switch (textureAsset.Format)
{
case TextureFormat.Compressed:
switch (parameters.Platform)
{
case PlatformType.Android:
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else if (textureAsset.SRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
switch (graphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = textureAsset.Alpha == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.R8G8B8A8_UNorm;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
// GLES3.0 starting from Level_10_0, this profile enables ETC2 compression on Android
outputFormat = textureAsset.Alpha == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.ETC2_RGBA;
break;
default:
throw new ArgumentOutOfRangeException("graphicsProfile");
}
}
break;
case PlatformType.iOS:
// PVRTC works only for square POT textures
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else if (textureAsset.SRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else if (SupportPVRTC(imageSize))
{
switch (textureAsset.Alpha)
{
case AlphaFormat.None:
// DXT1 handles 1-bit alpha channel
outputFormat = PixelFormat.PVRTC_4bpp_RGB;
break;
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
// TODO: Not sure about the equivalent here?
outputFormat = PixelFormat.PVRTC_4bpp_RGBA;
break;
case AlphaFormat.Explicit:
case AlphaFormat.Interpolated:
// DXT3 is good at sharp alpha transitions
// TODO: Not sure about the equivalent here?
outputFormat = PixelFormat.PVRTC_4bpp_RGBA;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
outputFormat = PixelFormat.R8G8B8A8_UNorm;
}
break;
case PlatformType.Windows:
case PlatformType.WindowsPhone:
case PlatformType.WindowsStore:
switch (parameters.GraphicsPlatform)
{
case GraphicsPlatform.Direct3D11:
// https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955%28v=vs.85%29.aspx
// http://www.reedbeta.com/blog/2012/02/12/understanding-bcn-texture-compression-formats/
// ---------------------------------------------- ---------------------------------------------------- --- ---------------------------------
// Source data Minimum required data compression resolution Recommended format Minimum supported feature level
// ---------------------------------------------- ---------------------------------------------------- --- ---------------------------------
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits), with 0 or 1 bit(s) of alpha BC1 Direct3D 9.1 (color maps, cutout color maps - 1 bit alpha, normal maps if memory is tight)
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits), with 4 bits of alpha BC2 Direct3D 9.1 (idem)
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits) with 8 bits of alpha BC3 Direct3D 9.1 (color maps with alpha, packing color and mono maps together)
// One-channel color One color channel (8 bits) BC4 Direct3D 10 (Height maps, gloss maps, font atlases, any gray scales image)
// Two-channel color Two color channels (8 bits:8 bits) BC5 Direct3D 10 (Tangent space normal maps)
// Three-channel high dynamic range (HDR) color Three color channels (16 bits:16 bits:16 bits) in "half" floating point* BC6H Direct3D 11 (HDR images)
// Three-channel color, alpha channel optional Three color channels (4 to 7 bits per channel) with 0 to 8 bits of alpha BC7 Direct3D 11 (High quality color maps, Color maps with full alpha)
switch (textureAsset.Alpha)
{
case AlphaFormat.None:
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
outputFormat = textureAsset.SRgb ? PixelFormat.BC1_UNorm_SRgb : PixelFormat.BC1_UNorm;
break;
case AlphaFormat.Explicit:
// DXT3 is good at sharp alpha transitions
outputFormat = textureAsset.SRgb ? PixelFormat.BC2_UNorm_SRgb : PixelFormat.BC2_UNorm;
break;
case AlphaFormat.Interpolated:
// DXT5 is good at alpha gradients
outputFormat = textureAsset.SRgb ? PixelFormat.BC3_UNorm_SRgb : PixelFormat.BC3_UNorm;
break;
default:
throw new ArgumentOutOfRangeException();
}
// Overrides the format when profile is >= 10.0
// Support some specific optimized formats based on the hint or input type
if (parameters.GraphicsProfile >= GraphicsProfile.Level_10_0)
{
if (hint == TextureHint.NormalMap)
{
outputFormat = PixelFormat.BC5_SNorm;
}
else if (hint == TextureHint.Grayscale)
{
outputFormat = PixelFormat.BC4_UNorm;
}
else if (inputImageFormat.IsHDR())
{
// BC6H is too slow to compile
//outputFormat = parameters.GraphicsProfile >= GraphicsProfile.Level_11_0 && textureAsset.Alpha == AlphaFormat.None ? PixelFormat.BC6H_Uf16 : inputImageFormat;
outputFormat = inputImageFormat;
}
// TODO support the BC6/BC7 but they are so slow to compile that we can't use them right now
}
break;
case GraphicsPlatform.OpenGLES: // OpenGLES on Windows
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else if (textureAsset.SRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
switch (graphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = textureAsset.Alpha == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.R8G8B8A8_UNorm;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
// GLES3.0 starting from Level_10_0, this profile enables ETC2 compression on Android
outputFormat = textureAsset.Alpha == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.ETC2_RGBA;
break;
default:
throw new ArgumentOutOfRangeException("graphicsProfile");
}
}
break;
default:
// OpenGL on Windows
// TODO: Need to handle OpenGL Desktop compression
outputFormat = textureAsset.SRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
break;
}
break;
default:
throw new NotSupportedException("Platform " + parameters.Platform + " is not supported by TextureTool");
}
break;
case TextureFormat.Color16Bits:
if (textureAsset.SRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
if (textureAsset.Alpha == AlphaFormat.None)
{
outputFormat = PixelFormat.B5G6R5_UNorm;
}
else if (textureAsset.Alpha == AlphaFormat.Mask)
{
outputFormat = PixelFormat.B5G5R5A1_UNorm;
}
}
break;
case TextureFormat.Color32Bits:
if (textureAsset.SRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
break;
case TextureFormat.AsIs:
outputFormat = inputImageFormat;
break;
default:
throw new ArgumentOutOfRangeException();
}
return outputFormat;
}
