public unsafe static void ReplaceAlphaChannel(ImageRef target, ImageRef alphaOperand)
{
lock (target.image)
{
lock (alphaOperand.image)
{
Image image = target.image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
Image image2 = alphaOperand.image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
Bitmap bitmap = (Bitmap)image;
Bitmap bitmap2 = (Bitmap)image2;
BitmapData bitmapdata = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
BitmapData data2 = bitmap2.LockBits(new Rectangle(0, 0, bitmap2.Width, bitmap2.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
PixelStruct *structPtr = (PixelStruct *)bitmapdata.Scan0;
PixelStruct *structPtr3 = (PixelStruct *)data2.Scan0;
int width = bitmapdata.Width;
int height = bitmapdata.Height;
int num3 = bitmapdata.Stride / sizeof(PixelStruct);
for (int i = 0; i < height; i++)
{
int num4 = 0;
PixelStruct *structPtr2 = structPtr + (i * num3);
for (PixelStruct *structPtr4 = structPtr3 + (i * num3); num4 < width; structPtr4++)
{
structPtr2->a = structPtr4->a;
num4++;
structPtr2++;
}
}
bitmap.UnlockBits(bitmapdata);
bitmap2.UnlockBits(data2);
}
}
}
public unsafe Transparentness GetTransparentness()
{
Transparentness entirelyTransparent;
lock (this)
{
Bitmap bitmap = (Bitmap)IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
BitmapData bitmapdata = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite,
PixelFormat.Format32bppArgb);
bool flag = false;
bool condition = false;
try
{
PixelStruct *structPtr = (PixelStruct *)bitmapdata.Scan0;
for (int i = 0; i < bitmapdata.Height; i++)
{
for (int j = 0; j < bitmapdata.Width; j++)
{
PixelStruct *structPtr2 = structPtr + i * bitmapdata.Stride / sizeof(PixelStruct) + j;
if (structPtr2->a != 0)
{
flag = true;
}
else
{
condition = true;
}
if (flag && condition)
{
return(Transparentness.SomeOfEach);
}
}
}
if (flag)
{
D.Assert(!condition);
return(Transparentness.EntirelyOpaque);
}
D.Assert(condition);
entirelyTransparent = Transparentness.EntirelyTransparent;
}
finally
{
bitmap.UnlockBits(bitmapdata);
}
}
return(entirelyTransparent);
}
private unsafe Present FadeTile(ImageRef sourceImage, double fadeFactor)
{
GDIBigLockedImage image = new GDIBigLockedImage(sourceImage.image.Size, "FadeVerb");
lock (sourceImage.image)
{
Image image2 = sourceImage.image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
lock (image)
{
Image image3 = image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
Bitmap bitmap = (Bitmap)image2;
Bitmap bitmap2 = (Bitmap)image3;
BitmapData bitmapdata = bitmap2.LockBits(new Rectangle(0, 0, bitmap2.Width, bitmap2.Height),
ImageLockMode.WriteOnly,
PixelFormat.Format32bppArgb);
BitmapData data2 = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
PixelStruct *structPtr = (PixelStruct *)bitmapdata.Scan0;
PixelStruct *structPtr3 = (PixelStruct *)data2.Scan0;
int width = bitmapdata.Width;
int height = bitmapdata.Height;
int num3 = bitmapdata.Stride / sizeof(PixelStruct);
for (int i = 0; i < height; i++)
{
int num4 = 0;
for (PixelStruct *structPtr2 = structPtr + i * num3; num4 < width; structPtr2++)
{
PixelStruct *structPtr4 = structPtr3 + i * num3 + num4;
structPtr2[0] = structPtr4[0];
structPtr2->a = (byte)(structPtr2->a * fadeFactor);
num4++;
}
}
bitmap2.UnlockBits(bitmapdata);
bitmap.UnlockBits(data2);
}
}
sourceImage.Dispose();
return(new ImageRef(new ImageRefCounted(image)));
}
public static unsafe void doWarp(GDIBigLockedImage destImage, GDIBigLockedImage sourceImage,
IPointTransformer[] pointTransformers, InterpolationMode mode)
{
Bitmap bitmap;
BitmapData data;
Bitmap bitmap2;
BitmapData data2;
DateTime now = DateTime.Now;
PointD td = new PointD();
PointD td2 = new PointD();
lock (destImage)
{
bitmap = (Bitmap)destImage.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.WriteOnly,
PixelFormat.Format32bppArgb);
}
lock (sourceImage)
{
bitmap2 = (Bitmap)sourceImage.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
data2 = bitmap2.LockBits(new Rectangle(0, 0, bitmap2.Width, bitmap2.Height),
ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
}
PixelStruct *structPtr = (PixelStruct *)data.Scan0;
int width = data.Width;
int height = data.Height;
int num9 = data.Stride / sizeof(PixelStruct);
PixelStruct *structPtr3 = (PixelStruct *)data2.Scan0;
int num10 = data2.Width;
int num11 = data2.Height;
int num12 = data2.Stride / sizeof(PixelStruct);
int num15 = num11 - 1;
for (int i = 0; i < height; i++)
{
int num13 = 0;
for (PixelStruct *structPtr2 = structPtr + (height - 1 - i) * num9; num13 < width; structPtr2++)
{
int x;
int num2;
PixelStruct *structPtr4;
td.x = num13;
td.y = i;
for (int j = 0; j < pointTransformers.Length; j++)
{
pointTransformers[j].doTransform(td, td2);
td.x = td2.x;
td.y = td2.y;
}
if (mode == InterpolationMode.NearestNeighbor)
{
x = (int)td.x;
num2 = num15 - (int)td.y;
if (x >= 0 && x < num10 && num2 >= 0 && num2 < num11)
{
structPtr4 = structPtr3 + num2 * num12 + x;
structPtr2[0] = structPtr4[0];
}
}
else
{
if (mode != InterpolationMode.Bilinear)
{
throw new Exception("Unimplemented mode");
}
double num17 = num15 - td.y;
int num3 = (int)td.x;
int num4 = (int)num17;
double num5 = td.x - num3;
double num6 = num17 - num4;
IntPixel pixel = IntPixel.BlackPixel();
int num20 = 0;
for (double k = 1.0 - num5; num20 <= 1; k = num5)
{
int num21 = 0;
for (double m = 1.0 - num6; num21 <= 1; m = num6)
{
x = num3 + num20;
num2 = num4 + num21;
if (x >= 0 && x < num10 && num2 >= 0 && num2 < num11)
{
structPtr4 = structPtr3 + num2 * num12 + x;
pixel.addWeighted(k * m, structPtr4[0]);
}
num21++;
}
num20++;
}
structPtr2[0] = pixel.AsPixel();
}
num13++;
}
}
lock (destImage)
{
bitmap.UnlockBits(data);
}
lock (sourceImage)
{
bitmap2.UnlockBits(data2);
}
}
private unsafe Present Evaluate(params Present[] paramList)
{
D.Assert(paramList.Length == 2);
if (!(paramList[0] is ImageRef))
{
return(paramList[0]);
}
if (!(paramList[1] is ImageRef))
{
return(paramList[1]);
}
ImageRef ref2 = (ImageRef)paramList[0];
ImageRef ref3 = (ImageRef)paramList[1];
GDIBigLockedImage image = new GDIBigLockedImage(ref2.image.Size, "TransparencyFuture");
lock (ref2.image)
{
Image image2 = ref2.image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
lock (ref3.image)
{
Image image3 = ref3.image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
lock (image)
{
BitmapData data3;
Image image4 = image.IPromiseIAmHoldingGDISLockSoPleaseGiveMeTheImage();
Bitmap bitmap = (Bitmap)image2;
Bitmap bitmap2 = (Bitmap)image4;
Bitmap bitmap3 = (Bitmap)image3;
BitmapData bitmapdata = bitmap2.LockBits(new Rectangle(0, 0, bitmap2.Width, bitmap2.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
BitmapData data2 = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
if (bitmap3 == bitmap)
{
data3 = data2;
}
else
{
data3 = bitmap3.LockBits(new Rectangle(0, 0, bitmap3.Width, bitmap3.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
}
PixelStruct *structPtr = (PixelStruct *)bitmapdata.Scan0;
PixelStruct *structPtr3 = (PixelStruct *)data2.Scan0;
PixelStruct *structPtr5 = (PixelStruct *)data3.Scan0;
int width = bitmapdata.Width;
int height = bitmapdata.Height;
int num3 = bitmapdata.Stride / sizeof(PixelStruct);
for (int i = 0; i < height; i++)
{
int num4 = 0;
for (PixelStruct *structPtr2 = structPtr + (i * num3); num4 < width; structPtr2++)
{
PixelStruct *structPtr4 = (structPtr3 + (i * num3)) + num4;
PixelStruct *structPtr6 = (structPtr5 + (i * num3)) + num4;
structPtr2[0] = structPtr4[0];
if (this.transparencyOptions.ShouldBeTransparent(structPtr6->r, structPtr6->g, structPtr6->b))
{
structPtr2->a = 0;
}
num4++;
}
}
bitmap2.UnlockBits(bitmapdata);
bitmap.UnlockBits(data2);
if (bitmap3 != bitmap)
{
bitmap3.UnlockBits(data3);
}
}
}
}
ref2.Dispose();
ref3.Dispose();
ImageRef source = new ImageRef(new ImageRefCounted(image));
int num6 = 0;
foreach (TransparencyColor color in this.transparencyOptions.colorList)
{
num6 = Math.Max(num6, color.halo);
}
if (num6 > 0)
{
HaloTransparency(source, num6);
}
return(source);
}
