public async Task <ActionResult> ListImportQueue(ImportParameters parameters)
{
var filter = new ImportQueueFilter()
{
FilterMessage = parameters.FilterMessage,
ImportStatus = (enums.ImportStatus)parameters.ImportStatusId.GetValueOrDefault(),
Action = ImportAction.ImportQueue
};
filter.InitialiseFromJson(parameters);
var results = await ImportViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results.TotalRecords, results.TotalDisplayRecords);
// Iterate through the results and put them in a format that can be used by jQuery datatables
if (results.ImportQueue.CurrentPage.Any())
{
foreach (var result in results.ImportQueue.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
}
return(Json(jQueryResult));
}
public async Task <List <ImportParameters> > UploadFilesToStorageAccountAndGnerateParameters()
{
List <ImportParameters> returnValue = new List <ImportParameters>();
MultipartMemoryStreamProvider inputStreams = await requestInput.Content.ReadAsMultipartAsync();
Dictionary <string, byte[]> fileData = inputStreams.ExtractStreams();
var nvc = requestInput.RequestUri.ParseQueryString();
string halbJahrParam = nvc["Halbjahr"]?.ToString();
halbJahrParam = System.Web.HttpUtility.UrlDecode(halbJahrParam);
string constring = Environment.GetEnvironmentVariable(ConnectionString);
BlobServiceClient blobServiceClient = new BlobServiceClient(constring);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient("imports");
string instanceId = string.Empty;
foreach (KeyValuePair <string, byte[]> kvp in fileData)
{
ImportParameters parameter = new ImportParameters();
parameter.FileName = string.Concat(kvp.Key, "_", Guid.NewGuid().ToString("N"));
parameter.HalfYearSetting = halbJahrParam;
BlobClient blob = containerClient.GetBlobClient(parameter.FileName);
blob.Upload(new MemoryStream(kvp.Value));
returnValue.Add(parameter);
}
return(returnValue);
}
/// <summary>
/// Utility function to check that the texture size is supported on the graphics platform for the provided graphics profile.
/// </summary>
/// <param name="parameters">The import parameters</param>
/// <param name="textureSize">The texture size requested.</param>
/// <param name="logger">The logger.</param>
/// <returns>true if the texture size is supported</returns>
/// <exception cref="System.ArgumentOutOfRangeException">graphicsProfile</exception>
public static Size2 FindMaximumTextureSize(ImportParameters parameters, Size2 textureSize, ILogger logger = null)
{
var maxTextureSize = 0;
// determine if the desired size if valid depending on the graphics profile
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
maxTextureSize = 16384;
break;
default:
throw new ArgumentOutOfRangeException("graphicsProfile");
}
if (textureSize.Width > maxTextureSize || textureSize.Height > maxTextureSize)
{
logger?.Error($"Graphic profile {parameters.GraphicsProfile} do not support texture with resolution {textureSize.Width} x {textureSize.Height} because it is larger than {maxTextureSize}. Please reduce texture size or upgrade your graphic profile.");
return(new Size2(Math.Min(textureSize.Width, maxTextureSize), Math.Min(textureSize.Height, maxTextureSize)));
}
return(textureSize);
}
public async Task <ActionResult> ImportPage(ImportParameters parameters)
{
Parameters = parameters;
var importView = await GetModelFromParameters();
return(View(importView));
}
public static ImportQueueFilter FromParameters(ImportParameters Parameters)
{
return(new ImportQueueFilter()
{
ImportQueueId = Parameters.ImportQueueId
});
}
protected void ApplyColumns(ImportParameters importParameters, ColumnScores columnScores)
{
importParameters.Columns = columnScores.Columns;
importParameters.HeaderColumnsValues = columnScores.HeaderColumnValues;
ImportEntity entity = importParameters.Entities.First();
entity.ColumnValues = columnScores.EntityColumns;
}
public ActionResult ModalAction(ImportParameters parameters)
{
Parameters = parameters;
ValidateImportParameters(Enum.GetName(Parameters.Action.GetType(), Parameters.Action));
return(RedirectToAction(Enum.GetName(Parameters.Action.GetType(), Parameters.Action),
ImportParameters.GetActionSpecificParameters(Parameters)));
}
private void UpdateContact(Entity contact, Dictionary <string, string> contactValues)
{
UserConnection userConnection = Get <UserConnection>("UserConnection");
var importParamsGenerator = new BaseImportParamsGenerator();
ImportParameters parameters = importParamsGenerator.GenerateParameters(contact.Schema, contactValues);
var fileImporter = new FileImporter(userConnection);
fileImporter.ImportWithParams(parameters);
}
static int Import(
ImportParameters p)
{
_parameters = p;
if (GetKeyManager(p) is IKeyManagement keyManagement)
{
keyManagement.ImportSymmetricKey(p.BinaryKey);
}
return(0);
}
public async Task <ActionResult> DeleteImport(ImportParameters parameters)
{
var filter = new ImportQueueFilter(parameters.ImportQueueId.GetValueOrDefault());
var importView = await GetModelFromParameters(parameters);
filter.ImportStatus = enums.ImportStatus.Cancelled;
importView.CurrentImport = await DataContext.Import.UpdateStatus(filter);
return(Json(JsonActionResult.GetSuccess(), JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Sets import session information.
/// </summary>
/// <param name="parameters">Import parameters.</param>
public void SetImportSessionInfo(ImportParameters parameters)
{
FileName = parameters.FileName;
ImportObject = parameters.ImportObject;
TotalRowsCount = parameters.TotalRowsCount;
ProcessedRowsCount = parameters.ProcessedRowsCount;
ImportedRowsCount = parameters.ImportedRowsCount;
NotImportedRowsCount = parameters.TotalRowsCount - parameters.ImportedRowsCount;
ImportTags = parameters.ImportTags;
}
/// <summary>
/// Utility function to check that the texture size is supported on the graphics platform for the provided graphics profile.
/// </summary>
/// <param name="parameters">The import parameters</param>
/// <param name="textureSizeRequested">The texture size requested.</param>
/// <param name="logger">The logger.</param>
/// <returns>true if the texture size is supported</returns>
/// <exception cref="System.ArgumentOutOfRangeException">graphicsProfile</exception>
public static Size2 FindBestTextureSize(ImportParameters parameters, Size2 textureSizeRequested, ILogger logger = null)
{
var textureSize = textureSizeRequested;
// compressed DDS files has to have a size multiple of 4.
if (parameters.GraphicsPlatform == GraphicsPlatform.Direct3D11 && parameters.DesiredFormat == TextureFormat.Compressed &&
((textureSizeRequested.Width % 4) != 0 || (textureSizeRequested.Height % 4) != 0))
{
textureSize.Width = unchecked ((int)(((uint)(textureSizeRequested.Width + 3)) & ~(uint)3));
textureSize.Height = unchecked ((int)(((uint)(textureSizeRequested.Height + 3)) & ~(uint)3));
}
var maxTextureSize = 0;
// determine if the desired size if valid depending on the graphics profile
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
if (parameters.GenerateMipmaps && (!MathUtil.IsPow2(textureSize.Width) || !MathUtil.IsPow2(textureSize.Height)))
{
// TODO: TEMPORARY SETUP A MAX TEXTURE OF 1024. THIS SHOULD BE SPECIFIED DONE IN THE ASSET INSTEAD
textureSize.Width = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Width), 1024);
textureSize.Height = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Height), 1024);
logger?.Warning("Graphic profiles 9.1/9.2/9.3 do not support mipmaps with textures that are not power of 2. Asset is automatically resized to " + textureSize);
}
maxTextureSize = parameters.GraphicsProfile >= GraphicsProfile.Level_9_3 ? 4096 : 2048;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
maxTextureSize = 8192;
break;
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
maxTextureSize = 16384;
break;
default:
throw new ArgumentOutOfRangeException("graphicsProfile");
}
if (textureSize.Width > maxTextureSize || textureSize.Height > maxTextureSize)
{
logger?.Error("Graphic profile {0} do not support texture with resolution {2} x {3} because it is larger than {1}. " +
"Please reduce texture size or upgrade your graphic profile.", parameters.GraphicsProfile, maxTextureSize, textureSize.Width, textureSize.Height);
return(new Size2(Math.Min(textureSize.Width, maxTextureSize), Math.Min(textureSize.Height, maxTextureSize)));
}
return(textureSize);
}
protected virtual ImportParameters GetImportParams(EntitySchema entitySchema)
{
var importParameters = new ImportParameters();
importParameters.Entities = new List <ImportEntity>();
var entity = new ImportEntity();
importParameters.Entities.Add(entity);
importParameters.RootSchemaUId = entitySchema.UId;
return(importParameters);
}
public static ImportQueue FromParameters(ImportParameters parameters)
{
return(new ImportQueue()
{
ProgrammeId = parameters.ProgrammeId.GetValueOrDefault(),
ModelYear = parameters.ModelYear,
Gateway = parameters.Gateway,
DocumentId = parameters.DocumentId,
FilePath = parameters.UploadFilePath,
OriginalFileName = parameters.UploadFile.FileName
});
}
public async Task <ActionResult> ModalContent(ImportParameters parameters)
{
if (parameters.Action != ImportAction.Upload)
{
ImportParametersValidator
.ValidateImportParameters(parameters, ImportParametersValidator.ImportQueueIdentifier, DataContext);
}
var importView = GetModelFromParameters(parameters).Result;
return(PartialView(GetContentPartialViewName(parameters.Action), importView));
}
public async Task <ActionResult> ContextMenu(ImportParameters parameters)
{
ImportParametersValidator.ValidateImportParameters(parameters, ImportParametersValidator.ImportQueueIdentifier, DataContext);
var importView = await ImportViewModel.GetModel(
DataContext,
new ImportQueueFilter(parameters.ImportQueueId.Value)
{
Action = ImportAction.ImportQueueItem
});
return(PartialView("_ContextMenu", importView));
}
public void PresentData(object data)
{
if (DataType != null)
{
foreach (PropertyInfo pi in DataType.GetProperties())
{
if (ImportParameters.Contains(pi.Name))
{
if (pi.GetGetMethod().GetCustomAttributes(typeof(CompilerGeneratedAttribute), true).Count() == 0)
{
string headerText;
string bindingName;
headerText = pi.Name;
bindingName = pi.Name;
if (pi.GetCustomAttributes(typeof(DisplayNameAttribute), false).Count() > 0)
{
headerText += "\n\r[" + ((DisplayNameAttribute)pi.GetCustomAttributes(typeof(DisplayNameAttribute), false)[0]).DisplayName + "]";
}
Column newColumn = new Column();
newColumn.Title = headerText;
newColumn.FieldName = bindingName;
ImportGrid.Columns.Add(newColumn);
if (!Presenter.PropertyToExcelColumnIIndexDic.ContainsKey(bindingName))
{
Presenter.PropertyToExcelColumnIIndexDic.Add(bindingName, -1);
}
}
}
}
LoadDataToGrid();
}
if (ShowOpenFile)
{
OpenFileComponent.FileExtensions = FileExtension;
OpenFileComponent.FileSelected += new EventHandler(OpenFileComponent_FileSelected);
}
else
{
OpenFileComponent.Visibility = System.Windows.Visibility.Collapsed;
}
}
/// <summary>
/// Utility function to check that the texture size is supported on the graphics platform for the provided graphics profile.
/// </summary>
/// <param name="parameters">The import parameters</param>
/// <param name="outputFormat">The output format</param>
/// <param name="textureSize">The texture size requested.</param>
/// <param name="logger">The logger.</param>
/// <returns>true if the texture size is supported</returns>
/// <exception cref="System.ArgumentOutOfRangeException">graphicsProfile</exception>
public static Size2 FindBestTextureSize(ImportParameters parameters, PixelFormat outputFormat, Size2 textureSize, ILogger logger = null)
{
bool isBlockCompressed =
(outputFormat >= PixelFormat.BC1_Typeless && outputFormat <= PixelFormat.BC5_SNorm) ||
(outputFormat >= PixelFormat.BC6H_Typeless && outputFormat <= PixelFormat.BC7_UNorm_SRgb);
// compressed DDS files has to have a size multiple of 4.
if (parameters.ShouldCompress && isBlockCompressed &&
((textureSize.Width % 4) != 0 || (textureSize.Height % 4) != 0))
{
textureSize.Width = unchecked ((int)(((uint)(textureSize.Width + 3)) & ~(uint)3));
textureSize.Height = unchecked ((int)(((uint)(textureSize.Height + 3)) & ~(uint)3));
}
return(FindMaximumTextureSize(parameters, textureSize, logger));
}
public static async Task <string> FetchFile([ActivityTrigger] ImportParameters parameter, ILogger log)
{
string constring = Environment.GetEnvironmentVariable("AzureWebJobsStorage");
BlobServiceClient blobServiceClient = new BlobServiceClient(constring);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient("imports");
BlobClient blob = containerClient.GetBlobClient(parameter.FileName);
MemoryStream s = new MemoryStream();
blob.DownloadTo(s);
parameter.Content = s.ToArray();
// Add Logic for Importing and replacing the following line
List <ImportResult> returnValue = new List <ImportResult>();
// Return the results
return(JsonConvert.SerializeObject(returnValue));
}
/// <summary>
/// Handles the form data.
/// </summary>
/// <param name="formData">The form data.</param>
public void HandleForm(FormData formData)
{
Success = true;
FormData = formData;
Guid webFormId = WebFormHelper.GetWebFormId(formData);
if (webFormId.Equals(Guid.Empty))
{
SetErrorStatus(GeneratedWebFormLczUtilities
.GetLczStringValue("UnknownWebFormIdentifierMessage",
"WebFormHandler", _userConnection));
return;
}
if (!(ImportParamsGenerator is IImportParamsGenerator))
{
SetErrorStatus(GeneratedWebFormLczUtilities
.GetLczStringValue("ImportParamsGeneratorImplementationMessage",
"WebFormHandler", _userConnection));
return;
}
InitHandlers(webFormId);
Guid newEntityId = SetUpNewEntityId(formData);
FormData = PreProcessData(formData);
EntitySchema schema = WebFormHelper.GetWebFormEntitySchema(webFormId, _userConnection);
ImportParameters parameters =
((IImportParamsGenerator)ImportParamsGenerator).GenerateParameters(schema);
if (!ImportParamsGenerator.Success)
{
SetErrorStatus(ImportParamsGenerator.ErrorMessage);
return;
}
FileImporter.ImportEntitySaveError += (sender, args) => {
SetErrorStatus(args.Message ?? args.Exception.Message, args.Exception);
};
FileImporter.ColumnProcessError += (sender, args) => {
SetErrorStatus(args.Message);
};
FileImporter.ImportWithParams(parameters);
if (Success)
{
PostProcessData(formData, webFormId, newEntityId);
}
}
/// <summary>
/// Utility function to check that the texture size is supported on the graphics platform for the provided graphics profile.
/// </summary>
/// <param name="parameters">The import parameters</param>
/// <param name="textureSizeRequested">The texture size requested.</param>
/// <param name="logger">The logger.</param>
/// <returns>true if the texture size is supported</returns>
/// <exception cref="System.ArgumentOutOfRangeException">graphicsProfile</exception>
public static Size2 FindMaximumTextureSize(ImportParameters parameters, Size2 textureSize, ILogger logger = null)
{
var maxTextureSize = 0;
// determine if the desired size if valid depending on the graphics profile
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
if (parameters.GenerateMipmaps && (!MathUtil.IsPow2(textureSize.Width) || !MathUtil.IsPow2(textureSize.Height)))
{
// TODO: TEMPORARY SETUP A MAX TEXTURE OF 1024. THIS SHOULD BE SPECIFIED DONE IN THE ASSET INSTEAD
textureSize.Width = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Width), 1024);
textureSize.Height = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Height), 1024);
logger?.Warning("Graphic profiles 9.1/9.2/9.3 do not support mipmaps with textures that are not power of 2. Asset is automatically resized to " + textureSize);
}
maxTextureSize = parameters.GraphicsProfile >= GraphicsProfile.Level_9_3 ? 4096 : 2048;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
maxTextureSize = 8192;
break;
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
maxTextureSize = 16384;
break;
default:
throw new ArgumentOutOfRangeException("graphicsProfile");
}
if (textureSize.Width > maxTextureSize || textureSize.Height > maxTextureSize)
{
logger?.Error($"Graphic profile {parameters.GraphicsProfile} do not support texture with resolution {textureSize.Width} x {textureSize.Height} because it is larger than {maxTextureSize}. Please reduce texture size or upgrade your graphic profile.");
return(new Size2(Math.Min(textureSize.Width, maxTextureSize), Math.Min(textureSize.Height, maxTextureSize)));
}
return(textureSize);
}
//[Ignore("Slow manual test harness")]
public void ImportFromRawFiles()
{
var idGenerator = new IdGenerator(IdGeneratorSequenceSeed);
var dobihFile = new DobihFile();
var parameters = new ImportParameters
{
DobihFile = dobihFile,
MapProvider = new MapProvider(idGenerator, new OsFile()),
IdGenerator = idGenerator,
CountryProvider = new CountryProvider(idGenerator),
ListProvider = new ListProvider(idGenerator, dobihFile, new ListInfoProvider()),
SectionProvider = new SectionProvider(idGenerator, dobihFile),
};
var sut = new DomainRootFactory(parameters).Build();
AssertDomain(sut);
sut.Save();
}
private async Task <ImportViewModel> GetModelFromParameters(ImportParameters parameters)
{
if (parameters.Action == ImportAction.DeleteImport)
{
return(await ImportViewModel.GetModel(
DataContext,
new ImportQueueFilter(parameters.ImportQueueId.GetValueOrDefault()) { Action = parameters.Action },
parameters.Action));
}
if (parameters.Action == ImportAction.Upload)
{
return(await ImportViewModel.GetModel(
DataContext,
new ImportQueueFilter()
{
Action = parameters.Action
},
parameters.Action));
}
return(GetModelFromParameters().Result);
}
public ActionResult Upload(HttpPostedFileBase fileToUpload,
string carLine,
string modelYear,
string gateway,
int?documentId)
{
Parameters = new ImportParameters
{
Action = ImportAction.Upload,
UploadFile = fileToUpload,
CarLine = carLine,
ModelYear = modelYear,
Gateway = gateway,
DocumentId = documentId
};
ValidateImportParameters(ImportParametersValidator.Upload);
SetProgrammeId();
SetUploadFilePath();
SaveImportFileToFileSystem();
QueueItemForProcessing();
ProcessQueuedItem();
//ValidateProcessedItem();
RefreshQueuedItem();
var retVal = JsonGetSuccess();
if (CurrentQueuedItem.HasErrors)
{
retVal = JsonGetFailure(string.Format("Import Completed with {0} {1} error(s)",
CurrentQueuedItem.ErrorCount,
ImportQueue.GetErrorTypeAbbreviation(CurrentQueuedItem.ErrorType)));
}
return(retVal);
}
/// <summary>
/// Sets import session information.
/// </summary>
/// <param name="parameters">Import parameters.</param>
/// <param name="schemaName">Schema name.</param>
public void SetImportSessionInfo(ImportParameters parameters, string schemaName)
{
SetImportSessionInfo(parameters);
RootSchemaName = schemaName;
}
public static ResultStatus ImportTextureImage(TextureTool textureTool, TexImage texImage, ImportParameters parameters, CancellationToken cancellationToken, Logger logger)
{
var assetManager = new AssetManager();
// Apply transformations
textureTool.Decompress(texImage, parameters.IsSRgb);
// Special case when the input texture is monochromatic but it is supposed to be a color and we are working in SRGB
// In that case, we need to transform it to a supported SRGB format (R8G8B8A8_UNorm_SRgb)
// TODO: As part of a conversion phase, this code may be moved to a dedicated method in this class at some point
if (parameters.TextureHint == TextureHint.Color && parameters.IsSRgb && (texImage.Format == PixelFormat.R8_UNorm || texImage.Format == PixelFormat.A8_UNorm))
{
textureTool.Convert(texImage, PixelFormat.R8G8B8A8_UNorm_SRgb);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
var fromSize = new Size2(texImage.Width, texImage.Height);
var targetSize = parameters.DesiredSize;
// Resize the image
if (parameters.IsSizeInPercentage)
{
targetSize = new Size2((int)(fromSize.Width * targetSize.Width / 100.0f), (int)(fromSize.Height * targetSize.Height / 100.0f));
}
// Find the target size
targetSize = FindBestTextureSize(parameters, targetSize, logger);
// Resize the image only if needed
if (targetSize != fromSize)
{
textureTool.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);
// determine the alpha format of the texture when set to Auto
// Note: this has to be done before the ColorKey transformation in order to be able to take advantage of image file AlphaDepth information
if(parameters.DesiredAlpha == AlphaFormat.Auto)
{
var colorKey = parameters.ColorKeyEnabled? (Color?)parameters.ColorKeyColor : null;
var alphaLevel = textureTool.GetAlphaLevels(texImage, new Rectangle(0, 0, textureSize.X, textureSize.Y), colorKey, logger);
parameters.DesiredAlpha = alphaLevel.ToAlphaFormat();
}
// Apply the color key
if (parameters.ColorKeyEnabled)
textureTool.ColorKey(texImage, parameters.ColorKeyColor);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Pre-multiply alpha only for relevant formats
if (parameters.PremultiplyAlpha && texImage.Format.HasAlpha32Bits())
textureTool.PreMultiplyAlpha(texImage);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Generate mipmaps
if (parameters.GenerateMipmaps)
{
var boxFilteringIsSupported = !texImage.Format.IsSRgb() || (MathUtil.IsPow2(textureSize.X) && MathUtil.IsPow2(textureSize.Y));
textureTool.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(parameters, textureSize, texImage.Format);
textureTool.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 = textureTool.ConvertToParadoxImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
assetManager.Save(parameters.OutputUrl, outputImage.ToSerializableVersion());
logger.Info("Compression successful [{3}] to ({0}x{1},{2})", outputImage.Description.Width, outputImage.Description.Height, outputImage.Description.Format, parameters.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="imageSize">The texture output size</param>
/// <param name="inputImageFormat">The pixel format of the input image</param>
/// <returns>The pixel format to use as output</returns>
public static PixelFormat DetermineOutputFormat(ImportParameters parameters, Int2 imageSize, PixelFormat inputImageFormat)
{
var hint = parameters.TextureHint;
var alphaMode = parameters.DesiredAlpha;
// Default output format
var outputFormat = PixelFormat.R8G8B8A8_UNorm;
switch (parameters.DesiredFormat)
{
case TextureFormat.Compressed:
switch (parameters.Platform)
{
case PlatformType.Android:
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : 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 = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.ETC2_RGBA_SRgb : 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 (SupportPVRTC(imageSize))
{
switch (alphaMode)
{
case AlphaFormat.None:
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGB_SRgb : PixelFormat.PVRTC_4bpp_RGB;
break;
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
// TODO: Not sure about the equivalent here?
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : 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 = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : PixelFormat.PVRTC_4bpp_RGBA;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
outputFormat = parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
}
break;
case PlatformType.Windows:
case PlatformType.WindowsPhone:
case PlatformType.WindowsStore:
case PlatformType.Windows10:
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 (alphaMode)
{
case AlphaFormat.None:
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
outputFormat = parameters.IsSRgb ? PixelFormat.BC1_UNorm_SRgb : PixelFormat.BC1_UNorm;
break;
case AlphaFormat.Explicit:
// DXT3 is good at sharp alpha transitions
outputFormat = parameters.IsSRgb ? PixelFormat.BC2_UNorm_SRgb : PixelFormat.BC2_UNorm;
break;
case AlphaFormat.Interpolated:
// DXT5 is good at alpha gradients
outputFormat = parameters.IsSRgb ? 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 && alphaMode == 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 (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == 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 = alphaMode == 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 = parameters.IsSRgb ? 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 (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
if (alphaMode == AlphaFormat.None)
{
outputFormat = PixelFormat.B5G6R5_UNorm;
}
else if (alphaMode == AlphaFormat.Mask)
{
outputFormat = PixelFormat.B5G5R5A1_UNorm;
}
}
break;
case TextureFormat.Color32Bits:
if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
break;
case TextureFormat.AsIs:
outputFormat = inputImageFormat;
break;
default:
throw new ArgumentOutOfRangeException();
}
return outputFormat;
}
/// <summary>
/// Utility function to check that the texture size is supported on the graphics platform for the provided graphics profile.
/// </summary>
/// <param name="parameters">The import parameters</param>
/// <param name="textureSizeRequested">The texture size requested.</param>
/// <param name="logger">The logger.</param>
/// <returns>true if the texture size is supported</returns>
/// <exception cref="System.ArgumentOutOfRangeException">graphicsProfile</exception>
public static Size2 FindBestTextureSize(ImportParameters parameters, Size2 textureSizeRequested, ILogger logger = null)
{
var textureSize = textureSizeRequested;
// compressed DDS files has to have a size multiple of 4.
if (parameters.GraphicsPlatform == GraphicsPlatform.Direct3D11 && parameters.DesiredFormat == TextureFormat.Compressed
&& ((textureSizeRequested.Width % 4) != 0 || (textureSizeRequested.Height % 4) != 0))
{
textureSize.Width = unchecked((int)(((uint)(textureSizeRequested.Width + 3)) & ~(uint)3));
textureSize.Height = unchecked((int)(((uint)(textureSizeRequested.Height + 3)) & ~(uint)3));
}
var maxTextureSize = 0;
// determine if the desired size if valid depending on the graphics profile
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
if (parameters.GenerateMipmaps && (!MathUtil.IsPow2(textureSize.Width) || !MathUtil.IsPow2(textureSize.Height)))
{
// TODO: TEMPORARY SETUP A MAX TEXTURE OF 1024. THIS SHOULD BE SPECIFIED DONE IN THE ASSET INSTEAD
textureSize.Width = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Width), 1024);
textureSize.Height = Math.Min(MathUtil.NextPowerOfTwo(textureSize.Height), 1024);
logger?.Warning("Graphic profiles 9.1/9.2/9.3 do not support mipmaps with textures that are not power of 2. Asset is automatically resized to " + textureSize);
}
maxTextureSize = parameters.GraphicsProfile >= GraphicsProfile.Level_9_3 ? 4096 : 2048;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
maxTextureSize = 8192;
break;
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
maxTextureSize = 16384;
break;
default:
throw new ArgumentOutOfRangeException("graphicsProfile");
}
if (textureSize.Width > maxTextureSize || textureSize.Height > maxTextureSize)
{
logger?.Error("Graphic profile {0} do not support texture with resolution {2} x {3} because it is larger than {1}. " +
"Please reduce texture size or upgrade your graphic profile.", parameters.GraphicsProfile, maxTextureSize, textureSize.Width, textureSize.Height);
return new Size2(Math.Min(textureSize.Width, maxTextureSize), Math.Min(textureSize.Height, maxTextureSize));
}
return textureSize;
}
public static ResultStatus ImportTextureImage(TextureTool textureTool, TexImage texImage, ImportParameters parameters, CancellationToken cancellationToken, Logger logger)
{
var assetManager = new ContentManager();
// Apply transformations
textureTool.Decompress(texImage, parameters.IsSRgb);
// Special case when the input texture is monochromatic but it is supposed to be a color and we are working in SRGB
// In that case, we need to transform it to a supported SRGB format (R8G8B8A8_UNorm_SRgb)
// TODO: As part of a conversion phase, this code may be moved to a dedicated method in this class at some point
if (parameters.TextureHint == TextureHint.Color && parameters.IsSRgb && (texImage.Format == PixelFormat.R8_UNorm || texImage.Format == PixelFormat.A8_UNorm))
{
textureTool.Convert(texImage, PixelFormat.R8G8B8A8_UNorm_SRgb);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
var fromSize = new Size2(texImage.Width, texImage.Height);
var targetSize = parameters.DesiredSize;
// Resize the image
if (parameters.IsSizeInPercentage)
{
targetSize = new Size2((int)(fromSize.Width * targetSize.Width / 100.0f), (int)(fromSize.Height * targetSize.Height / 100.0f));
}
// Find the target size
targetSize = FindBestTextureSize(parameters, targetSize, logger);
// Resize the image only if needed
if (targetSize != fromSize)
{
textureTool.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);
// determine the alpha format of the texture when set to Auto
// Note: this has to be done before the ColorKey transformation in order to be able to take advantage of image file AlphaDepth information
if (parameters.DesiredAlpha == AlphaFormat.Auto)
{
var colorKey = parameters.ColorKeyEnabled? (Color?)parameters.ColorKeyColor : null;
var alphaLevel = textureTool.GetAlphaLevels(texImage, new Rectangle(0, 0, textureSize.X, textureSize.Y), colorKey, logger);
parameters.DesiredAlpha = alphaLevel.ToAlphaFormat();
}
// Apply the color key
if (parameters.ColorKeyEnabled)
{
textureTool.ColorKey(texImage, parameters.ColorKeyColor);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Pre-multiply alpha only for relevant formats
if (parameters.PremultiplyAlpha && texImage.Format.HasAlpha32Bits())
{
textureTool.PreMultiplyAlpha(texImage);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Generate mipmaps
if (parameters.GenerateMipmaps)
{
var boxFilteringIsSupported = !texImage.Format.IsSRgb() || (MathUtil.IsPow2(textureSize.X) && MathUtil.IsPow2(textureSize.Y));
textureTool.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(parameters, textureSize, texImage.Format);
textureTool.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 = textureTool.ConvertToXenkoImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
assetManager.Save(parameters.OutputUrl, outputImage.ToSerializableVersion());
logger.Verbose("Compression successful [{3}] to ({0}x{1},{2})", outputImage.Description.Width, outputImage.Description.Height, outputImage.Description.Format, parameters.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="imageSize">The texture output size</param>
/// <param name="inputImageFormat">The pixel format of the input image</param>
/// <returns>The pixel format to use as output</returns>
public static PixelFormat DetermineOutputFormat(ImportParameters parameters, Int2 imageSize, PixelFormat inputImageFormat)
{
var hint = parameters.TextureHint;
var alphaMode = parameters.DesiredAlpha;
// Default output format
var outputFormat = PixelFormat.R8G8B8A8_UNorm;
switch (parameters.DesiredFormat)
{
case TextureFormat.Compressed:
switch (parameters.Platform)
{
case PlatformType.Android:
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : 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 = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.ETC2_RGBA_SRgb : 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 (SupportPVRTC(imageSize))
{
switch (alphaMode)
{
case AlphaFormat.None:
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGB_SRgb : PixelFormat.PVRTC_4bpp_RGB;
break;
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
// TODO: Not sure about the equivalent here?
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : 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 = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : PixelFormat.PVRTC_4bpp_RGBA;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
outputFormat = parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
}
break;
case PlatformType.Windows:
case PlatformType.WindowsPhone:
case PlatformType.WindowsStore:
case PlatformType.Windows10:
case PlatformType.Linux:
switch (parameters.GraphicsPlatform)
{
case GraphicsPlatform.Direct3D11:
case GraphicsPlatform.Direct3D12:
case GraphicsPlatform.OpenGL:
// 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 (alphaMode)
{
case AlphaFormat.None:
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
outputFormat = parameters.IsSRgb ? PixelFormat.BC1_UNorm_SRgb : PixelFormat.BC1_UNorm;
break;
case AlphaFormat.Explicit:
// DXT3 is good at sharp alpha transitions
outputFormat = parameters.IsSRgb ? PixelFormat.BC2_UNorm_SRgb : PixelFormat.BC2_UNorm;
break;
case AlphaFormat.Interpolated:
// DXT5 is good at alpha gradients
outputFormat = parameters.IsSRgb ? 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 (parameters.GraphicsPlatform != GraphicsPlatform.OpenGL && hint == TextureHint.NormalMap)
{
outputFormat = PixelFormat.BC5_SNorm;
}
else if (parameters.GraphicsPlatform != GraphicsPlatform.OpenGL && hint == TextureHint.Grayscale)
{
outputFormat = PixelFormat.BC4_UNorm;
}
else if (inputImageFormat.IsHDR())
{
// BC6H is too slow to compile
//outputFormat = parameters.GraphicsProfile >= GraphicsProfile.Level_11_0 && alphaMode == 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 (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == 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 = alphaMode == 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 = parameters.IsSRgb ? 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 (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
if (alphaMode == AlphaFormat.None)
{
outputFormat = PixelFormat.B5G6R5_UNorm;
}
else if (alphaMode == AlphaFormat.Mask)
{
outputFormat = PixelFormat.B5G5R5A1_UNorm;
}
}
break;
case TextureFormat.Color32Bits:
if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
break;
case TextureFormat.AsIs:
outputFormat = inputImageFormat;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(outputFormat);
}
public static ResultStatus ImportTextureImage(TextureTool textureTool, TexImage texImage, ImportParameters parameters, CancellationToken cancellationToken, Logger logger)
{
var assetManager = new AssetManager();
// Apply transformations
textureTool.Decompress(texImage, parameters.IsSRgb);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
var fromSize = new Size2(texImage.Width, texImage.Height);
var targetSize = parameters.DesiredSize;
// Resize the image
if (parameters.IsSizeInPercentage)
{
targetSize = new Size2((int)(fromSize.Width * targetSize.Width / 100.0f), (int)(fromSize.Height * targetSize.Height / 100.0f));
}
// Find the target size
targetSize = FindBestTextureSize(parameters, fromSize, targetSize, logger);
// Resize the image only if needed
if (targetSize != fromSize)
{
textureTool.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 (parameters.ColorKeyEnabled)
{
textureTool.ColorKey(texImage, parameters.ColorKeyColor);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Pre-multiply alpha
if (parameters.PremultiplyAlpha)
{
textureTool.PreMultiplyAlpha(texImage);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Generate mipmaps
if (parameters.GenerateMipmaps)
{
var boxFilteringIsSupported = texImage.Format != PixelFormat.B8G8R8A8_UNorm_SRgb || (MathUtil.IsPow2(textureSize.X) && MathUtil.IsPow2(textureSize.Y));
textureTool.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(parameters, textureSize, texImage.Format, texImage.GetAlphaDepth());
textureTool.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 = textureTool.ConvertToParadoxImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
assetManager.Save(parameters.OutputUrl, outputImage.ToSerializableVersion());
logger.Info("Compression successful [{3}] to ({0}x{1},{2})", outputImage.Description.Width, outputImage.Description.Height, outputImage.Description.Format, parameters.OutputUrl);
}
return(ResultStatus.Successful);
}
public void OneTimeSetUp()
{
var mockRecord = new Mock <IDobihRecord>();
mockRecord.Setup(x => x.Number).Returns(Number);
mockRecord.Setup(x => x.Name).Returns(Name);
mockRecord.Setup(x => x.SectionCode).Returns(SectionCode);
mockRecord.Setup(x => x.SectionName).Returns(SectionName);
mockRecord.Setup(x => x.Country).Returns(Country);
mockRecord.Setup(x => x.Lists).Returns(Lists);
mockRecord.Setup(x => x.Maps1To50000).Returns(Maps1To50000);
mockRecord.Setup(x => x.Maps1To25000).Returns(Maps1To25000);
mockRecord.Setup(x => x.Metres).Returns(Metres);
mockRecord.Setup(x => x.Latitude).Returns(Latitude);
mockRecord.Setup(x => x.Longitude).Returns(Longitude);
mockRecord.Setup(x => x.GridRef).Returns(GridRef);
mockRecord.Setup(x => x.Drop).Returns(Drop);
mockRecord.Setup(x => x.ColGridRef).Returns(ColGridRef);
mockRecord.Setup(x => x.ColMetres).Returns(ColMetres);
mockRecord.Setup(x => x.Feature).Returns(Feature);
mockRecord.Setup(x => x.Observations).Returns(Observations);
var mockDobihFile = new Mock <IDobihFile>();
mockDobihFile.Setup(x => x.Records).Returns(new List <IDobihRecord> {
mockRecord.Object
});
var mockIdGenerator = new Mock <IIdGenerator>();
mockIdGenerator.Setup(x => x.Generate(Number)).Returns(Id);
var mockCountryProvider = new Mock <IEntityProvider <Country> >();
mockCountryProvider.Setup(x => x.GetByDobihId(Country)).Returns(new Country {
Id = CountryId
});
var mockListProvider = new Mock <IEntityProvider <List> >();
mockListProvider.Setup(x => x.GetByDobihId(List1)).Returns(new List {
Id = List1Id
});
mockListProvider.Setup(x => x.GetByDobihId(List2)).Returns(new List {
Id = List2Id
});
var mockSectionProvider = new Mock <IEntityProvider <Section> >();
mockSectionProvider.Setup(x => x.GetByDobihId(SectionName)).Returns(new Section {
Id = SectionId
});
var mockMapProvider = new Mock <IMapProvider>();
mockMapProvider
.Setup(x => x.GetMapsByCode(It.IsAny <decimal>(), It.IsAny <MapConstants.Region>(), Maps1To50000))
.Returns(new List <Map> {
new Map {
Id = Map1To50K1Id
}, new Map {
Id = Map1To50K2Id
}
});
mockMapProvider
.Setup(x => x.GetMapsByCode(It.IsAny <decimal>(), It.IsAny <MapConstants.Region>(), Maps1To25000))
.Returns(new List <Map> {
new Map {
Id = Map1To25K1Id
}, new Map {
Id = Map1To25K2Id
}
});
var parameters = new ImportParameters
{
DobihFile = mockDobihFile.Object,
IdGenerator = mockIdGenerator.Object,
CountryProvider = mockCountryProvider.Object,
ListProvider = mockListProvider.Object,
SectionProvider = mockSectionProvider.Object,
MapProvider = mockMapProvider.Object
};
_actual = new MountainProvider(parameters).GetAll().Single();
}
public static ResultStatus ImportTextureImage(TextureTool textureTool, TexImage texImage, ImportParameters parameters, CancellationToken cancellationToken, Logger logger)
{
var assetManager = new AssetManager();
// Apply transformations
textureTool.Decompress(texImage, parameters.IsSRgb);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
var fromSize = new Size2(texImage.Width, texImage.Height);
var targetSize = parameters.DesiredSize;
// Resize the image
if (parameters.IsSizeInPercentage)
{
targetSize = new Size2((int)(fromSize.Width * targetSize.Width / 100.0f), (int)(fromSize.Height * targetSize.Height / 100.0f));
}
// Find the target size
targetSize = FindBestTextureSize(parameters, fromSize, targetSize, logger);
// Resize the image only if needed
if (targetSize != fromSize)
{
textureTool.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 (parameters.ColorKeyEnabled)
textureTool.ColorKey(texImage, parameters.ColorKeyColor);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Pre-multiply alpha
if (parameters.PremultiplyAlpha)
textureTool.PreMultiplyAlpha(texImage);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Generate mipmaps
if (parameters.GenerateMipmaps)
{
var boxFilteringIsSupported = texImage.Format != PixelFormat.B8G8R8A8_UNorm_SRgb || (MathUtil.IsPow2(textureSize.X) && MathUtil.IsPow2(textureSize.Y));
textureTool.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(parameters, textureSize, texImage.Format, texImage.GetAlphaDepth());
textureTool.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 = textureTool.ConvertToParadoxImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
assetManager.Save(parameters.OutputUrl, outputImage.ToSerializableVersion());
logger.Info("Compression successful [{3}] to ({0}x{1},{2})", outputImage.Description.Width, outputImage.Description.Height, outputImage.Description.Format, parameters.OutputUrl);
}
return ResultStatus.Successful;
}
/// <summary>
/// Utility function to check that the texture size is supported on the graphics platform for the provided graphics profile.
/// </summary>
/// <param name="parameters">The import parameters</param>
/// <param name="outputFormat">The output format</param>
/// <param name="textureSize">The texture size requested.</param>
/// <param name="logger">The logger.</param>
/// <returns>true if the texture size is supported</returns>
/// <exception cref="System.ArgumentOutOfRangeException">graphicsProfile</exception>
public static Size2 FindBestTextureSize(ImportParameters parameters, PixelFormat outputFormat, Size2 textureSize, ILogger logger = null)
{
bool isBlockCompressed =
(outputFormat >= PixelFormat.BC1_Typeless && outputFormat <= PixelFormat.BC5_SNorm) ||
(outputFormat >= PixelFormat.BC6H_Typeless && outputFormat <= PixelFormat.BC7_UNorm_SRgb);
// compressed DDS files has to have a size multiple of 4.
if ((parameters.DesiredFormat == TextureFormat.Compressed) && isBlockCompressed &&
((textureSize.Width % 4) != 0 || (textureSize.Height % 4) != 0))
{
textureSize.Width = unchecked((int)(((uint)(textureSize.Width + 3)) & ~(uint)3));
textureSize.Height = unchecked((int)(((uint)(textureSize.Height + 3)) & ~(uint)3));
}
return FindMaximumTextureSize(parameters, textureSize, logger);
}
public static ResultStatus ImportTextureImage(ContentManager assetManager, TextureTool textureTool, TexImage texImage, ImportParameters parameters, CancellationToken cancellationToken, Logger logger)
{
// Convert image to the final format
var result = ImportTextureImageRaw(textureTool, texImage, parameters, cancellationToken, logger);
if (result != ResultStatus.Successful)
{
return(result);
}
// Save the texture
using (var outputImage = textureTool.ConvertToStrideImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
assetManager.Save(parameters.OutputUrl, outputImage.ToSerializableVersion(), typeof(Texture));
logger.Verbose($"Compression successful [{parameters.OutputUrl}] to ({outputImage.Description.Width}x{outputImage.Description.Height},{outputImage.Description.Format})");
}
return(ResultStatus.Successful);
}