public void Color_Types_From_Vector3_Produce_Equal_Scaled_Component_OutPut()
{
Rgba32 color = new Rgba32(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
RgbaVector colorVector = new RgbaVector(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
Assert.Equal(color.B, (byte)(colorVector.B * 255));
Assert.Equal(color.A, (byte)(colorVector.A * 255));
}
public void Color_Types_From_Floats_Produce_Equal_Scaled_Component_OutPut()
{
var color = new Rgba32(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
Assert.Equal(color.B, (byte)(colorVector.B * 255));
Assert.Equal(color.A, (byte)(colorVector.A * 255));
}
public void Color_Types_From_Bytes_Produce_Equal_Scaled_Component_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
Assert.Equal(color.B, (byte)(colorVector.B * 255));
Assert.Equal(color.A, (byte)(colorVector.A * 255));
}
public void Color_Types_From_Hex_Produce_Equal_Scaled_Component_OutPut()
{
var color = Rgba32.FromHex("183060C0");
var colorVector = RgbaVector.FromHex("183060C0");
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
Assert.Equal(color.B, (byte)(colorVector.B * 255));
Assert.Equal(color.A, (byte)(colorVector.A * 255));
}
public void Color_Types_To_BgraBytes_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
byte[] bgra = new byte[4];
byte[] bgraVector = new byte[4];
color.ToZyxwBytes(bgra, 0);
colorVector.ToZyxwBytes(bgraVector, 0);
Assert.Equal(bgra, bgraVector);
}
public void Color_Types_To_RgbBytes_Produce_Equal_OutPut()
{
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
var rgb = default(Rgb24);
var rgbVector = default(Rgb24);
color.ToRgb24(ref rgb);
colorVector.ToRgb24(ref rgbVector);
Assert.Equal(rgb, rgbVector);
}
public void Color_Types_To_RgbaBytes_Produce_Equal_OutPut()
{
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
Rgba32 rgba = default;
Rgba32 rgbaVector = default;
color.ToRgba32(ref rgba);
colorVector.ToRgba32(ref rgbaVector);
Assert.Equal(rgba, rgbaVector);
}
public void FloatLayout()
{
var color = new RgbaVector(1F, 2, 3, 4);
Vector4 colorBase = Unsafe.As <RgbaVector, Vector4>(ref Unsafe.Add(ref color, 0));
float[] ordered = new float[4];
colorBase.CopyTo(ordered);
Assert.Equal(1, ordered[0]);
Assert.Equal(2, ordered[1]);
Assert.Equal(3, ordered[2]);
Assert.Equal(4, ordered[3]);
}
public void AreNotEqual()
{
var color1 = new RgbaVector(1, 0, 0, 1);
var color2 = new RgbaVector(0, 0, 0, 1);
var color3 = RgbaVector.FromHex("#000");
var color4 = RgbaVector.FromHex("#000000");
var color5 = RgbaVector.FromHex("#FF000000");
Assert.NotEqual(color1, color2);
Assert.NotEqual(color1, color3);
Assert.NotEqual(color1, color4);
Assert.NotEqual(color1, color5);
}
public void Color_Types_To_BgraBytes_Produce_Equal_OutPut()
{
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
var bgra = default(Bgra32);
var bgraVector = default(Bgra32);
color.ToBgra32(ref bgra);
colorVector.ToBgra32(ref bgraVector);
Assert.Equal(bgra, bgraVector);
}
public void Color_Types_To_RgbaBytes_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
byte[] rgba = new byte[4];
byte[] rgbaVector = new byte[4];
color.ToXyzwBytes(rgba, 0);
colorVector.ToXyzwBytes(rgbaVector, 0);
Assert.Equal(rgba, rgbaVector);
}
public void AreEqual()
{
var color1 = new RgbaVector(0, 0, 0F);
var color2 = new RgbaVector(0, 0, 0, 1F);
var color3 = RgbaVector.FromHex("#000");
var color4 = RgbaVector.FromHex("#000F");
var color5 = RgbaVector.FromHex("#000000");
var color6 = RgbaVector.FromHex("#000000FF");
Assert.Equal(color1, color2);
Assert.Equal(color1, color3);
Assert.Equal(color1, color4);
Assert.Equal(color1, color5);
Assert.Equal(color1, color6);
}
public void ConstructorAssignsProperties()
{
var color1 = new RgbaVector(1, .1F, .133F, .864F);
Assert.Equal(1F, color1.R);
Assert.Equal(.1F, color1.G);
Assert.Equal(.133F, color1.B);
Assert.Equal(.864F, color1.A);
var color2 = new RgbaVector(1, .1f, .133f);
Assert.Equal(1F, color2.R);
Assert.Equal(.1F, color2.G);
Assert.Equal(.133F, color2.B);
Assert.Equal(1F, color2.A);
}
public void FromAndToHex()
{
var color = RgbaVector.FromHex("#AABBCCDD");
Assert.Equal(170 / 255F, color.R);
Assert.Equal(187 / 255F, color.G);
Assert.Equal(204 / 255F, color.B);
Assert.Equal(221 / 255F, color.A);
color.A = 170 / 255F;
color.B = 187 / 255F;
color.G = 204 / 255F;
color.R = 221 / 255F;
Assert.Equal("DDCCBBAA", color.ToHex());
color.R = 0;
Assert.Equal("00CCBBAA", color.ToHex());
color.A = 255 / 255F;
Assert.Equal("00CCBBFF", color.ToHex());
}
public void ColorBurn()
{
RgbaVector colorBurn = RgbaVector.ColorBurn(Backdrop, Source);
Assert.Equal(colorBurn.ToVector4(), new RgbaVector(0, 0, 0).ToVector4(), FloatComparer);
}
public void Darken()
{
RgbaVector darken = RgbaVector.Darken(Backdrop, Source);
Assert.Equal(darken.ToVector4(), new RgbaVector(0, 102, 0).ToVector4(), FloatComparer);
}
public void Exclusion()
{
RgbaVector exclusion = RgbaVector.Exclusion(Backdrop, Source);
Assert.Equal(exclusion.ToVector4(), new RgbaVector(204, 122, 153).ToVector4(), FloatComparer);
}
public void Difference()
{
RgbaVector difference = RgbaVector.Difference(Backdrop, Source);
Assert.Equal(difference.ToVector4(), new RgbaVector(204, 0, 153).ToVector4(), FloatComparer);
}
public void Normal()
{
RgbaVector normal = RgbaVector.Normal(Backdrop, Source);
Assert.True(normal == Source);
}
public void HardLight()
{
RgbaVector hardLight = RgbaVector.HardLight(Backdrop, Source);
Assert.Equal(hardLight.ToVector4(), new RgbaVector(0, 82, 51).ToVector4(), FloatComparer);
}
public void Overlay()
{
RgbaVector overlay = RgbaVector.Overlay(Backdrop, Source);
Assert.Equal(overlay.ToVector4(), new RgbaVector(153, 82, 0).ToVector4(), FloatComparer);
}
public void SoftLight()
{
RgbaVector softLight = RgbaVector.SoftLight(Backdrop, Source);
Assert.Equal(softLight.ToVector4(), new RgbaVector(163, 90, 0).ToVector4(), FloatComparer);
}
public void ColorDodge()
{
RgbaVector colorDodge = RgbaVector.ColorDodge(Backdrop, Source);
Assert.Equal(colorDodge.ToVector4(), new RgbaVector(204, 170, 0).ToVector4(), FloatComparer);
}
public void Lighten()
{
RgbaVector lighten = RgbaVector.Lighten(Backdrop, Source);
Assert.Equal(lighten.ToVector4(), new RgbaVector(204, 102, 153).ToVector4(), FloatComparer);
}
public override TextureContent Process(TextureContent input, ContentProcessorContext context)
{
if (input.Faces[0][0].TryGetFormat(out SurfaceFormat format))
{
// If it is already a compressed format, we cannot do anything else so just return it
if (format.IsCompressedFormat())
{
return(input);
}
}
if (ColorKeyEnabled || ResizeToPowerOfTwo || MakeSquare || PremultiplyAlpha || GenerateMipmaps)
{
// Convert to floating point format for modifications. Keep the original format for conversion back later on if required.
var originalType = input.Faces[0][0].GetType();
try
{
input.ConvertBitmapType(typeof(PixelBitmapContent <RgbaVector>));
}
catch (Exception ex)
{
context.Logger.LogImportantMessage("Could not convert input texture for processing. " + ex.ToString());
throw;
}
if (GenerateMipmaps)
{
input.GenerateMipmaps(true);
}
for (int f = 0; f < input.Faces.Count; ++f)
{
var face = input.Faces[f];
for (int m = 0; m < face.Count; ++m)
{
var bmp = (PixelBitmapContent <RgbaVector>)face[m];
if (ColorKeyEnabled)
{
var original = new RgbaVector(); // TODO: UNsafe.SkipInit
original.FromScaledVector(ColorKeyColor.ToScaledVector4());
bmp.ReplaceColor(original, new RgbaVector(0, 0, 0, 0));
}
if (ResizeToPowerOfTwo)
{
if (!GraphicsUtil.IsPowerOfTwo(bmp.Width) ||
!GraphicsUtil.IsPowerOfTwo(bmp.Height) ||
(MakeSquare && bmp.Height != bmp.Width))
{
var newWidth = GraphicsUtil.GetNextPowerOfTwo(bmp.Width);
var newHeight = GraphicsUtil.GetNextPowerOfTwo(bmp.Height);
if (MakeSquare)
{
newWidth = newHeight = Math.Max(newWidth, newHeight);
}
var resized = new PixelBitmapContent <RgbaVector>(newWidth, newHeight);
BitmapContent.Copy(bmp, resized);
bmp = resized;
}
}
else if (MakeSquare && bmp.Height != bmp.Width)
{
var newSize = Math.Max(bmp.Width, bmp.Height);
var resized = new PixelBitmapContent <RgbaVector>(newSize, newSize);
BitmapContent.Copy(bmp, resized);
}
if (PremultiplyAlpha)
{
var pixels = bmp.GetPixelSpan();
for (int i = 0; i < pixels.Length; i++)
{
ref RgbaVector pixel = ref pixels[i];
pixel.R *= pixel.A;
pixel.G *= pixel.A;
pixel.B *= pixel.A;
}
}
face[m] = bmp;
}
}
// If no change to the surface format was desired, change it back now before it early outs
if (TextureFormat == TextureProcessorOutputFormat.NoChange)
{
input.ConvertBitmapType(originalType);
}
}
