public static bool IsNegativeInfinity(Half half)
{
return(half.value == 0xfc00);
}
private void GetScanlineBytes(
int bytesPerPixel, int destIndex, int srcIndex, bool isHalf, bool destinationAlpha, bool sourceAlpha,
Half[] hr, Half[] hg, Half[] hb, Half[] ha, float[] fr, float[] fg, float[] fb, float[] fa,
int bitsPerPixel, GammaEncoding gamma, bool premultiplied, bool bgra, byte[] buffer, BinaryWriter writer
)
{
writer.Seek(destIndex, SeekOrigin.Begin);
for (int x = 0; x < DataWindow.Width; x++, destIndex += bytesPerPixel, srcIndex++)
{
float r, g, b, a;
// get source channels as floats
if (isHalf)
{
r = hr[srcIndex];
g = hg[srcIndex];
b = hb[srcIndex];
if (destinationAlpha)
{
a = sourceAlpha ? (float)ha[srcIndex] : 1.0f;
}
else
{
a = 1.0f;
}
}
else
{
r = fr[srcIndex];
g = fg[srcIndex];
b = fb[srcIndex];
if (destinationAlpha)
{
a = sourceAlpha ? fa[srcIndex] : 1.0f;
}
else
{
a = 1.0f;
}
}
// convert to destination format
if (bitsPerPixel == 8)
{
byte r8, g8, b8, a8 = 255;
if (gamma == GammaEncoding.Linear)
{
if (premultiplied)
{
r8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(r * a * 255 + 0.5)));
g8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(g * a * 255 + 0.5)));
b8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(b * a * 255 + 0.5)));
a8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(a * 255 + 0.5)));
}
else
{
r8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(r * 255 + 0.5)));
g8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(g * 255 + 0.5)));
b8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(b * 255 + 0.5)));
if (destinationAlpha)
{
a8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(a * 255 + 0.5)));
}
}
}
else if (gamma == GammaEncoding.Gamma)
{
if (premultiplied)
{
r8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress(r) * a * 255 + 0.5)));
g8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress(g) * a * 255 + 0.5)));
b8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress(b) * a * 255 + 0.5)));
a8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(a * 255 + 0.5)));
}
else
{
r8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress(r) * 255 + 0.5)));
g8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress(g) * 255 + 0.5)));
b8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress(b) * 255 + 0.5)));
if (destinationAlpha)
{
a8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(a * 255 + 0.5)));
}
}
}
else
{ // sRGB
if (premultiplied)
{
r8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress_sRGB(r) * a * 255 + 0.5)));
g8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress_sRGB(g) * a * 255 + 0.5)));
b8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress_sRGB(b) * a * 255 + 0.5)));
a8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(a * 255 + 0.5)));
}
else
{
r8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress_sRGB(r) * 255 + 0.5)));
g8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress_sRGB(g) * 255 + 0.5)));
b8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(Gamma.Compress_sRGB(b) * 255 + 0.5)));
if (destinationAlpha)
{
a8 = (byte)Math.Min(255, Math.Max(0, Math.Floor(a * 255 + 0.5)));
}
}
}
if (bgra)
{
buffer[destIndex] = b8;
buffer[destIndex + 1] = g8;
buffer[destIndex + 2] = r8;
}
else
{
buffer[destIndex] = r8;
buffer[destIndex + 1] = g8;
buffer[destIndex + 2] = b8;
}
if (destinationAlpha)
{
buffer[destIndex + 3] = a8;
}
}
else if (bitsPerPixel == 32)
{
float r32, g32, b32, a32 = 1.0f;
if (gamma == GammaEncoding.Linear)
{
if (premultiplied)
{
r32 = r * a;
g32 = g * a;
b32 = b * a;
a32 = a;
}
else
{
r32 = r;
g32 = g;
b32 = b;
if (destinationAlpha)
{
a32 = a;
}
}
}
else if (gamma == GammaEncoding.Gamma)
{
if (premultiplied)
{
r32 = Gamma.Compress(r) * a;
g32 = Gamma.Compress(g) * a;
b32 = Gamma.Compress(b) * a;
a32 = a;
}
else
{
r32 = Gamma.Compress(r);
g32 = Gamma.Compress(g);
b32 = Gamma.Compress(b);
if (destinationAlpha)
{
a32 = a;
}
}
}
else
{ // sRGB
if (premultiplied)
{
r32 = Gamma.Compress_sRGB(r) * a;
g32 = Gamma.Compress_sRGB(g) * a;
b32 = Gamma.Compress_sRGB(b) * a;
a32 = a;
}
else
{
r32 = Gamma.Compress_sRGB(r);
g32 = Gamma.Compress_sRGB(g);
b32 = Gamma.Compress_sRGB(b);
if (destinationAlpha)
{
a32 = a;
}
}
}
if (bgra)
{
writer.Write(b32);
writer.Write(g32);
writer.Write(r32);
}
else
{
writer.Write(r32);
writer.Write(g32);
writer.Write(b32);
}
if (destinationAlpha)
{
writer.Write(a32);
}
}
else
{ // 16
Half r16, g16, b16, a16 = new Half(1.0f);
if (gamma == GammaEncoding.Linear)
{
if (premultiplied)
{
r16 = (Half)(r * a);
g16 = (Half)(g * a);
b16 = (Half)(b * a);
a16 = (Half)a;
}
else
{
r16 = (Half)r;
g16 = (Half)g;
b16 = (Half)b;
if (destinationAlpha)
{
a16 = (Half)a;
}
}
}
else if (gamma == GammaEncoding.Gamma)
{
if (premultiplied)
{
r16 = (Half)(Gamma.Compress(r) * a);
g16 = (Half)(Gamma.Compress(g) * a);
b16 = (Half)(Gamma.Compress(b) * a);
a16 = (Half)a;
}
else
{
r16 = (Half)Gamma.Compress(r);
g16 = (Half)Gamma.Compress(g);
b16 = (Half)Gamma.Compress(b);
if (destinationAlpha)
{
a16 = (Half)a;
}
}
}
else
{ // sRGB
if (premultiplied)
{
r16 = (Half)(Gamma.Compress_sRGB(r) * a);
g16 = (Half)(Gamma.Compress_sRGB(g) * a);
b16 = (Half)(Gamma.Compress_sRGB(b) * a);
a16 = (Half)a;
}
else
{
r16 = (Half)Gamma.Compress_sRGB(r);
g16 = (Half)Gamma.Compress_sRGB(g);
b16 = (Half)Gamma.Compress_sRGB(b);
if (destinationAlpha)
{
a16 = (Half)a;
}
}
}
if (bgra)
{
writer.Write(b16.value);
writer.Write(g16.value);
writer.Write(r16.value);
}
else
{
writer.Write(r16.value);
writer.Write(g16.value);
writer.Write(b16.value);
}
if (destinationAlpha)
{
writer.Write(a16.value);
}
}
}
}
public static bool IsInfinity(Half half)
{
return((half.value & 0x7fff) == 0x7c00);
}
public static bool IsPositiveInfinity(Half half)
{
return(half.value == 0x7c00);
}
public static bool IsNaN(Half half)
{
return((half.value & 0x7fff) > 0x7c00);
}
public static Half Abs(Half half)
{
return(Half.ToHalf((ushort)(half.value & 0x7fff)));
}
public static Half Negate(Half half)
{
return(Half.ToHalf((ushort)(half.value ^ 0x8000)));
}
public static unsafe float HalfToSingle(Half half)
{
public Half ReadHalf()
{
return(Half.ToHalf(reader.ReadUInt16()));
}
