public BGRA Lerp(BGRA color1, int factor1, BGRA color2, int factor2, BGRA color3, int factor3)
{
int alphaFactor1 = factor1;
int alphaFactor2 = factor2;
int alphaFactor3 = factor3;
if (color1.A == 0)
{
factor1 = 0;
}
if (color2.A == 0)
{
factor2 = 0;
}
if (color3.A == 0)
{
factor3 = 0;
}
if (factor1 == 0 && factor2 == 0 && factor3 == 0)
{
return(color1);
}
return(BGRA.FromArgb(
LerpChannel(color1.A, alphaFactor1, color2.A, alphaFactor2, color3.A, alphaFactor3),
LerpChannel(color1.R, factor1, color2.R, factor2, color3.R, factor3),
LerpChannel(color1.G, factor1, color2.G, factor2, color3.G, factor3),
LerpChannel(color1.B, factor1, color2.B, factor2, color3.B, factor3)
));
}
public StaticLight(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
Type = (LightType)br.ReadByte();
UseAttenuation = br.ReadBoolean();
UseUnknown1 = br.ReadBoolean();
UseUnknown2 = br.ReadBoolean();
Colour = br.ReadBGRA();
Position = br.ReadVector3();
Intensity = br.ReadSingle();
AttenuationStartRadius = br.ReadSingle();
AttenuationEndRadius = br.ReadSingle();
Unknown1StartRadius = br.ReadSingle();
Unknown1EndRadius = br.ReadSingle();
Unknown2StartRadius = br.ReadSingle();
Unknown2EndRadius = br.ReadSingle();
}
}
}
/// <summary>
/// Writes a 4-byte <see cref="ARGB"/> value to the data stream.
/// </summary>
/// <param name="binaryWriter">The current <see cref="BinaryWriter"/> object.</param>
/// <param name="argb">The ARGB value to write.</param>
public static void WriteARGB(this BinaryWriter binaryWriter, BGRA argb)
{
binaryWriter.Write(argb.A);
binaryWriter.Write(argb.R);
binaryWriter.Write(argb.G);
binaryWriter.Write(argb.B);
}
/// <summary>
/// Writes a 4-byte <see cref="BGRA"/> value to the data stream.
/// </summary>
/// <param name="binaryWriter">The current <see cref="BinaryWriter"/> object.</param>
/// <param name="bgra">The BGRA value to write.</param>
public static void WriteBGRA(this BinaryWriter binaryWriter, BGRA bgra)
{
binaryWriter.Write(bgra.B);
binaryWriter.Write(bgra.G);
binaryWriter.Write(bgra.R);
binaryWriter.Write(bgra.A);
}
public static Image ColorizeDepthImage(Image depthImage, Tuple <int, int> expectedValueRange)
{
ImageFormat imageFormat = depthImage.Format;
if (imageFormat != ImageFormat.Depth16 && imageFormat != ImageFormat.IR16)
{
throw new Exception("Attempted to colorize a non-depth image!");
}
int width = depthImage.WidthPixels;
int height = depthImage.HeightPixels;
Image colorizedDepthImage = new Image(ImageFormat.ColorBGRA32, width, height);
for (int h = 0; h < height; ++h)
{
for (int w = 0; w < width; ++w)
{
BGRA colorDepthPixel = new BGRA(0, 0, 0, 0);
colorDepthPixel = ColorizeBlueToRed(depthImage.GetPixel <short>(h, w), expectedValueRange);
colorizedDepthImage.SetPixel <BGRA>(h, w, colorDepthPixel);
}
}
return(colorizedDepthImage);
}
public static IImage <BGRA> ToBgra(IImage <double> blue, IImage <double> green, IImage <double> red, IImage <double> alpha)
{
CheckEqualDimensions(blue, green, red, alpha);
// Normalize to [0 - 255]
blue = blue.Normalize256();
green = green.Normalize256();
red = red.Normalize256();
alpha = alpha.Normalize256();
// Construct BGRA values
BGRA[] data = new BGRA[blue.Length];
Parallel.For(0, blue.Length, i =>
{
data[i] = new BGRA()
{
B = (byte)blue[i],
G = (byte)green[i],
R = (byte)red[i],
A = (byte)alpha[i]
};
});
return(new BgraImage(blue.Width, blue.Height, data));
}
private static unsafe void MakeBackgroundTransparent(Bitmap bitmap, BGRA background)
{
Debug.Assert(bitmap.PixelFormat == PixelFormat.Format32bppArgb);
int width = bitmap.Width;
int height = bitmap.Height;
var data = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
try
{
for (int y = 0; y < height; y++)
{
var pData = (BGRA *)((byte *)data.Scan0 + y * data.Stride);
for (int x = 0; x < width; x++)
{
var col = pData[x];
if (col == background)
{
*(int *)(pData + x) = 0; //transparent
}
}
}
}
finally
{
bitmap.UnlockBits(data);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FogDefinition"/> class.
/// </summary>
/// <param name="inData">The binary data.</param>
public FogDefinition(byte[] inData)
{
using var ms = new MemoryStream(inData);
using var br = new BinaryReader(ms);
EndRadius = br.ReadSingle();
StartMultiplier = br.ReadSingle();
Colour = br.ReadBGRA();
}
public BGRA Lerp(BGRA color1, int factor1, BGRA color2, int factor2, BGRA color3, int factor3)
{
return(BGRA.FromArgb(
LerpChannel(color1.R, factor1, color2.R, factor2, color3.R, factor3),
LerpChannel(color1.G, factor1, color2.G, factor2, color3.G, factor3),
LerpChannel(color1.B, factor1, color2.B, factor2, color3.B, factor3)
));
}
private static Color32 Convert32(BGRA c)
{
return(new Color32(
c.R,
c.G,
c.B,
c.A
));
}
public void TestBgraStruct()
{
BGRA black = BGRA.Black;
int blackInt32 = black;
UInt32 blackUInt32 = black;
Assert.IsTrue(((BGRA)blackInt32) == black);
Assert.IsTrue(((BGRA)blackUInt32) == black);
}
private static BGRA ReadBGRA(Stream stream)
{
BGRA BGRAColor = new BGRA();
BGRAColor.B = (byte)stream.ReadByte();
BGRAColor.G = (byte)stream.ReadByte();
BGRAColor.R = (byte)stream.ReadByte();
BGRAColor.A = (byte)stream.ReadByte();
return(BGRAColor);
}
/// <summary>
/// Reads a 4-byte BGRA value from the data stream.
/// </summary>
/// <returns>The argument.</returns>
/// <param name="binaryReader">binaryReader.</param>
public static BGRA ReadBGRA(this BinaryReader binaryReader)
{
byte b = binaryReader.ReadByte();
byte g = binaryReader.ReadByte();
byte r = binaryReader.ReadByte();
byte a = binaryReader.ReadByte();
BGRA bgra = new BGRA(b, g, r, a);
return(bgra);
}
/// <summary>
/// Reads a 4-byte BGRA value from the data stream.
/// </summary>
/// <returns>The argument.</returns>
/// <param name="binaryReader">The reader.</param>
public static BGRA ReadBGRA(this BinaryReader binaryReader)
{
var b = binaryReader.ReadByte();
var g = binaryReader.ReadByte();
var r = binaryReader.ReadByte();
var a = binaryReader.ReadByte();
var bgra = new BGRA(b, g, r, a);
return(bgra);
}
} // loaded
public static void ReadMOCV(Stream WMOrootstream, int MOCVsize)
{
groupDataBuffer.vertexColors = new List <Color32>();
int count = MOCVsize / 4;
for (int i = 0; i < count; i++)
{
BGRA bgra = ReadBGRA(WMOrootstream);
Color32 color = new Color32(bgra.R, bgra.G, bgra.B, bgra.A);
groupDataBuffer.vertexColors.Add(color);
}
}
// https://code.google.com/p/2dimagefilter/wiki/ImageScaling
public static IImage <BGRA> PixelUpscale(this IImage <BGRA> img)
{
var upscaled = new BgraImage(img.Width << 1, img.Height << 1, new BGRA[img.Length << 2]);
for (int x = 0, xu = 0; x < img.Width; x++, xu += 2)
{
for (int y = 0, yu = 0; y < img.Height; y++, yu += 2)
{
// A --\ 1 2
// C P B --/ 3 4
// D
BGRA P = img[y, x];
BGRA A = img[y - 1, x];
BGRA B = img[y, x + 1];
BGRA D = img[y + 1, x];
BGRA C = img[y, x - 1];
// 1=P; 2=P; 3=P; 4=P;
BGRA _1 = P, _2 = P, _3 = P, _4 = P;
// IF C==A AND C!=D AND A!=B => 1=A
if (C == A && C != D && A != B)
{
_1 = A;
}
// IF A==B AND A!=C AND B!=D => 2=B
if (A == B && A != C && B != D)
{
_2 = B;
}
// IF B==D AND B!=A AND D!=C => 4=D
if (B == D && B != A && D != C)
{
_4 = D;
}
// IF D==C AND D!=B AND C!=A => 3=C
if (D == C && D != B && C != A)
{
_3 = C;
}
upscaled[yu, xu + 0] = _1;
upscaled[yu, xu + 1] = _2;
++yu;
upscaled[yu, xu + 0] = _3;
upscaled[yu, xu + 1] = _4;
}
}
return(null);
}
public static BGRA ReadBGRA(this BinaryReader reader)
{
BGRA BGRAColor = new BGRA()
{
B = reader.ReadByte(),
G = reader.ReadByte(),
R = reader.ReadByte(),
A = reader.ReadByte(),
};
return(BGRAColor);
}
public FogDefinition(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.EndRadius = br.ReadSingle();
this.StartMultiplier = br.ReadSingle();
this.Colour = br.ReadBGRA();
}
}
}
public FogDefinition(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.EndRadius = br.ReadSingle();
this.StartMultiplier = br.ReadSingle();
this.Colour = br.ReadBGRA();
}
}
}
public static YCbCr ToYCbCr_JPEG(this BGRA color)
{
double R = color.R;
double G = color.G;
double B = color.B;
double Y = R * 0.29900 + G * 0.58700 + B * 0.11400;
double Cb = R * -0.16874 + G * -0.33126 + B * 0.50000 + 128;
double Cr = R * 0.50000 + G * -0.41869 + B * -0.08131 + 128;
return(new YCbCr {
Y = (byte)Y, Cb = (byte)Cb, Cr = (byte)Cr
});
}
private static void TestDataConsistency <T>(IImage <T> img)
where T : struct, IEquatable <T>
{
byte[] rgb = img.ToBGR();
byte[] rgbA = img.ToBGRA();
Assert.IsTrue((rgb.Length / 3) * 4 == rgbA.Length);
// rgb and rgbA should be the same
// except one lacks alpha
for (int i = 0, j = 0; i < rgbA.Length; i++, j++)
{
// Alpha
if ((i + 1) % 4 == 0)
{
// Alpha should be 255
Assert.IsTrue(rgbA[i] == byte.MaxValue);
j--;
continue;
}
Assert.IsTrue(rgb[j] == rgbA[i]);
}
// Doing this should produce the same thing as
// ToBGRA just as a struct in stead of 4 bytes
BGRA[] bgra = new BGRA[img.Length];
img.ToIndexedBgra((i, x) => bgra[i] = x);
for (int i = 0, j = 0; i < img.Length; i++, j += 4)
{
BGRA val = bgra[i];
Assert.IsTrue(val.B == rgbA[j]);
Assert.IsTrue(val.G == rgbA[j + 1]);
Assert.IsTrue(val.R == rgbA[j + 2]);
Assert.IsTrue(val.A == rgbA[j + 3]);
}
// ToBGRA just as BGRA struct
BGRA[] bgra2 = img.ToPixelColor();
for (int i = 0; i < img.Length; i++)
{
Assert.IsTrue(bgra[i] == bgra2[i]);
}
}
public void BGRA()
{
BGRA b1 = new BGRA(1, 2, 3, 4);
BGRA b2 = new BGRA(1, 2, 3);
Assert.AreEqual(1, b1.B);
Assert.AreEqual(2, b1.G);
Assert.AreEqual(3, b1.R);
Assert.AreEqual(4, b1.A);
Assert.AreEqual(0x04030201, b1.Value);
Assert.AreNotEqual(b1, b2);
b2.A = 4;
Assert.AreEqual(b1, b2);
Assert.AreEqual(true, b1.Equals(b2));
}
/// <summary>
/// Initializes a new instance of the <see cref="DoodadInstance"/> class.
/// </summary>
/// <param name="inData">The binary data.</param>
public DoodadInstance(byte[] inData)
{
using var ms = new MemoryStream(inData);
using var br = new BinaryReader(ms);
var finalNameBytes = new byte[4];
var nameOffsetBytes = br.ReadBytes(3);
Buffer.BlockCopy(nameOffsetBytes, 0, finalNameBytes, 0, 3);
NameOffset = BitConverter.ToUInt32(finalNameBytes, 0);
Flags = (DoodadInstanceFlags)br.ReadByte();
Position = br.ReadVector3();
// TODO: Investigate whether or not this is a Quat16 in >= BC
Orientation = br.ReadQuaternion32();
Scale = br.ReadSingle();
StaticLightingColour = br.ReadBGRA();
}
public static BGRA ColorizeBlueToRed(short depthPixel, Tuple <int, int> min_max)
{
int min = min_max.Item1;
int max = min_max.Item2;
byte PixelMax = Byte.MaxValue;
BGRA result = new BGRA(0, 0, 0, PixelMax);
if (depthPixel == 0)
{
return(result);
}
int clampedValue = depthPixel;
clampedValue = Math.Min(clampedValue, max);
clampedValue = Math.Max(clampedValue, min);
float hue = (float)(clampedValue - min) / (float)(max - min);
float range = 2.0f / 3.0f;
hue *= range;
hue = range - hue;
float fRed = 0.0f;
float fGreen = 0.0f;
float fBlue = 0.0f;
StaticImageProperties.ColorConvertHSVtoRGB(hue, 1.0f, 1.0f, ref fRed, ref fGreen, ref fBlue);
result.R = Convert.ToByte(fRed * (float)PixelMax);
result.G = Convert.ToByte(fGreen * (float)PixelMax);
result.B = Convert.ToByte(fBlue * (float)PixelMax);
return(result);
}
public DoodadInstance(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
byte[] finalNameBytes = new byte[4];
byte[] nameOffsetBytes = br.ReadBytes(3);
Buffer.BlockCopy(nameOffsetBytes, 0, finalNameBytes, 0, 3);
this.NameOffset= BitConverter.ToUInt32(finalNameBytes, 0);
this.Flags = (DoodadInstanceFlags) br.ReadByte();
this.Position = br.ReadVector3f();
// TODO: Investigate whether or not this is a Quat16 in >= BC
this.Orientation = br.ReadQuaternion32();
this.Scale = br.ReadSingle();
this.StaticLightingColour = br.ReadBGRA();
}
}
}
public static CMYK ToCmyk(this BGRA pixel)
{
// special case for all black (K = 1)
// to avoid a NaN
if (pixel == BGRA.Black)
{
return(new CMYK {
K = 1.0
});
}
double R = pixel.R / 255.0;
double G = pixel.G / 255.0;
double B = pixel.B / 255.0;
// K = 1-max(R', G', B')
double K = 1 - (R > G ? (R > B ? R : B) : (G > B ? G : B));
// 1 - K
double oneMinK = 1 - K;
double oneMinDiv1 = 1.0 / oneMinK;
// C = (1-R'-K) / (1-K)
double C = (oneMinK - R) * oneMinDiv1;
// M = (1-G'-K) / (1-K)
double M = (oneMinK - G) * oneMinDiv1;
// Y = (1-B'-K) / (1-K)
double Y = (oneMinK - B) * oneMinDiv1;
return(new CMYK()
{
C = C, M = M, Y = Y, K = K
});
}
private unsafe void RenderInternal(Input input)
{
if (webBrowser.InvokeRequired)
{
//wait until MathJax is done with rendering
while (!mathJaxRenderingDone)
{
Thread.Sleep(WaitingIntervalMs);
}
webBrowser.Invoke(new Action <Input>(RenderInternal), input);
}
else
{
webBrowser.Width = (int)(input.ZoomScale * ExtensionSettings.Instance.CustomZoomScale * DefaultBrowserWidth);
webBrowser.Height = (int)(input.ZoomScale * ExtensionSettings.Instance.CustomZoomScale * DefaultBrowserHeight);
const int ExtraMargin = 4;
var myDiv = webBrowser.Document.GetElementById("myDiv");
var width = (myDiv.OffsetRectangle.X + myDiv.ScrollRectangle.Width) + ExtraMargin;
var height = (myDiv.OffsetRectangle.Y + myDiv.ScrollRectangle.Height) + ExtraMargin;
webBrowser.Width = width;
webBrowser.Height = height;
webBrowser.Document.BackColor = Color.Transparent;
const PixelFormat pixelFormat = PixelFormat.Format32bppArgb;
using (var bitmap = new Bitmap(width, height, pixelFormat))
{
if (webBrowser.Document.DomDocument is IViewObject viewObject)
{
var webBrowserRectangle = new TagRECT(myDiv.OffsetRectangle);
var bitmapRectangle = new TagRECT(0, 0, width, height);
using (var gr = Graphics.FromImage(bitmap))
{
var hdc = gr.GetHdc();
try
{
int hr = viewObject.Draw(1 /*DVASPECT_CONTENT*/,
-1, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero,
hdc,
ref bitmapRectangle,
ref webBrowserRectangle,
IntPtr.Zero, 0);
}
finally
{
gr.ReleaseHdc();
}
}
var background = BGRA.From(input.Background);
using (var croppedBitmap = CropToContent(bitmap, background))
{
MakeBackgroundTransparent(croppedBitmap, background);
var bitmapSource = ResourcesManager.CreateBitmapSourceWithCurrentDpi(croppedBitmap);
var cacheInfo = new HtmlRendererCache.Info(
currentContent,
input.Foreground,
input.Background,
input.Font,
input.ZoomScale * ExtensionSettings.Instance.CustomZoomScale,
CacheVersion);
var errors = objectForScripting.Errors.Count == 0 ? Array.Empty <string>() : objectForScripting.Errors.ToArray();
var cachedImagePath = errors.Length == 0 ? cache.Add(cacheInfo, croppedBitmap) : null;
rendererResult = new RendererResult(bitmapSource, cachedImagePath, errors);
}
}
}
}
}
public static Color ToColor(this BGRA pixel)
{
return(Color.FromArgb(pixel.A, pixel.R, pixel.G, pixel.B));
}
public static HSV ToHsv(this BGRA pixel)
{
return(ToHsv((double)pixel.R, (double)pixel.G, (double)pixel.B));
}
public static double ToGrayscale(this BGRA pixel)
{
return(pixel.R * 0.299 + pixel.G * 0.587 + pixel.B * 0.114);
}
public static RGB ToRgb(this BGRA pixel)
{
return(new RGB(pixel.R, pixel.G, pixel.B));
}
public static HSL ToHsl(this BGRA pixel)
{
return(ToHsl(pixel.R, pixel.G, pixel.B));
}
public StaticLight(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.Type = (LightType) br.ReadByte();
this.bUseAttenuation = br.ReadBoolean();
this.bUseUnknown1 = br.ReadBoolean();
this.bUseUnknown2 = br.ReadBoolean();
this.Colour = br.ReadBGRA();
this.Position = br.ReadVector3f();
this.Intensity = br.ReadSingle();
this.AttenuationStartRadius = br.ReadSingle();
this.AttenuationEndRadius = br.ReadSingle();
this.Unknown1StartRadius = br.ReadSingle();
this.Unknown1EndRadius = br.ReadSingle();
this.Unknown2StartRadius = br.ReadSingle();
this.Unknown2EndRadius = br.ReadSingle();
}
}
}
