public static ObservableCollection <Layer> ToLayers(this SerializableDocument serializableDocument)
{
ObservableCollection <Layer> layers = new ObservableCollection <Layer>();
for (int i = 0; i < serializableDocument.Layers.Count; i++)
{
SerializableLayer serLayer = serializableDocument.Layers[i];
Layer layer =
new Layer(serLayer.Name, BitmapUtils.BytesToWriteableBitmap(serLayer.Width, serLayer.Height, serLayer.BitmapBytes))
{
IsVisible = serLayer.IsVisible,
Offset = new Thickness(serLayer.OffsetX, serLayer.OffsetY, 0, 0),
Opacity = serLayer.Opacity,
MaxHeight = serializableDocument.Height,
MaxWidth = serializableDocument.Width,
};
if (serLayer.LayerGuid != Guid.Empty)
{
layer.ChangeGuid(serLayer.LayerGuid);
}
layers.Add(layer);
}
return(layers);
}
public static Layer ToLayer(this SerializableLayer layer, int maxWidth, int maxHeight)
{
return(new Layer(layer.Name, new Surface(layer.ToSKImage()), maxWidth, maxHeight)
{
Opacity = layer.Opacity,
IsVisible = layer.IsVisible,
Offset = new(layer.OffsetX, layer.OffsetY, 0, 0),
});
/// <summary>
/// Encodes the <paramref name="image"/> into the png bytes of the layer
/// </summary>
/// <param name="bitmap">The bitmap that should be encoded</param>
/// <returns><paramref name="image"/></returns>
public static SerializableLayer FromSKImage(this SerializableLayer layer, SKImage image)
{
using SKData data = image.Encode();
layer.PngBytes = data.AsSpan().ToArray();
layer.Width = image.Width;
layer.Height = image.Height;
return(layer);
}
/// <summary>
/// Encodes the <paramref name="bitmap"/> into the png bytes of the layer
/// </summary>
/// <param name="bitmap">The bitmap that should be encoded</param>
/// <returns><paramref name="layer"/></returns>
public static SerializableLayer FromSKBitmap(this SerializableLayer layer, SKBitmap bitmap)
{
using SKData data = bitmap.Encode(SKEncodedImageFormat.Png, 100);
layer.PngBytes = data.AsSpan().ToArray();
layer.Width = bitmap.Width;
layer.Height = bitmap.Height;
return(layer);
}
public void CanCreateSKImageFromLayer()
{
SerializableDocument document = PixiParser.Deserialize("./Files/16x16,PPD-3.pixi");
SerializableLayer layer = document.Layers[0];
using SKImage image = layer.ToSKImage();
Assert.Equal(layer.Width, image.Width);
}
public ObservableCollection <Layer> ToLayers()
{
ObservableCollection <Layer> layers = new ObservableCollection <Layer>();
for (int i = 0; i < Layers.Length; i++)
{
SerializableLayer serLayer = Layers[i];
Layer layer =
new Layer(serLayer.Name, BitmapUtils.BytesToWriteableBitmap(serLayer.Width, serLayer.Height, serLayer.BitmapBytes))
{
IsVisible = serLayer.IsVisible,
Offset = new Thickness(serLayer.OffsetX, serLayer.OffsetY, 0, 0),
Opacity = serLayer.Opacity
};
layers.Add(layer);
}
return(layers);
}
public static SerializableLayer ToSerializable(this Layer layer)
{
SerializableLayer serializable = new SerializableLayer
{
LayerGuid = layer.LayerGuid,
Name = layer.Name,
Width = layer.Width,
Height = layer.Height,
BitmapBytes = layer.ConvertBitmapToBytes(),
IsVisible = layer.IsVisible,
OffsetX = (int)layer.Offset.Left,
OffsetY = (int)layer.Offset.Top,
Opacity = layer.Opacity,
MaxWidth = layer.MaxWidth,
MaxHeight = layer.MaxHeight
};
return(serializable);
}
public void LayerStructureWorks()
{
SerializableDocument document = new();
SerializableLayer layer1 = document.Layers.Add("Test Layer 1");
SerializableLayer layer2 = document.Layers.Add("Test Layer 2");
SerializableLayer layer3 = document.Layers.Add("Test Layer 3");
SerializableLayer layer4 = document.Layers.Add("Test Layer 4");
SerializableGroup group1 = new("Group 1");
SerializableGroup group2 = new("Group 1|1");
group1.Subgroups.Add(group2);
SerializableGroup group3 = new("Group 2");
document.Groups.Add(group1);
document.Groups.Add(group2);
document.Groups.Add(group3);
document.Layers.AddToGroup(group1, layer1);
document.Layers.AddToGroup(group2, layer2);
document.Layers.AddToGroup(group1, layer3);
document.Layers.AddToGroup(group3, layer4);
Assert.Equal(0, document.Groups[0].StartLayer);
Assert.Equal(2, document.Groups[0].EndLayer);
Assert.Equal(1, document.Groups[1].StartLayer);
Assert.Equal(1, document.Groups[1].EndLayer);
Assert.Equal(3, document.Groups[2].StartLayer);
Assert.Equal(3, document.Groups[2].EndLayer);
Assert.True(document.Layers.ContainedIn(group1, layer1));
Assert.True(document.Layers.ContainedIn(group1, layer2));
Assert.True(document.Layers.ContainedIn(group1, layer3));
Assert.True(document.Layers.ContainedIn(group2, layer2));
Assert.False(document.Layers.ContainedIn(group1, layer4));
Assert.True(document.Layers.ContainedIn(group3, layer4));
}
public void SerializingAndDeserialzingWorks()
{
SerializableDocument document = new()
{
Height = 1,
Width = 1
};
document.Swatches.Add(255, 255, 255);
SerializableLayer layer = document.Layers.Add("Base Layer", 1, 1, false, 0.5f, 1, 1);
layer.PngBytes = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF };
document.Groups.Add(new SerializableGroup("Base Group"));
byte[] serialized = PixiParser.Serialize(document);
SerializableDocument deserializedDocument = PixiParser.Deserialize(serialized);
AssertEqual(document, deserializedDocument);
}
public static SerializableDocument CreateDocument(int size, int layers, bool encodePng = true)
{
var benchmarkDocument = new SerializableDocument()
{
Width = size,
Height = size
};
benchmarkDocument.Swatches.Add(255, 255, 255, 255);
for (int i = 0; i < layers; i++)
{
var layer = new SerializableLayer(size, size);
if (encodePng)
{
layer.FromSKBitmap(CreateSKBitmap(size));
}
benchmarkDocument.Layers.Add(layer);
}
return(benchmarkDocument);
}
public static double GetFinalOpacity(this SerializableLayer layer, SerializableDocument document) => document.Layers.GetFinalLayerOpacity(layer);
public static bool GetFinalVisibility(this SerializableLayer layer, SerializableDocument document) => document.Layers.GetFinalLayerVisibilty(layer);
/// <summary> /// Creates a new <see cref="SKImage"/> from the png bytes of the layer /// </summary> public static SKImage ToSKImage(this SerializableLayer layer) => SKImage.FromEncodedData(layer.PngBytes);
/// <summary> /// Creates a new <see cref="SKBitmap"/> from the png bytes of the layer /// </summary> public static SKBitmap ToSKBitmap(this SerializableLayer layer) => SKBitmap.Decode(layer.PngBytes, new SKImageInfo(layer.Width, layer.Height));
