/// <summary>
/// Set the preview pane to a previewable item
/// </summary>
/// <param name="item"></param>
public void SetPreviewItem(object item)
{
if (item is Thumbnail)
{
// Set the underlying object's preview then add a context menu
Thumbnail thumb = (Thumbnail)item;
SetPreviewItem(thumb.ThumbnailOf);
}
else if (item is BitmapType)
{
BitmapType preview = (BitmapType)item;
imagePreview.Source = preview.Bitmap;
InputBindings.Clear();
MouseBinding doubleclick = new MouseBinding(Commands.CmdFullscreen, new MouseGesture(MouseAction.LeftDoubleClick));
doubleclick.CommandTarget = this;
doubleclick.CommandParameter = preview;
InputBindings.Add(doubleclick);
List <MenuItem> menuitems = GetMenuItems(item, item);
ContextMenu = new ContextMenu()
{
ItemsSource = menuitems
};
}
else
{
imagePreview.Source = null;
InputBindings.Clear();
ContextMenu = null;
}
}
public void Save(string filename, BitmapType type, bool withBorder)
{
FileStream stream = new FileStream(filename, FileMode.Create);
this.Save(stream, type, withBorder);
stream.Close();
}
public Texture(PakFile Pak, PakFile.PakTag Item)
{
var reader = Pak.Reader;
reader.EndianType = EndianFormat.LittleEndian;
reader.SeekTo(Item.Offset + 6);
isLittleEndian = reader.ReadInt32() == 1346978644; //PICT
if (!isLittleEndian) reader.EndianType = Endian.EndianFormat.BigEndian;
reader.SeekTo(Item.Offset + (isLittleEndian ? 16 : 12));
Width = reader.ReadInt32();
Height = reader.ReadInt32();
reader.SeekTo(Item.Offset + (isLittleEndian ? 38 : 32));
Format = BitmapFormat.Dxt5;
var intFormat = reader.ReadInt32();
switch (intFormat)
{
case 0:
Format = BitmapFormat.A8R8G8B8;
break;
case 10:
Format = BitmapFormat.A8Y8;
break;
case 12:
Format = BitmapFormat.Dxt1;
break;
case 13:
Format = BitmapFormat.Dxt1;
break;
case 15:
Format = BitmapFormat.Dxt3;
break;
case 17:
Format = BitmapFormat.Dxt5;
break;
case 22:
Format = BitmapFormat.X8R8G8B8;
break;
case 36:
Format = BitmapFormat.Dxn;
break;
case 37:
Format = BitmapFormat.DXT5a;
break;
default:
throw new Exception("CHECK THIS");
}
reader.SeekTo(Item.Offset + (isLittleEndian ? 28 : 24));
int mapCount = reader.ReadInt32();
if (mapCount == 6) Type = BitmapType.CubeMap;
else Type = BitmapType.Texture2D;
if (mapCount > 1 && mapCount != 6)
throw new Exception("CHECK THIS");
DataAddress = Item.Offset + (isLittleEndian ? 58 : 4096);
reader.EndianType = Endian.EndianFormat.LittleEndian; //in case it was PICT
}
public BaseBitmap(BitmapTextureInterleavedInteropResource definition, int index, Bitmap.Image image)
{
var def = definition.Texture.Definition;
if (index == 0)
{
Height = def.Height1;
Width = def.Width1;
Depth = def.Depth1;
MipMapCount = def.MipmapCount1 - 1;
Type = def.Type1;
Flags = image.Flags;
UpdateFormat(image.Format);
}
else
{
Height = def.Height2;
Width = def.Width2;
Depth = def.Depth2;
MipMapCount = def.MipmapCount2 - 1;
Type = def.Type2;
Flags = image.Flags;
UpdateFormat(image.Format);
}
}
public void Save(string filename, BitmapType type)
{
FileStream stream = new FileStream(filename, FileMode.Create);
this.Save(stream, type, false);
stream.Close();
}
public void Load(string filename, BitmapType type, bool setSize)
{
FileStream stream = new FileStream(filename, FileMode.Open);
this.Load(stream, type, setSize);
stream.Close();
}
public BaseBitmap(BitmapTextureInterleavedInteropResource definition, int index, Bitmap.Image image)
{
if (index == 0)
{
var def = definition.Texture.Definition.Bitmap1;
Height = def.Height;
Width = def.Width;
Depth = def.Depth;
MipMapCount = def.MipmapCount - 1;
Type = def.BitmapType;
Flags = image.Flags;
UpdateFormat(image.Format);
}
else
{
var def = definition.Texture.Definition.Bitmap2;
Height = def.Height;
Width = def.Width;
Depth = def.Depth;
MipMapCount = def.MipmapCount - 1;
Type = def.BitmapType;
Flags = image.Flags;
UpdateFormat(image.Format);
}
MipMapOffset = image.MipMapOffset;
Curve = image.Curve;
}
public static bool ContrainsElement(string name, BitmapType type)
{
if ((graphicElements.FindAll(x => x.Name == name && x.eType == type).Count > 0))
{
return(true);
}
return(false);
}
internal TouchManipulationBitmap(SKBitmap bitmap, BitmapType type, string text, SKColor color = default)
{
Matrix = SKMatrix.MakeIdentity();
Bitmap = bitmap;
Type = type;
Color = color;
Text = text;
}
internal TouchManipulationBitmap(SKBitmap bitmap, SKMatrix matrix, BitmapType type, string text, SKColor color = default)
{
Bitmap = bitmap;
Matrix = matrix;
Type = type;
Text = text;
Color = color;
}
public Thumbnail(BitmapType represents)
: base()
{
ThumbnailOf = represents;
Source = ThumbnailOf.GetThumbnail(false);
// ContextMenu = GetContextMenu();
}
public BaseBitmap(BaseBitmap bitmap)
{
Height = bitmap.Height;
Width = bitmap.Width;
Depth = bitmap.Depth;
MipMapCount = bitmap.MipMapCount;
Type = bitmap.Type;
Flags = bitmap.Flags;
UpdateFormat(bitmap.Format);
}
public virtual void Load(ref BinaryReader input)
{
Type = (BitmapType)input.ReadInt16();
Format = (BitmapFormat)input.ReadInt16();
Usage = (BitmapUsage)input.ReadInt16();
input.BaseStream.Position += 16;
ColorPlateWidth = input.ReadInt16();
ColorPlateHeight = input.ReadInt16();
ColorPlateData = input.ReadInt32();
}
//---------------------------------------------------------------------
private static IntPtr LoadImageFromByteArray(byte[] data, BitmapType type)
{
IntPtr DataPtr = IntPtr.Zero;
DataPtr = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, DataPtr, data.Length);
return(wxImage_ctorByByteArray(DataPtr, data.Length, type));
}
public BaseBitmap(Bitmap.Image image)
{
Height = image.Height;
Width = image.Width;
Depth = image.Depth;
MipMapCount = image.MipmapCount;
Type = image.Type;
Flags = image.Flags;
UpdateFormat(image.Format);
}
// Full-screen view
public void CmdFullscreenExecuted(object sender, ExecutedRoutedEventArgs e)
{
if (e.Parameter is BitmapType || e.Parameter is Thumbnail)
{
BitmapType target = (BitmapType)e.Parameter;
PreviewPane restore = PreviewPane;
FullscreenView fsview = new FullscreenView(target, () => PreviewPane = restore);
fsview.Show();
PreviewPane = fsview.previewFullScreen;
}
}
//---------------------------------------------------------------------
private static IntPtr LoadPossibleResource(string name, BitmapType type, Assembly asm)
{
if (type == BitmapType.wxBITMAP_TYPE_RESOURCE)
{
return(Object.SafePtr(new Image(name, asm)));
}
else
{
return(wxImage_ctorByName(name, type));
}
}
private void ChangeOutputType(object sender, UserEventArgs <BitmapType> e)
{
((PictureBox)ImageController).Image = null;
currentOutputType = e.item;
var elements = (List <LocalDataGraphicsElement>)LocalDataBase.GetTypedElements(currentOutputType);
if (elements != null)
{
((GraphicsInfoControlMenu)ListController).SetListBoxItems(elements);
}
}
/// <summary>
/// Find the thumnail that matches the specified item
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public Thumbnail FindThumbnail(BitmapType item)
{
foreach (Thumbnail thumb in myThumbnails)
{
if (thumb.ThumbnailOf == item)
{
return(thumb);
}
}
return(null);
}
public BaseBitmap(BitmapTextureInteropDefinition definition, Bitmap.Image image)
{
Height = definition.Height;
Width = definition.Width;
Depth = definition.Depth;
MipMapCount = definition.MipmapCount != 0 ? definition.MipmapCount - 1 : 0;
Type = definition.BitmapType;
Flags = image.Flags;
Curve = image.Curve;
MipMapOffset = image.MipMapOffset;
UpdateFormat(image.Format);
}
public BaseBitmap(BitmapTextureInteropResource definition, Bitmap.Image image)
{
var def = definition.Texture.Definition;
Height = def.Height;
Width = def.Width;
Depth = def.Depth;
MipMapCount = def.MipmapCount - 1;
Type = def.Type;
Flags = image.Flags;
UpdateFormat(image.Format);
}
public ushort[] GetData(BitmapType type)
{
switch (type)
{
case BitmapType.Depth:
return(this.depthData);
case BitmapType.Infrared:
return(this.infraredData);
}
return(null);
}
/// <summary>
/// Deserializes this structure from binary data.
/// </summary>
/// <param name="reader">The <see cref="BinaryReader"/> to read the data from.</param>
public void ReadFrom(BinaryReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
_width = reader.ReadUInt32();
_height = reader.ReadUInt32();
_flags = (BitmapDescriptionFlags)reader.ReadUInt16();
_bitsPerPixel = reader.ReadByte();
_type = (BitmapType)reader.ReadByte();
}
public Texture(BinaryReader reader)
{
Magic = Encoding.ASCII.GetString(reader.ReadBytes(4));
Width = reader.ReadInt32();
Height = reader.ReadInt32();
BitsPerPixel = reader.ReadInt32();
OriginalBitsPerPixel = reader.ReadInt32();
MipCount = reader.ReadInt32();
PaletteEntryCount = reader.ReadInt32();
CompressionCandidate = reader.ReadInt32();
CompressionAllowed = reader.ReadInt32();
UsesAlpha = reader.ReadInt32();
UsesChromaKey = reader.ReadInt32();
Type = (BitmapType)reader.ReadUInt32();
Padding0 = reader.ReadUInt32();
Padding1 = reader.ReadUInt32();
Padding2 = reader.ReadUInt32();
Padding3 = reader.ReadUInt32();
if (PaletteEntryCount > 0 && Type != BitmapType.DXT3)
{
PaletteData = reader.ReadBytes(4 * PaletteEntryCount);
}
int bytes = 0;
if ((Magic == MAGIC_PCT2 && (Type == BitmapType.RGBA || Type == BitmapType.BGRA)) || (Magic == MAGIC_PCT1 && PaletteEntryCount == 0))
{
bytes = (int)(Width * Height * BitsPerPixel / 8);
PixelData = reader.ReadBytes(bytes);
}
else if ((Magic == MAGIC_PCT2 && Type == BitmapType.Paletted) || (Magic == MAGIC_PCT1 && PaletteEntryCount > 0))
{
bytes = (int)(Width * Height * BitsPerPixel / 8);
PixelData = reader.ReadBytes(bytes);
}
else if (Magic == MAGIC_PCT2 && Type == BitmapType.DXT3)
{
bytes = ((int)Width / 4) * ((int)Height / 4) * 16;
PixelData = reader.ReadBytes(bytes);
}
if ((PixelData?.Length ?? 0) != bytes)
{
//System.Diagnostics.Debugger.Break();
//Console.WriteLine(Unk08.ToString("X8") + " [BAD]");
Console.WriteLine("[ERROR]: " + ToString());
throw new NotSupportedException("No pixel data!");
}
}
public DDSImage(int Height, int Width, byte[] Buffer, BitmapFormat Format, BitmapType Type,
bool Swizzled, int Depth, int PixelOffset, int MipMapCount)
{
this.Height = Height;
this.Width = Width;
this.Buffer = Buffer;
this.Size = Buffer.Length;
this.Format = Format;
this.Type = Type;
this.Swizzled = Swizzled;
this.Depth = Depth;
this.PixelOffset = PixelOffset;
this.MipMapCount = MipMapCount;
}
public virtual void Load(ref BinaryReader input)
{
Signature = input.ReadUInt32();
Width = input.ReadInt16();
Height = input.ReadInt16();
Depth = input.ReadInt16();
Type = (BitmapType)input.ReadInt16();
Format = (BitmapDataFormat)input.ReadInt16();
Flags = (BitmapDataFlags)input.ReadInt16();
RegPointX = input.ReadInt16();
RegPointY = input.ReadInt16();
NumMipmaps = input.ReadInt16();
PixelOffset = input.ReadInt16();
}
/// <summary>
/// Checks if the photo type is Thumbnail and if it is disables manipulation of all image controls for the layout grid.
/// </summary>
private static void OnPhotoTypeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
LayoutGrid layoutGrid = d as LayoutGrid;
BitmapType type = (BitmapType)e.NewValue;
if (layoutGrid != null && type == BitmapType.Thumbnail)
{
// This layout grid is one of many displaying possible layouts that the user can choose from
// and it must not have the option of manipulating individual photos
foreach (Image img in layoutGrid.images)
{
img.IsHitTestVisible = false;
}
}
}
/// <summary>
/// 添加位图到画布
/// </summary>
/// <param name="bitmap"></param>
/// <param name="type"></param>
internal void AddBitmapToCanvas(SKBitmap bitmap, BitmapType type)
{
if (bitmap != null)
{
if (type != BitmapType.Main)
{
AddBitmapToCanvas(new TouchManipulationBitmap(bitmap, type, null));
}
else
{
SetMainBitmap(bitmap);
}
InvalidateSurface();
}
}
internal ShaderTemplateParameterBlockBase(BinaryReader binaryReader)
{
this.name = binaryReader.ReadStringID();
this.explanation = ReadData(binaryReader);
this.type = (Type)binaryReader.ReadInt16();
this.flags = (Flags)binaryReader.ReadInt16();
this.defaultBitmap = binaryReader.ReadTagReference();
this.defaultConstValue = binaryReader.ReadSingle();
this.defaultConstColor = binaryReader.ReadColorR8G8B8();
this.bitmapType = (BitmapType)binaryReader.ReadInt16();
this.invalidName_ = binaryReader.ReadBytes(2);
this.bitmapAnimationFlags = (BitmapAnimationFlags)binaryReader.ReadInt16();
this.invalidName_0 = binaryReader.ReadBytes(2);
this.bitmapScale = binaryReader.ReadSingle();
}
/// <summary>
/// Save image to a file
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void CmdSaveDepthmapExecuted(object sender, ExecutedRoutedEventArgs e)
{
try
{
BitmapType image = e.Parameter as BitmapType;
if (image != null)
{
theViewModel.SaveBitmapToFile(image, "Save Depthmap", theViewModel.DepthmapPalette.sDefaultDirectory);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
}
private void makebitmap(PictureBox box, BitmapType btype)
{
try
{
image = new Bitmap(512, 512);
if (btype == BitmapType.SMA)
{
var idx = SmaFormatter.GetIndex("tileinfo", "EventType");
var temp = (_SmaData[1] as object[]).Select(x => (byte)(x as object[])[idx]).ToArray();
for (int x = 0; x < 256; x++)
{
for (int y = 0; y < 256; y++)
{
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
image.SetPixel(2 * (255 - y) + i, 2 * x + j, temp[x + 256 * y] == 0 ? Color.LightBlue : Color.Black);
}
}
}
}
box.Image = image;
}
if (btype == BitmapType.DAT)
{
var idx = MapFormatter.GetIndex("tileinfo", "EventType");
var temp = (_DatData[2] as object[]).Select(x => (byte)(x as object[])[idx]).ToArray();
for (int x = 0; x < 256; x++)
{
for (int y = 0; y < 256; y++)
{
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
image.SetPixel(2 * (255 - y) + i, 2 * x + j, temp[x + 256 * y] == 0 ? Color.LightBlue : Color.Black);
}
}
}
}
box.Image = image;
}
}catch (Exception ex) { ErrorLogger.LogException(ex); }
}
/// <summary>
/// The decode bitmap.
/// </summary>
/// <param name="fart">The fart.</param>
/// <param name="height">The height.</param>
/// <param name="width">The width.</param>
/// <param name="depth">The depth.</param>
/// <param name="bitsPerPixel">The bits per pixel.</param>
/// <param name="type">The type.</param>
/// <param name="format">The format.</param>
/// <param name="swizzle">The swizzle.</param>
/// <param name="map">The map.</param>
/// <param name="visualchunkindex">The visualchunkindex.</param>
/// <param name="ident">The ident.</param>
/// <returns>The decode bitmap.</returns>
/// <remarks></remarks>
private static int DecodeBitmap(
ref byte[] fart,
int height,
int width,
int depth,
int bitsPerPixel,
BitmapType type,
BitmapFormat format,
bool swizzle,
Map map,
int visualchunkindex,
int ident)
{
byte[] poo = new byte[0];
int poolength;
byte[] tempData;
DecodeDXT decode = new DecodeDXT();
int stride = width;
if (swizzle)
{
fart = Swizzler.Swizzle(fart, width, height, depth, bitsPerPixel, true);
}
switch (format)
{
#region DXT1
case (BitmapFormat)14:
if (swizzle)
{
MessageBox.Show("Swizzled");
}
fart = decode.DecodeDXT1(height, width, fart);
stride *= 4;
break;
#endregion
#region DXT2/3
case (BitmapFormat)15:
if (swizzle)
{
MessageBox.Show("Swizzled");
}
fart = decode.DecodeDXT23(height, width, fart);
stride *= 4;
break;
#endregion
#region DXT 4/5
case (BitmapFormat)16:
if (swizzle)
{
MessageBox.Show("Swizzled");
}
fart = decode.DecodeDXT45(height, width, fart);
stride *= 4;
break;
#endregion
#region A8R8G8B8
case (BitmapFormat)11:
stride *= 4;
break;
#endregion
#region X8R8G8B8
case (BitmapFormat)10:
stride *= 4;
/*
poolength = fart.Length;
tempData = new byte[poolength];
for (int e = 0; e < poolength; e++)
tempData[e * 4 + 3] = 255; // Alpha always 255
fart = tempData;
*/
break;
#endregion
#region // 16 bit \\
#region A4R4G4B4
case (BitmapFormat)9:
stride *= 4;
poolength = fart.Length;
tempData = new byte[poolength * 2];
for (int e = 0; e < poolength / 2; e++)
{
int r = e * 2;
tempData[r * 2 + 0] = (byte)((fart[r + 1] & 0xFF) >> 0); // Blue
tempData[r * 2 + 1] = (byte)((fart[r + 0] & 0xFF) >> 0); // Green
tempData[r * 2 + 2] = (byte)((fart[r + 0] & 0xFF) >> 0); // Red
tempData[r * 2 + 3] = 255; // (byte)(((fart[r + 1] & 0xFF) >> 0)); // Alpha
}
fart = tempData;
break;
#endregion
#region G8B8
case (BitmapFormat)22:
stride *= 4;
poolength = fart.Length;
tempData = new byte[poolength / 2 * 4];
// These are actually signed (+/-128), so convert to unsigned
for (int e = 0; e < poolength / 2; e++)
{
int r = e * 2;
tempData[r * 2 + 0] = (byte)(fart[r + 1] + 128); // Blue
tempData[r * 2 + 1] = (byte)(fart[r + 1] + 128); // Green
tempData[r * 2 + 2] = (byte)(fart[r + 0] + 128); // Red
tempData[r * 2 + 3] = (byte)(fart[r + 0] + 128); // Alpha
}
fart = tempData;
break;
#endregion
#region A1R5G5B5
case (BitmapFormat)8:
stride *= 4;
poolength = fart.Length;
tempData = new byte[poolength / 2 * 4];
for (int r = 0; r < fart.Length; r += 2)
{
int temp = fart[r + 0] + (fart[r + 1] << 8);
tempData[r * 2 + 0] = (byte)(((temp >> 0) & 0x1F) * 255 / 0x1F); // 5-bit Blue
tempData[r * 2 + 1] = (byte)(((temp >> 5) & 0x1F) * 255 / 0x1F); // 5-bit Green
tempData[r * 2 + 2] = (byte)(((temp >> 10) & 0x1F) * 255 / 0x1F); // 5-bit Red
tempData[r * 2 + 3] = (byte)(((temp >> 15) & 0x01) * 255); // 1-bit Alpha
}
fart = tempData;
break;
#endregion
#region R5G6B5
case (BitmapFormat)6:
stride *= 4;
poolength = fart.Length;
tempData = new byte[poolength / 2 * 4];
for (int r = 0; r < fart.Length; r += 2)
{
int temp = fart[r + 0] + (fart[r + 1] << 8);
tempData[r * 2 + 0] = (byte)(((temp >> 0) & 0x1F) * 255 / 0x1F); // 5-bit Blue
tempData[r * 2 + 1] = (byte)(((temp >> 5) & 0x3F) * 255 / 0x3F); // 6-bit Green
tempData[r * 2 + 2] = (byte)(((temp >> 11) & 0x1F) * 255 / 0x1F); // 5-bit Red
tempData[r * 2 + 3] = 255; // Alpha always 255
}
fart = tempData;
break;
#endregion
#region A8Y8
case (BitmapFormat)3:
poolength = fart.Length;
tempData = new byte[poolength / 2 * 4];
for (int e = 0; e < poolength / 2; e++)
{
int r = e * 2;
tempData[r * 2 + 0] = fart[r + 1]; // B
tempData[r * 2 + 1] = fart[r + 1]; // G
tempData[r * 2 + 2] = fart[r + 1]; // R
tempData[r * 2 + 3] = fart[r + 0]; // A
}
fart = tempData;
stride *= 4;
break;
#endregion
#region Unknown - Very similar (exactly?) to G8B8
case (BitmapFormat)23:
stride *= 4;
poolength = fart.Length;
tempData = new byte[poolength / 2 * 4];
// These are actually signed (+/-128), so convert to unsigned
for (int e = 0; e < poolength / 2; e++)
{
int r = e * 2;
tempData[r * 2 + 0] = (byte)(fart[r + 1] + 128); // Blue
tempData[r * 2 + 1] = (byte)(fart[r + 1] + 128); // Green
tempData[r * 2 + 2] = (byte)(fart[r + 0] + 128); // Red
tempData[r * 2 + 3] = (byte)(fart[r + 0] + 128); // Alpha
}
fart = tempData;
break;
#endregion
#endregion
#region // 8 bit \\
#region P8
case BitmapFormat.BITM_FORMAT_P8:
poolength = fart.Length;
tempData = new byte[poolength * 4];
for (int e = 0; e < poolength; e++)
{
int r = e * 4;
tempData[r + 0] = fart[e];
tempData[r + 1] = fart[e];
tempData[r + 2] = fart[e];
tempData[r + 3] = 255;
}
fart = tempData;
stride *= 4;
break;
#endregion
#region A8
case BitmapFormat.BITM_FORMAT_A8:
poolength = fart.Length;
tempData = new byte[poolength * 4];
for (int e = 0; e < poolength; e++)
{
int r = e * 4;
tempData[r + 0] = fart[e];
tempData[r + 1] = fart[e];
tempData[r + 2] = fart[e];
tempData[r + 3] = 255;
}
fart = tempData;
stride *= 4;
break;
#endregion
#region AY8
case BitmapFormat.BITM_FORMAT_AY8:
poolength = fart.Length;
tempData = new byte[poolength * 4];
for (int e = 0; e < poolength; e++)
{
int r = e * 4;
tempData[r + 0] = (byte)(fart[e]);
tempData[r + 1] = (byte)(fart[e]);
tempData[r + 2] = (byte)(fart[e]);
tempData[r + 3] = (byte)(fart[e] == 0 ? 0 : 255);
}
fart = tempData;
stride *= 4;
break;
#endregion
#region Y8
case (BitmapFormat)1:
poolength = fart.Length;
tempData = new byte[poolength * 4];
for (int e = 0; e < poolength; e++)
{
int r = e * 4;
tempData[r + 0] = fart[e];
tempData[r + 1] = fart[e];
tempData[r + 2] = fart[e];
tempData[r + 3] = 255;
}
fart = tempData;
stride *= 4;
break;
#endregion
#region LightMap
case BitmapFormat.BITM_FORMAT_LIGHTMAP:
poolength = fart.Length;
tempData = new byte[poolength * 4];
int bspnumber = ident;
int paletteindex = -1;
if (visualchunkindex < 0)
{
int wtf = 0 - (visualchunkindex + 1);
paletteindex = map.BSP.sbsp[bspnumber].SceneryChunk_LightMap_Index[wtf];
}
if (paletteindex == -1)
{
for (int i = 0; i < map.BSP.sbsp[bspnumber].VisualChunk_Bitmap_Index.Length; i++)
{
if (map.BSP.sbsp[bspnumber].VisualChunk_Bitmap_Index[i] == visualchunkindex)
{
paletteindex = map.BSP.sbsp[bspnumber].VisualChunk_LightMap_Index[visualchunkindex];
break;
}
}
}
if (paletteindex == -1)
{
for (int i = 0; i < map.BSP.sbsp[bspnumber].SceneryChunk_Bitmap_Index.Length; i++)
{
if (map.BSP.sbsp[bspnumber].SceneryChunk_Bitmap_Index[i] == visualchunkindex)
{
paletteindex = map.BSP.sbsp[bspnumber].SceneryChunk_LightMap_Index[i];
break;
}
}
}
if (paletteindex != 255)
{
for (int e = 0; e < poolength; e++)
{
int r = e * 4;
tempData[r + 0] = (byte)map.BSP.sbsp[bspnumber].LightMap_Palettes[paletteindex][fart[e]].r;
tempData[r + 1] = (byte)map.BSP.sbsp[bspnumber].LightMap_Palettes[paletteindex][fart[e]].g;
tempData[r + 2] = (byte)map.BSP.sbsp[bspnumber].LightMap_Palettes[paletteindex][fart[e]].b;
tempData[r + 3] = (byte)map.BSP.sbsp[bspnumber].LightMap_Palettes[paletteindex][fart[e]].a;
}
fart = tempData;
stride *= 4;
}
break;
#endregion
#endregion
}
return stride;
}
private void Save(Stream stream, BitmapType type, bool withBorder, int aWidth, int aHeight, Bitmap aSrcImage)
{
BinaryWriter writer = new BinaryWriter(stream);
int width = 0;
int height = aHeight;
if ((aWidth % 8) == 0)
{
width = aWidth / 8;
}
else
{
width = (aWidth / 8) + 1;
}
if ((width % 4) != 0)
{
width += 4 - (width % 4);
}
BMPHEADER bmpheader = new BMPHEADER();
bmpheader.header.bfSize = bmpheader.header.bfOffBits + ((uint) (width * height));
bmpheader.info.bmiHeader.biWidth = aWidth;
bmpheader.info.bmiHeader.biHeight = height;
bmpheader.info.bmiHeader.biSizeImage = (uint) (width * height);
bmpheader.info.bmiColor1 = new RGBQUAD(this.BackColor.B, this.BackColor.G, this.BackColor.R);
bmpheader.info.bmiColor2 = new RGBQUAD(this.ForeColor.B, this.ForeColor.G, this.ForeColor.R);
switch (type)
{
case BitmapType.Bmp1:
bmpheader.Write(writer);
break;
case BitmapType.Binary:
case BitmapType.BinaryStrict:
{
BINARYHEADER binaryheader = new BINARYHEADER();
binaryheader.iWidth = aWidth;
binaryheader.iHeight = height;
binaryheader.cBackground = new RGBQUAD(this.BackColor.B, this.BackColor.G, this.BackColor.R);
binaryheader.cForeground = new RGBQUAD(this.ForeColor.B, this.ForeColor.G, this.ForeColor.R);
binaryheader.Write(writer);
break;
}
}
Graphics graphics = Graphics.FromImage(aSrcImage);
IntPtr hdc = graphics.GetHdc();
IntPtr ptr2 = CreateCompatibleDC(hdc);
SelectObject(ptr2, aSrcImage.GetHbitmap());
IntPtr ptr3 = CreateCompatibleDC(hdc);
graphics.ReleaseHdc(hdc);
IntPtr zero = IntPtr.Zero;
IntPtr ptr = LocalAlloc(0x40, (uint) (bmpheader.info.bmiHeader.biSize + 8));
Marshal.StructureToPtr(bmpheader.info.bmiHeader, ptr, false);
new RGBQUAD(0, 0, 0).WriteToPtr(ptr, bmpheader.info.bmiHeader.biSize);
new RGBQUAD(0xff, 0xff, 0xff).WriteToPtr(ptr, bmpheader.info.bmiHeader.biSize + 4);
IntPtr hObj = CreateDIBSection(ptr2, ptr, 0, ref zero, IntPtr.Zero, 0);
IntPtr ptr7 = SelectObject(ptr3, hObj);
BitBlt(ptr3, 0, 0, bmpheader.info.bmiHeader.biWidth, bmpheader.info.bmiHeader.biHeight, ptr2, 0, 0, 0xcc0020);
if (withBorder)
{
IntPtr ptr8 = CreatePen(0, this.m_IsQvga ? 1 : 2, 0xffffff);
if ((ptr3 != IntPtr.Zero) && (ptr8 != IntPtr.Zero))
{
SelectObject(ptr3, ptr8);
}
this.LineTo(ptr3, 0, 0, aWidth - 1, 0);
this.LineTo(ptr3, aWidth - 1, 0, aWidth - 1, aHeight - 1);
this.LineTo(ptr3, aWidth - 1, aHeight - 1, 0, aHeight - 1);
this.LineTo(ptr3, 0, aHeight - 1, 0, 0);
if (ptr8 != IntPtr.Zero)
{
DeleteObject(ptr8);
}
}
byte[] destination = new byte[bmpheader.info.bmiHeader.biSizeImage];
Marshal.Copy(zero, destination, 0, (int) bmpheader.info.bmiHeader.biSizeImage);
if (type == BitmapType.BinaryStrict)
{
this.SwapLines(destination, width, height);
}
writer.Write(destination);
DeleteObject(SelectObject(ptr3, ptr7));
DeleteDC(ptr3);
DeleteDC(ptr2);
LocalFree(ptr);
}
public void Load(Stream stream, BitmapType type, bool setSize)
{
BinaryReader reader = new BinaryReader(stream);
Stream output = stream;
BMPHEADER bmpheader = null;
byte[] pBits = null;
int width = 0;
int iWidth = 0;
int height = 0;
switch (type)
{
case BitmapType.Binary:
case BitmapType.BinaryStrict:
{
BINARYHEADER binaryheader = new BINARYHEADER();
binaryheader.Read(reader);
width = binaryheader.iWidth;
iWidth = binaryheader.iWidth;
height = binaryheader.iHeight;
if ((width % 8) != 0)
{
width = (width / 8) + 1;
}
else
{
width /= 8;
}
if ((width % 4) != 0)
{
width += 4 - (width % 4);
}
this.ForeColor = Color.FromArgb(binaryheader.cForeground.rgbRed, binaryheader.cForeground.rgbGreen, binaryheader.cForeground.rgbBlue);
this.BackColor = Color.FromArgb(binaryheader.cBackground.rgbRed, binaryheader.cBackground.rgbGreen, binaryheader.cBackground.rgbBlue);
output = new MemoryStream();
BinaryWriter writer = new BinaryWriter(output);
bmpheader = new BMPHEADER();
bmpheader.header.bfSize = bmpheader.header.bfOffBits + ((uint) (width * height));
bmpheader.info.bmiHeader.biWidth = iWidth;
bmpheader.info.bmiHeader.biHeight = height;
bmpheader.info.bmiHeader.biSizeImage = (uint) (width * height);
bmpheader.info.bmiColor1 = new RGBQUAD(this.BackColor.B, this.BackColor.G, this.BackColor.R);
bmpheader.info.bmiColor2 = new RGBQUAD(this.ForeColor.B, this.ForeColor.G, this.ForeColor.R);
bmpheader.Write(writer);
long position = reader.BaseStream.Position;
pBits = reader.ReadBytes((int) (reader.BaseStream.Length - reader.BaseStream.Position));
if (type == BitmapType.BinaryStrict)
{
this.SwapLines(pBits, width, height);
}
writer.Write(pBits);
reader.BaseStream.Position = position;
break;
}
default:
bmpheader = new BMPHEADER();
bmpheader.Read(reader);
width = bmpheader.info.bmiHeader.biWidth;
iWidth = bmpheader.info.bmiHeader.biWidth;
height = bmpheader.info.bmiHeader.biHeight;
if ((width % 8) == 0)
{
width /= 8;
}
else
{
width = (width / 8) + 1;
}
if ((width % 4) != 0)
{
width += 4 - (width % 4);
}
this.BackColor = Color.FromArgb(bmpheader.info.bmiColor1.rgbRed, bmpheader.info.bmiColor1.rgbGreen, bmpheader.info.bmiColor1.rgbBlue);
this.ForeColor = Color.FromArgb(bmpheader.info.bmiColor2.rgbRed, bmpheader.info.bmiColor2.rgbGreen, bmpheader.info.bmiColor2.rgbBlue);
pBits = reader.ReadBytes((int) bmpheader.info.bmiHeader.biSizeImage);
break;
}
if (setSize)
{
this.m_ImageSize.Width = iWidth;
this.m_ImageSize.Height = height;
if (!this.m_ImageSizeCustom)
{
this.Size = this.m_ImageSize;
}
}
base.CreateGraphics();
this.CreateMemoryBitmap();
this.CreateGdiObjects();
this.CreatePenObjects();
Bitmap image = new Bitmap(this.ImageSize.Width, this.ImageSize.Height);
Graphics.FromImage(image).Clear(Color.FromArgb(0xff, 0, 0xff));
Bitmap bitmap2 = new Bitmap(output);
ImageAttributes imageAttr = new ImageAttributes();
imageAttr.SetColorKey(this.BackColor, this.BackColor);
Graphics.FromImage(image).DrawImage(bitmap2, new Rectangle(0, 0, image.Width, image.Height), 0, 0, bitmap2.Width, bitmap2.Height, GraphicsUnit.Pixel, imageAttr);
if (bitmap2 != null)
{
bitmap2.Dispose();
bitmap2 = null;
}
this.Clear();
IntPtr dC = GetDC(base.Handle);
IntPtr hdc = CreateCompatibleDC(dC);
IntPtr zero = IntPtr.Zero;
IntPtr ptr = LocalAlloc(0x40, (uint) (bmpheader.info.bmiHeader.biSize + 8));
Marshal.StructureToPtr(bmpheader.info.bmiHeader, ptr, false);
Marshal.WriteInt32(ptr, bmpheader.info.bmiHeader.biSize, 0);
Marshal.WriteInt32(ptr, bmpheader.info.bmiHeader.biSize + 4, 0xffffff);
IntPtr hObj = CreateDIBSection(dC, ptr, 0, ref zero, IntPtr.Zero, 0);
if ((type == BitmapType.BinaryStrict) && (pBits == null))
{
pBits = reader.ReadBytes((int) bmpheader.info.bmiHeader.biSizeImage);
this.SwapLines(pBits, width, height);
}
Marshal.Copy(pBits, 0, zero, (int) bmpheader.info.bmiHeader.biSizeImage);
pBits = null;
IntPtr ptr7 = SelectObject(hdc, hObj);
Graphics graphics = Graphics.FromImage(this.m_ImageDC);
IntPtr hdcDest = graphics.GetHdc();
BitBlt(hdcDest, 0, 0, bmpheader.info.bmiHeader.biWidth, bmpheader.info.bmiHeader.biHeight, hdc, 0, 0, 0xcc0020);
DeleteObject(SelectObject(hdc, ptr7));
DeleteDC(hdc);
graphics.ReleaseHdc(hdcDest);
LocalFree(ptr);
this.m_isEmpty = false;
if (this.m_bmp != null)
{
this.m_bmp.Dispose();
this.m_bmp = null;
}
this.m_bmp = image;
this.Refresh();
}
public void Load(string filename, BitmapType type, bool setSize)
{
FileStream stream = new FileStream(filename, FileMode.Open);
this.Load(stream, type, setSize);
stream.Close();
}
public ISO8583Message(BitmapType Type, bool secondaryBitmapPresent)
{
this.Bitmap = Type;
this.isSecondaryBitmapPresent = secondaryBitmapPresent;
}
public ISO8583Message(BitmapType Type)
{
this.Bitmap = Type;
}
public void Save(string filename, BitmapType type)
{
FileStream stream = new FileStream(filename, FileMode.Create);
this.Save(stream, type, false);
stream.Close();
}
public void Save(Stream stream, BitmapType type, bool withBorder)
{
this.Save(stream, type, withBorder, this.ImageSize.Width, this.ImageSize.Height, this.m_ImageDC);
}
public void Save(string filename, BitmapType type, bool withBorder)
{
FileStream stream = new FileStream(filename, FileMode.Create);
this.Save(stream, type, withBorder);
stream.Close();
}
public void Save(Stream stream, BitmapType type, bool withBorder, ZoomPercent aZoom)
{
Bitmap thumbnailBmp = GetThumbnail.GetThumbnailBmp(this.m_ImageDC, aZoom);
this.Save(stream, type, withBorder, thumbnailBmp.Width, thumbnailBmp.Height, thumbnailBmp);
}
internal IntPtr AllockBitmap(BitmapType type, int width, int height, uint linePadding, ref GflColor backgroundColor)
{
this.ThrowIfDisposed();
if(this._AllockBitmapDelegate == null){
this._AllockBitmapDelegate = this.LoadMethod<AllockBitmapDelegate>("gflAllockBitmap");
}
return this._AllockBitmapDelegate(type, width, height, linePadding, ref backgroundColor);
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapInfo"/> class.
/// </summary>
/// <param name="offset">The offset.</param>
/// <param name="meta">The meta.</param>
/// <remarks></remarks>
public BitmapInfo(int offset, ref Meta meta)
{
BinaryReader BR = new BinaryReader(meta.MS);
BR.BaseStream.Position = offset;
tagtype = BR.ReadChars(4);
width = BR.ReadUInt16();
height = BR.ReadUInt16();
depth = BR.ReadUInt16();
type = BR.ReadUInt16();
typename = (BitmapType)type;
// case BitmapFormat.BITM_TYPE_LIGHTMAP:
format = BR.ReadUInt16();
formatname = (BitmapFormat)format;
switch (formatname)
{
case BitmapFormat.BITM_FORMAT_A8:
case BitmapFormat.BITM_FORMAT_P8:
case BitmapFormat.BITM_FORMAT_Y8:
case BitmapFormat.BITM_FORMAT_AY8:
case BitmapFormat.BITM_FORMAT_LIGHTMAP:
bitsPerPixel = 8;
break;
case BitmapFormat.BITM_FORMAT_A1R5G5B5:
case BitmapFormat.BITM_FORMAT_A4R4G4B4:
case BitmapFormat.BITM_FORMAT_A8Y8:
case BitmapFormat.BITM_FORMAT_R5G6B5:
case BitmapFormat.BITM_FORMAT_G8B8:
case BitmapFormat.BITM_FORMAT_UNKNOWN:
bitsPerPixel = 16;
break;
case BitmapFormat.BITM_FORMAT_X8R8G8B8:
case BitmapFormat.BITM_FORMAT_A8R8G8B8:
case BitmapFormat.BITM_FORMAT_DXT1:
case BitmapFormat.BITM_FORMAT_DXT2AND3:
case BitmapFormat.BITM_FORMAT_DXT4AND5:
bitsPerPixel = 32;
break;
default:
bitsPerPixel = 0;
break;
}
flags = BR.ReadUInt16();
// if ((flags & 0x1000) == 0x1000) { swizzle = true; }
if ((flags & 0x8) == 0x8)
{
swizzle = true;
}
regPointX = BR.ReadUInt16();
regPointY = BR.ReadUInt16();
mipMapCount = BR.ReadUInt16();
pixelOffset = BR.ReadUInt16();
}
public Bitmap toBitmap(BitmapType type)
{
Bitmap bmp = new Bitmap(height, width);
if (BitmapType.GrayScale == type)
{
for (int x = 0; x < O3DImage.height; x++)
{
for (int y = 0; y < O3DImage.width; y++)
{
float dum = ((imageData[x, y] - min) / (max - min)) * 255;
int gray = (int)dum;
bmp.SetPixel(x, y, Color.FromArgb(gray, gray, gray));
}
}
}
return bmp;
}
/// <summary>
/// The decode bitm.
/// </summary>
/// <param name="bitmBytes">The bitm bytes.</param>
/// <param name="height">The height.</param>
/// <param name="width">The width.</param>
/// <param name="depth">The depth.</param>
/// <param name="bitsPerPixel">The bits per pixel.</param>
/// <param name="type">The type.</param>
/// <param name="format">The format.</param>
/// <param name="swizzle">The swizzle.</param>
/// <param name="map">The map.</param>
/// <param name="visualchunkindex">The visualchunkindex.</param>
/// <param name="ident">The ident.</param>
/// <returns></returns>
/// <exception cref="Exception">
/// </exception>
///
/// <exception cref="Exception">
/// </exception>
/// <remarks></remarks>
public static Bitmap DecodeBitm(
byte[] bitmBytes,
int height,
int width,
int depth,
int bitsPerPixel,
BitmapType type,
BitmapFormat format,
bool swizzle,
Map map,
int visualchunkindex,
int ident)
{
int stride = 0;
#region Volume Textures / 3D
if (type == BitmapType.BITM_TYPE_3D)
{
List<Bitmap> images = new List<Bitmap>();
Bitmap finalImage = null;
List<IntPtr> tPtr = new List<IntPtr>();
if (swizzle)
{
bitmBytes = Swizzler.Swizzle(bitmBytes, width, height, depth, bitsPerPixel, true);
}
try
{
// Make our new image large enough to handle a square of all the images together with a 2 pixel pad between
int imageSize = width * height * bitsPerPixel >> 3;
int rCount = (int)(Math.Sqrt(depth) + 0.5);
int tWidth = rCount * (width + 1);
int tHeight = (int)Math.Round(depth / rCount + 0.5f, MidpointRounding.AwayFromZero) * (height + 2);
// Display 3D bitmaps combined as a 2D bitmap
if (visualchunkindex == 0)
{
for (int i = 0; i < depth; i++)
{
byte[] tempBytes = new byte[imageSize];
Array.Copy(bitmBytes, i * imageSize, tempBytes, 0, imageSize);
stride = DecodeBitmap(
ref tempBytes,
height,
width,
1,
bitsPerPixel,
type,
format,
false,
map,
visualchunkindex,
ident);
tPtr.Add(Marshal.AllocHGlobal(tempBytes.Length));
RtlMoveMemory(tPtr[tPtr.Count - 1], tempBytes, tempBytes.Length);
Bitmap bitmap = new Bitmap(
width, height, stride, PixelFormat.Format32bppArgb, tPtr[tPtr.Count - 1]);
images.Add(bitmap);
}
}
// Display only one of the 3D images
else
{
byte[] tempBytes = new byte[imageSize];
Array.Copy(bitmBytes, (visualchunkindex - 1) * imageSize, tempBytes, 0, imageSize);
stride = DecodeBitmap(
ref tempBytes,
height,
width,
1,
bitsPerPixel,
type,
format,
false,
map,
visualchunkindex,
ident);
tPtr.Add(Marshal.AllocHGlobal(tempBytes.Length));
RtlMoveMemory(tPtr[tPtr.Count - 1], tempBytes, tempBytes.Length);
images.Add(new Bitmap(width, height, stride, PixelFormat.Format32bppArgb, tPtr[tPtr.Count - 1]));
tWidth = width;
tHeight = height;
}
// create a bitmap to hold the combined image
finalImage = new Bitmap(tWidth, tHeight);
// get a graphics object from the image so we can draw on it
using (Graphics g = Graphics.FromImage(finalImage))
{
// set background color
g.Clear(Color.Empty);
// go through each image and draw it on the final image
int offset = 0;
foreach (Bitmap image in images)
{
g.DrawImage(
image,
new Rectangle(
offset % tWidth, (offset / tWidth) * (image.Height + 1), image.Width, image.Height));
offset += image.Width + 1;
}
}
return finalImage;
}
catch (Exception ex)
{
if (finalImage != null)
{
finalImage.Dispose();
}
throw ex;
//Global.ShowErrorMsg("Error loading bitmap", ex);
}
finally
{
// clean up memory
foreach (Bitmap image in images)
{
image.Dispose();
}
foreach (IntPtr p in tPtr)
{
Marshal.FreeHGlobal(p);
}
}
}
#endregion
#region Cubemap
else if (type == BitmapType.BITM_TYPE_CUBEMAP)
{
// stride = DecodeBitmap(ref bitmBytes, height, width, 1, bitsPerPixel, type, format, swizzle, map, visualchunkindex, ident);
List<Bitmap> images = new List<Bitmap>();
Bitmap finalImage = null;
List<IntPtr> tPtr = new List<IntPtr>();
// Don't think any cubemaps are swizzled, but...
if (swizzle)
{
int imageSize = bitmBytes.Length / 6; // width * height * bitsPerPixel >> 3;
for (int i = 0; i < 6; i++)
{
bitmBytes = Swizzler.Swizzle(bitmBytes, i * imageSize, width, height, depth, bitsPerPixel, true);
}
}
try
{
// Make our new image large enough to handle a square of all the images together with a 2 pixel pad between
//int tWidth = 2 * (width + 2) + 10; // Add some extras..
int tWidth = 4 * width; // Add some extras..
int tHeight = 3 * height;
int imageSize = width * height * (bitsPerPixel >> 3);
// Total image size has each image (including it's mipmaps) padded to 256
int tImageSize = bitmBytes.Length / 6;
// Unused, just divide stream size by 6 as above
int ttImageSize = imageSize +
((imageSize / 6) % 256 == 0 ? 0 : ((256 * 6) - (imageSize % (256 * 6))));
// All cubemaps should be DXT1...
switch (format)
{
case BitmapFormat.BITM_FORMAT_DXT1:
imageSize = Math.Max(imageSize / 8, 8);
break;
case BitmapFormat.BITM_FORMAT_DXT2AND3:
case BitmapFormat.BITM_FORMAT_DXT4AND5:
imageSize = Math.Max(imageSize / 4, 16);
break;
}
//int mipmaps = 0;
for (int i = 0; i < 6; i++)
{
int tw = width;
int th = height;
int tempSize = imageSize;
int offset = 0;
//while (tw > 2 & th > 2)
{
byte[] tempBytes = new byte[tempSize];
Array.Copy(bitmBytes, i * tImageSize + offset, tempBytes, 0, tempSize);
stride = DecodeBitmap(
ref tempBytes,
th,
tw,
1,
bitsPerPixel,
type,
format,
false,
map,
visualchunkindex,
ident);
tPtr.Add(Marshal.AllocHGlobal(tempBytes.Length));
RtlMoveMemory(tPtr[tPtr.Count - 1], tempBytes, tempBytes.Length);
Bitmap bitmap = new Bitmap(
tw, th, stride, PixelFormat.Format32bppArgb, tPtr[tPtr.Count - 1]);
images.Add(bitmap);
offset += tempSize;
tempSize /= 4;
tw /= 2;
th /= 2;
}
}
// create a bitmap to hold the combined image
finalImage = new Bitmap(tWidth, tHeight);
// get a graphics object from the image so we can draw on it
using (Graphics g = Graphics.FromImage(finalImage))
{
// set background color
g.Clear(Color.Empty);
//
int[] crossX = new int[6] { 2, 0, 1, 1, 1, 3 }; // Right, Left, Top, Bottom, Front, Back
int[] crossY = new int[6] { 1, 1, 0, 2, 1, 1 }; // Right, Left, Top, Bottom, Front, Back
// go through each image and draw it on the final image
int xOffset = 0;
int yOffset = 0;
int tempCount = 0;
foreach (Bitmap image in images)
{
/*
if (mipmapCount == 0)
{
xOffset = 0;
yOffset += image.Height + 2;
mipmapCount = images.Count / 6;
}
*/
xOffset = crossX[tempCount] * image.Width;
yOffset = crossY[tempCount] * image.Height;
g.DrawImage(image, new Rectangle(xOffset, yOffset, image.Width, image.Height));
tempCount++;
}
}
return finalImage;
}
catch (Exception ex)
{
if (finalImage != null)
{
finalImage.Dispose();
}
throw ex;
//Global.ShowErrorMsg("Error while processing bitmap", ex);
}
finally
{
// clean up memory
foreach (Bitmap image in images)
{
image.Dispose();
}
foreach (IntPtr p in tPtr)
{
Marshal.FreeHGlobal(p);
}
}
}
#endregion
#region 2D Textures
else
{
stride = DecodeBitmap(
ref bitmBytes, height, width, 1, bitsPerPixel, type, format, swizzle, map, visualchunkindex, ident);
}
#endregion
/*
// This creates a memory leaks from HGlobal
IntPtr intPtr = Marshal.AllocHGlobal(bitmBytes.Length);
RtlMoveMemory(intPtr, bitmBytes, bitmBytes.Length);
Bitmap temp = new Bitmap(width, height, stride, PixelFormat.Format32bppArgb, intPtr);
temp.Tag = intPtr; // This NEEDS to be released when disposed
*/
Bitmap temp = new Bitmap(width, height, PixelFormat.Format32bppArgb);
Rectangle rect = new Rectangle( 0, 0, width, height);
BitmapData data = null;
try
{
data = temp.LockBits(rect, ImageLockMode.WriteOnly, temp.PixelFormat);
System.Runtime.InteropServices.Marshal.Copy(bitmBytes, 0, data.Scan0, Math.Min(bitmBytes.Length, data.Width * data.Height * 4));
}
finally
{
if (data != null)
temp.UnlockBits(data);
}
return temp;
}
public void setBitmapType(BitmapType type)
{
this.bitmapType = type;
}
