protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
// load the sound thumbnail image from the resources
using (var imageStream = new MemoryStream(staticImageData))
using (var image = Image.Load(imageStream))
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(image, Parameters.SRgb))
{
// Rescale image so that it fits the thumbnail asked resolution
texTool.Decompress(texImage, texImage.Format.IsSRgb());
texTool.Resize(texImage, thumbnailSize.X, thumbnailSize.Y, Filter.Rescaling.Lanczos3);
// Save
using (var outputImageStream = MicrothreadLocalDatabases.DatabaseFileProvider.OpenStream(Url, VirtualFileMode.Create, VirtualFileAccess.Write))
using (var outputImage = texTool.ConvertToStrideImage(texImage))
{
ThumbnailBuildHelper.ApplyThumbnailStatus(outputImage, DependencyBuildStatus);
outputImage.Save(outputImageStream, ImageFileType.Png);
commandContext.Logger.Verbose($"Thumbnail creation successful [{Url}] to ({outputImage.Description.Width}x{outputImage.Description.Height},{outputImage.Description.Format})");
}
}
return(Task.FromResult(ResultStatus.Successful));
}
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Parameters.FontDataFile, Parameters.IsSrgb))
{
//make sure we are RGBA and not BGRA
texTool.Convert(texImage, Parameters.IsSrgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm);
var image = texTool.ConvertToStrideImage(texImage);
Graphics.SpriteFont staticFont = FontDataFactory.NewStatic(
Parameters.Size,
Parameters.Glyphs,
new[] { image },
Parameters.BaseOffset,
Parameters.DefaultLineSpacing,
Parameters.Kernings,
Parameters.ExtraSpacing,
Parameters.ExtraLineSpacing,
Parameters.DefaultCharacter);
// save the data into the database
var assetManager = new ContentManager(MicrothreadLocalDatabases.ProviderService);
assetManager.Save(Url, staticFont);
image.Dispose();
}
return(Task.FromResult(ResultStatus.Successful));
}
private void CheckEmptyRegion(TextureTool tool, TexImage image, Int2 position)
{
var theoreticalRegion = new Rectangle(position.X, position.Y, 0, 0);
var foundRegion = tool.FindSpriteRegion(image, position);
Assert.Equal(theoreticalRegion, foundRegion);
}
public void Update(GraphicsDevice Device)
{
if (!CompositeValid)
{
CompositeValid = true;
Layers.Sort((a, b) => a.Layer.Precedence - b.Layer.Precedence);
// Render the composite texture
var maxSize = new Point(0, 0);
foreach (var layer in Layers)
{
maxSize.X = Math.Max(layer.Layer.CachedTexture.Width, maxSize.X);
maxSize.Y = Math.Max(layer.Layer.CachedTexture.Height, maxSize.Y);
}
if (maxSize.X == 0 || maxSize.Y == 0)
{
return;
}
if (MemoryComposite == null || MemoryComposite.Width != maxSize.X || MemoryComposite.Height != maxSize.Y)
{
MemoryComposite = new MemoryTexture(maxSize.X, maxSize.Y);
}
TextureTool.ClearMemoryTexture(MemoryComposite);
foreach (var layer in Layers)
{
TextureTool.Blit(layer.Layer.CachedTexture, layer.Palette.CachedPalette, MemoryComposite);
}
Composite = TextureTool.Texture2DFromMemoryTexture(Device, MemoryComposite);
}
}
public static void CreateAndSaveSeparateTextures(TextureTool texTool, TexImage texImage, string originalTextureURL, bool shouldGenerateMipMaps, PixelFormat outputFormat = PixelFormat.ETC1)
{
var assetManager = new AssetManager();
var alphaTextureURL = GenerateAlphaTextureURL(originalTextureURL);
var colorTextureURL = GenerateColorTextureURL(originalTextureURL);
// create a new image containing only the alpha component
texTool.Decompress(texImage, texImage.Format.IsSRgb());
using (var alphaImage = texTool.CreateImageFromAlphaComponent(texImage))
{
// generate the mip-maps for the alpha component if required
if (shouldGenerateMipMaps)
{
texTool.GenerateMipMaps(alphaImage, Filter.MipMapGeneration.Box);
}
// save the alpha component
texTool.Compress(alphaImage, outputFormat);
using (var outputImage = texTool.ConvertToXenkoImage(alphaImage))
assetManager.Save(alphaTextureURL, outputImage.ToSerializableVersion());
}
// save the color component
texTool.Decompress(texImage, texImage.Format.IsSRgb());
texTool.Compress(texImage, outputFormat);
using (var outputImage = texTool.ConvertToXenkoImage(texImage))
assetManager.Save(colorTextureURL, outputImage.ToSerializableVersion());
}
private static void InitializeLayers()
{
if (LayersInitialized)
{
return;
}
LayersInitialized = true;
LayerTypes = FileUtils.LoadJsonListFromMultipleSources <LayerType>("Entities/Dwarf/Layers/layer-types.json", null, p => p.Name);
Layers = new List <Layer>();
foreach (var file in AssetManager.EnumerateAllFiles("Entities/Dwarf/Layers").Where(filename => System.IO.Path.GetExtension(filename) == ".psd" && filename.Contains("layer")))
{
foreach (var sheet in TextureTool.LoadPSD(System.IO.File.OpenRead(file)))
{
var tags = sheet.LayerName.Split(' ');
if (tags.Length < 2)
{
continue;
}
var l = new Layer()
{
CachedTexture = TextureTool.DecomposeTexture(sheet.Data, BasePalette.CachedPalette),
Type = tags[0]
};
l.Names.AddRange(tags.Skip(1));
Layers.Add(l);
}
}
}
private static void InitializePalettes()
{
if (PalettesInitialized)
{
return;
}
PalettesInitialized = true;
PaletteTypes = FileUtils.LoadJsonListFromMultipleSources <PaletteType>("Entities/Dwarf/Layers/palette-types.json", null, p => p.Name);
Palettes = FileUtils.LoadJsonListFromMultipleSources <Palette>("Entities/Dwarf/Layers/palettes.json", null, p => p.Name);
foreach (var palette in Palettes)
{
var asset = AssetManager.GetContentTexture(palette.Asset);
palette.CachedPalette = new DwarfCorp.Palette(TextureTool.RawPaletteFromMemoryTextureRow(TextureTool.MemoryTextureFromTexture2D(asset), palette.Row));
}
if (Palettes.Count == 0)
{
throw new InvalidProgramException("No palettes?");
}
_BasePalette = Palettes.FirstOrDefault(p => p.Type == "Base");
if (_BasePalette == null)
{
_BasePalette = Palettes[0];
}
}
private static void Initialize()
{
if (Layers != null && Palettes != null)
{
return;
}
Layers = FileUtils.LoadJsonListFromMultipleSources <Layer>(ContentPaths.dwarf_layers, null, l => l.Type + "&" + l.Asset);
foreach (var layer in Layers)
{
var rawTexture = AssetManager.GetContentTexture(layer.Asset);
var memTexture = TextureTool.MemoryTextureFromTexture2D(rawTexture);
if (memTexture == null)
{
continue;
}
layer.CachedTexture = TextureTool.DecomposeTexture(memTexture, BaseDwarfPalette.CachedPalette);
}
Palettes = FileUtils.LoadJsonListFromMultipleSources <Palette>(ContentPaths.dwarf_palettes, null, l => l.Asset);
foreach (var palette in Palettes)
{
var rawTexture = AssetManager.GetContentTexture(palette.Asset);
palette.CachedPalette = TextureTool.RawPaletteFromTexture2D(rawTexture);
}
}
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);
}
public static void CreateAndSaveSeparateTextures(Image image, string originalTextureURL, bool shouldGenerateMipMaps, PixelFormat outputFormat = PixelFormat.ETC1)
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(image))
{
CreateAndSaveSeparateTextures(texTool, texImage, originalTextureURL, shouldGenerateMipMaps, outputFormat);
}
}
/// <summary>
/// 起始
/// </summary>
void Start()
{
scTexture = TextureTool.OnGetTextureGray(textRwa.texture);
//TextureTool.OnSaveTexture2d(Application.dataPath + "/Image", "towVal_1", scTexture);
//Debug.Log(Application.dataPath);
OnFindMarginPoint();
}
public override void Construct()
{
Root.RegisterForUpdate(this);
base.Construct();
this.OnUpdate = (sender, time) =>
{
if (Hidden || Transparent)
{
return;
}
if (IsAnyParentHidden())
{
return;
}
if (Sprite == null)
{
return;
}
var texture = Sprite.GetCompositeTexture();
if (texture != null)
{
var sheet = new SpriteSheet(texture, 48, 40);
var frame = AnimationPlayer.GetCurrentAnimation().Frames[AnimationPlayer.CurrentFrame];
if (DynamicAtlasEntry == null)
{
var tex = new Texture2D(Root.RenderData.Device, 48, 40);
DynamicAtlasEntry = Root.SpriteAtlas.AddDynamicSheet(null,
new TileSheetDefinition
{
TileHeight = 40,
TileWidth = 48,
RepeatWhenUsedAsBorder = false,
Type = TileSheetType.TileSheet
},
tex);
}
var memTex = TextureTool.MemoryTextureFromTexture2D(texture, new Rectangle(frame.X * 48, frame.Y * 40, 48, 40));
DynamicAtlasEntry.ReplaceTexture(TextureTool.Texture2DFromMemoryTexture(Root.RenderData.Device, memTex));
}
this.Invalidate();
};
this.OnClose = (sender) =>
{
if (DynamicAtlasEntry != null)
{
DynamicAtlasEntry.Discard();
}
};
}
public void TransparencyKeyTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "BgraSheet.dds"))
{
var theoreticalRegion = new Rectangle(25, 25, 0, 0);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(25, 25), transparencyColorKey, 0xffffffff);
Assert.Equal(theoreticalRegion, foundRegion);
}
}
private AtlasTextureElement CreateElementFromFile(string name, int borderSize, TextureAddressMode borderModeU, TextureAddressMode borderModeV, RotableRectangle?imageRegion = null)
{
using (var texTool = new TextureTool())
{
var image = LoadImage(texTool, new UFile(ImageInputPath + "/" + name + ".png"));
var region = imageRegion ?? new RotableRectangle(0, 0, image.Description.Width, image.Description.Height);
return(new AtlasTextureElement(name, image, region, borderSize, borderModeU, borderModeV, Color.SteelBlue));
}
}
public void SinglePixelTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(4, 5, 1, 1);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(4, 5));
Assert.Equal(theoreticalRegion, foundRegion);
}
}
public void SinglePixelTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(4, 5, 1, 1);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(4,5));
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
public static void ConvertTestPSD()
{
var stream = System.IO.File.OpenRead("Content/Entities/Dwarf/Layers/test.psd");
var psd = new PhotoshopFile.PsdFile(stream, new PhotoshopFile.LoadContext());
if (FindPalette("Hair 02").HasValue(out var conversionPalette))
{
foreach (var layer in psd.Layers)
{
var channels = new List <PhotoshopFile.Channel>();
channels.Add(layer.Channels.Where(c => c.ID == 0).FirstOrDefault());
channels.Add(layer.Channels.Where(c => c.ID == 1).FirstOrDefault());
channels.Add(layer.Channels.Where(c => c.ID == 2).FirstOrDefault());
channels.Add(layer.AlphaChannel);
var rawMemText = new MemoryTexture(layer.Rect.Width, layer.Rect.Height);
for (var index = 0; index < layer.Rect.Width * layer.Rect.Height; ++index)
{
if (channels[3].ImageData[index] == 0)
{
rawMemText.Data[index] = new Color(0, 0, 0, 0);
}
else
{
rawMemText.Data[index] = new Color(channels[0].ImageData[index], channels[1].ImageData[index], channels[2].ImageData[index], channels[3].ImageData[index]);
}
}
var memTex = new MemoryTexture(psd.ColumnCount, psd.RowCount);
TextureTool.Blit(rawMemText, new Rectangle(0, 0, layer.Rect.Width, layer.Rect.Height), memTex, new Point(layer.Rect.X, layer.Rect.Y));
var decomposed = TextureTool.DecomposeTexture(memTex, conversionPalette.CachedPalette);
var composed = TextureTool.ComposeTexture(decomposed, BasePalette.CachedPalette);
TextureTool.Blit(composed, new Rectangle(layer.Rect.X, layer.Rect.Y, layer.Rect.Width, layer.Rect.Height), rawMemText, new Rectangle(0, 0, rawMemText.Width, rawMemText.Height));
for (var index = 0; index < rawMemText.Width * rawMemText.Height; ++index)
{
channels[0].ImageData[index] = rawMemText.Data[index].R;
channels[1].ImageData[index] = rawMemText.Data[index].G;
channels[2].ImageData[index] = rawMemText.Data[index].B;
channels[3].ImageData[index] = rawMemText.Data[index].A;
}
foreach (var channel in layer.Channels)
{
channel.ImageDataRaw = null;
}
}
}
psd.PrepareSave();
psd.Save("processed.psd", Encoding.Unicode);
}
public void ConcavShapeTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(65, 60, 55, 61);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(89, 67));
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
private ResultStatus Import(ICommandContext commandContext, TextureTool textureTool, TexImage texImage, TextureHelper.ImportParameters convertParameters)
{
var assetManager = new ContentManager(MicrothreadLocalDatabases.ProviderService);
var useSeparateDataContainer = TextureHelper.ShouldUseDataContainer(Parameters.IsStreamable, texImage.Dimension);
// Note: for streamable textures we want to store mip maps in a separate storage container and read them on request instead of whole asset deserialization (at once)
return useSeparateDataContainer
? TextureHelper.ImportStreamableTextureImage(assetManager, textureTool, texImage, convertParameters, CancellationToken, commandContext)
: TextureHelper.ImportTextureImage(assetManager, textureTool, texImage, convertParameters, CancellationToken, commandContext.Logger);
}
public void ConvexShapeTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(10, 4, 36, 38);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(29, 23));
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
private static void ResizeLayerLibrary()
{
int currentFrameSizeX = 32;
int currentFrameSizeY = 40;
int newFrameSizeX = 48;
int newFrameSizeY = 40;
foreach (var layer in Layers)
{
var rawTexture = AssetManager.GetContentTexture(layer.Asset);
var memTexture = TextureTool.MemoryTextureFromTexture2D(rawTexture);
int num_frames_x = memTexture.Width / currentFrameSizeX;
int num_frames_y = memTexture.Height / currentFrameSizeY;
int currentWidth = memTexture.Width;
int currentHeight = memTexture.Height;
Color[] newColor = new Color[(num_frames_x * newFrameSizeX) * (num_frames_y * newFrameSizeY)];
int newWidth = (num_frames_x * newFrameSizeX);
int newHeight = (num_frames_y * newFrameSizeY);
for (int frameX = 0; frameX < num_frames_x; frameX++)
{
for (int frameY = 0; frameY < num_frames_y; frameY++)
{
int currentFrameStartX = frameX * currentFrameSizeX;
int currentFrameStartY = frameY * currentFrameSizeY;
int newFrameStartX = frameX * newFrameSizeX;
int newFrameStartY = frameY * newFrameSizeY;
for (int px = 0; px < currentFrameSizeX; px++)
{
for (int py = 0; py < currentFrameSizeY; py++)
{
int newPX = newFrameSizeX / 2 - currentFrameSizeX / 2 + px;
int newPY = newFrameSizeY / 2 - currentFrameSizeY / 2 + py;
int currentPixelX = px + currentFrameStartX;
int currentPixelY = py + currentFrameStartY;
int newPixelX = newPX + newFrameStartX;
int newPixelY = newPY + newFrameStartY;
newColor[newPixelX + newPixelY * newWidth] = memTexture.Data[currentPixelX + currentPixelY * currentWidth];
}
}
}
}
Texture2D newTexture = new Texture2D(GameStates.GameState.Game.GraphicsDevice, newWidth, newHeight);
newTexture.SetData(newColor);
using (System.IO.FileStream fs = new System.IO.FileStream(System.IO.Path.GetFileName(layer.Asset) + "_resized.png", System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write))
{
newTexture.SaveAsPng(fs, newWidth, newHeight);
}
}
System.Environment.Exit(0);
}
public void ConcavShapeTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(65, 60, 55, 61);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(89, 67));
Assert.Equal(theoreticalRegion, foundRegion);
}
}
public void IncludedShapeTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(70, 83, 32, 14);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(85, 85));
Assert.Equal(theoreticalRegion, foundRegion);
}
}
protected override Task<ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
var convertParameters = new TextureHelper.ImportParameters(Parameters) { OutputUrl = Url };
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Parameters.SourcePathFromDisk, convertParameters.IsSRgb))
{
var importResult = Import(commandContext, texTool, texImage, convertParameters);
return Task.FromResult(importResult);
}
}
public void EmptyRegionTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
CheckEmptyRegion(texTool, texImage, new Int2(-1, 5));
CheckEmptyRegion(texTool, texImage, new Int2(1000, 5));
CheckEmptyRegion(texTool, texImage, new Int2(4, -5));
CheckEmptyRegion(texTool, texImage, new Int2(4, 5000));
CheckEmptyRegion(texTool, texImage, new Int2(2, 2));
}
}
public void EmptyRegionTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
CheckEmptyRegion(texTool, texImage, new Int2(-1, 5));
CheckEmptyRegion(texTool, texImage, new Int2(1000, 5));
CheckEmptyRegion(texTool, texImage, new Int2(4, -5));
CheckEmptyRegion(texTool, texImage, new Int2(4, 5000));
CheckEmptyRegion(texTool, texImage, new Int2(2, 2));
}
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var sources = parameters.Tags.Get(SourceFilesPathKey);
if (sources == null)
{
return(base.CreateAssets(parameters));
}
SpriteSheetAsset asset;
if (parameters.Description.Id == SpriteSheetId)
{
asset = SpriteSheetSprite2DFactory.Create();
}
else if (parameters.Description.Id == UISpriteSheetId)
{
asset = SpriteSheetUIFactory.Create();
}
else
{
throw new ArgumentException("Invalid template description for this generator.");
}
using (var textureTool = new TextureTool())
{
foreach (var source in sources)
{
int width = 0;
int height = 0;
parameters.Logger.Verbose($"Processing image \"{source}\"");
try
{
var image = textureTool.Load(source.ToString(), false);
width = image.Width;
height = image.Height;
}
catch (Exception)
{
parameters.Logger.Warning($"Unable to retrieve the size of \"{source}\"");
}
var spriteInfo = new SpriteInfo
{
Name = source.GetFileNameWithoutExtension(),
TextureRegion = new Rectangle(0, 0, width, height),
Source = source
};
asset.Sprites.Add(spriteInfo);
}
}
return(new AssetItem(GenerateLocation(parameters), asset).Yield());
}
public void GetAlphaLevelTests()
{
var testEntries = new List <AlphaLevelTest>
{
// transparency color tests
new AlphaLevelTest(new Rectangle(12, 12, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(11, 12, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// last pixel test
new AlphaLevelTest(new Rectangle(52, 54, 12, 10), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// region out of bound tests
new AlphaLevelTest(new Rectangle(120, 12, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(12, 120, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(120, 120, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(51, 56, 10, 180), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(51, 56, 100, 7), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(51, 56, 100, 70), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// all image test
new AlphaLevelTest(new Rectangle(0, 0, 64, 64), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// single pixel tests
new AlphaLevelTest(new Rectangle(0, 0, 1, 1), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
new AlphaLevelTest(new Rectangle(12, 12, 1, 1), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
// normal transparency channel tests
new AlphaLevelTest(new Rectangle(0, 0, 5, 6), null, AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(12, 12, 18, 18), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(1, 30, 5, 14), null, AlphaLevels.MaskAlpha),
new AlphaLevelTest(new Rectangle(1, 30, 6, 14), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(6, 30, 6, 14), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(1, 47, 5, 14), null, AlphaLevels.MaskAlpha),
new AlphaLevelTest(new Rectangle(1, 47, 6, 14), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(6, 47, 6, 14), null, AlphaLevels.InterpolatedAlpha)
};
var images = new[] { "TransparentRGBA.dds", "TransparentBGRA.dds" };
foreach (var image in images)
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + image))
{
foreach (var entry in testEntries)
{
var result = texTool.GetAlphaLevels(texImage, entry.Region, entry.TransparencyColor);
Assert.Equal(entry.ExpectedResult, result);
}
}
}
}
private void BlitSheet(TextureAtlas.SpriteAtlasEntry Sheet, Texture2D Into)
{
Sheet.NeedsBlitToAtlas = false;
var memTexture = TextureTool.MemoryTextureFromTexture2D(Sheet.SourceTexture);
if (Sheet.SourceDefinition.Type == TileSheetType.VariableWidthFont)
{
memTexture.Filter(c => (c.R == 0 && c.G == 0 && c.B == 0) ? new Color(0, 0, 0, 0) : c);
}
Into.SetData(0, Sheet.AtlasBounds, memTexture.Data, 0, memTexture.Width * memTexture.Height);
}
private void SaveAndCompareTexture(Image outputImage, string fileName, ImageFileType extension = ImageFileType.Png)
{
// save
Directory.CreateDirectory(ImageOutputPath);
outputImage.Save(new FileStream(ImageOutputPath + fileName + extension.ToFileExtension(), FileMode.Create), extension);
// Compare
using (var texTool = new TextureTool())
{
var referenceImage = LoadImage(texTool, new UFile(GoldImagePath + "/" + fileName + extension.ToFileExtension()));
Assert.True(CompareImages(outputImage, referenceImage), "The texture outputted differs from the gold image.");
}
}
public void TransversalLineTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(1, 8, 13, 15);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(3, 18));
Assert.AreEqual(theoreticalRegion, foundRegion);
foundRegion = texTool.FindSpriteRegion(texImage, new Int2(13, 8));
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
/// <summary>
/// Loads image from a path with texTool
/// </summary>
/// <param name="texTool">A tool for loading an image</param>
/// <param name="sourcePath">Source path of an image</param>
/// <param name="isSRgb">Indicate if the texture to load is sRGB</param>
/// <returns></returns>
private static Image LoadImage(TextureTool texTool, UFile sourcePath, bool isSRgb)
{
using (var texImage = texTool.Load(sourcePath, isSRgb))
{
texTool.Decompress(texImage, isSRgb);
if (texImage.Format == PixelFormat.B8G8R8A8_UNorm || texImage.Format == PixelFormat.B8G8R8A8_UNorm_SRgb)
{
texTool.SwitchChannel(texImage);
}
return(texTool.ConvertToXenkoImage(texImage));
}
}
public void TransversalLineTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(1, 8, 13, 15);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(3, 18));
Assert.Equal(theoreticalRegion, foundRegion);
foundRegion = texTool.FindSpriteRegion(texImage, new Int2(13, 8));
Assert.Equal(theoreticalRegion, foundRegion);
}
}
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
var convertParameters = new TextureHelper.ImportParameters(AssetParameters)
{
OutputUrl = Url
};
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(AssetParameters.SourcePathFromDisk, convertParameters.IsSRgb))
{
var importResult = TextureHelper.ImportTextureImage(texTool, texImage, convertParameters, CancellationToken, commandContext.Logger);
return(Task.FromResult(importResult));
}
}
public TexThread(string[] fileList, int num)
{
this.fileList = fileList;
texTool = new TextureTool();
this.num = num;
}
public void PickColorTest()
{
var pixelCoordinate1 = new Int2(4, 4);
var theoreticalColor1 = new Color(0, 255, 46, 255);
var pixelCoordinate2 = new Int2(3, 4);
var theoreticalColor2 = new Color(222, 76, 255, 255);
var images = new[] { "BgraSheet.dds", "RgbaSheet.dds" };
foreach (var image in images)
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + image))
{
var foundColor = texTool.PickColor(texImage, pixelCoordinate1);
Assert.AreEqual(theoreticalColor1, foundColor);
foundColor = texTool.PickColor(texImage, pixelCoordinate2);
Assert.AreEqual(theoreticalColor2, foundColor);
}
}
}
public void ShapeWithHoleTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(49, 1, 76, 53);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(52, 29));
Assert.AreEqual(theoreticalRegion, foundRegion);
foundRegion = texTool.FindSpriteRegion(texImage, new Int2(58, 30));
Assert.AreEqual(theoreticalRegion, foundRegion);
foundRegion = texTool.FindSpriteRegion(texImage, new Int2(75, 32));
Assert.AreEqual(theoreticalRegion, foundRegion);
foundRegion = texTool.FindSpriteRegion(texImage, new Int2(84, 28));
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
public void SetUp()
{
texTool = new TextureTool();
}
public void GetAlphaLevelTests()
{
var testEntries = new List<AlphaLevelTest>
{
// transparency color tests
new AlphaLevelTest(new Rectangle(12, 12, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(11, 12, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// last pixel test
new AlphaLevelTest(new Rectangle(52, 54, 12, 10), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// region out of bound tests
new AlphaLevelTest(new Rectangle(120, 12, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(12, 120, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(120, 120, 18, 18), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(51, 56, 10, 180), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(51, 56, 100, 7), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(51, 56, 100, 70), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// all image test
new AlphaLevelTest(new Rectangle(0, 0, 64, 64), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
// single pixel tests
new AlphaLevelTest(new Rectangle(0, 0, 1, 1), new Color(255, 81, 237, 255), AlphaLevels.MaskAlpha),
new AlphaLevelTest(new Rectangle(12, 12, 1, 1), new Color(255, 81, 237, 255), AlphaLevels.NoAlpha),
// normal transparency channel tests
new AlphaLevelTest(new Rectangle(0, 0, 5, 6), null, AlphaLevels.NoAlpha),
new AlphaLevelTest(new Rectangle(12, 12, 18, 18), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(1, 30, 5, 14), null, AlphaLevels.MaskAlpha),
new AlphaLevelTest(new Rectangle(1, 30, 6, 14), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(6, 30, 6, 14), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(1, 47, 5, 14), null, AlphaLevels.MaskAlpha),
new AlphaLevelTest(new Rectangle(1, 47, 6, 14), null, AlphaLevels.InterpolatedAlpha),
new AlphaLevelTest(new Rectangle(6, 47, 6, 14), null, AlphaLevels.InterpolatedAlpha)
};
var images = new[] { "TransparentRGBA.dds", "TransparentBGRA.dds" };
foreach (var image in images)
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + image))
{
foreach (var entry in testEntries)
{
var result = texTool.GetAlphaLevels(texImage, entry.Region, entry.TransparencyColor);
Assert.AreEqual(entry.ExpectedResult, result);
}
}
}
}
private void CheckEmptyRegion(TextureTool tool, TexImage image, Int2 position)
{
var theoreticalRegion = new Rectangle(position.X, position.Y, 0, 0);
var foundRegion = tool.FindSpriteRegion(image, position);
Assert.AreEqual(theoreticalRegion, foundRegion);
}
public void IncludedShapeTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "TransparentSheet.dds"))
{
var theoreticalRegion = new Rectangle(70, 83, 32, 14);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(85, 85));
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
public void BgraRgbaTest()
{
var images = new[] { "BgraSheet.dds", "RgbaSheet.dds" };
foreach (var image in images)
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + image))
{
var theoreticalRegion = new Rectangle(4, 4, 1, 1);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(4, 4), transparencyColorKey, 0xffffffff);
Assert.AreEqual(theoreticalRegion, foundRegion);
theoreticalRegion = new Rectangle(6, 7, 30, 20);
foundRegion = texTool.FindSpriteRegion(texImage, new Int2(23, 13), transparencyColorKey, 0xffffffff);
Assert.AreEqual(theoreticalRegion, foundRegion);
theoreticalRegion = new Rectangle(16, 28, 45, 31);
foundRegion = texTool.FindSpriteRegion(texImage, new Int2(42, 45), transparencyColorKey, 0xffffffff);
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
}
public void TransparencyKeyTest()
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + "BgraSheet.dds"))
{
var theoreticalRegion = new Rectangle(25, 25, 0, 0);
var foundRegion = texTool.FindSpriteRegion(texImage, new Int2(25, 25), transparencyColorKey, 0xffffffff);
Assert.AreEqual(theoreticalRegion, foundRegion);
}
}
