A bitmap in Simba is simply a two dimensional field of colours. These colours can all be the same, or they can be of different colours. Simba features functions to create, manipulate and search for bitmaps.
The bitmaps are - just as files - represented as integer in Simba (they point to a list of bitmaps, and the value of the integer is the position in the list). So typically, when referring to bitmaps in Simba, you simply represent them as an integer:
var bmp, x, y: integer;
begin
bmp := CreateBitmap(10, 10); // Create a bitmap of size (10, 10)
if FindBitmapIn(bmp, x, y, 0, 0, 300, 300) then
writeln('Found it!');
FreeBitmap(bmp); // Don't forget to free it when we are done.
end;
Note that the previous example doesn’t make a lot of sense as the bitmap has only been created and not filled with any colours, they are as of yet, undefined. You can also create bitmaps from screenshots and load them when your script starts using the BitmapFromString function, or simple store them as files and load them using the LoadBitmap function.
Bitmaps in Simba are internally all instances of TMufasaBitmap. Scripts should generally access bitmaps using their handle: an integer. All functions referenced here either require a bitmap handle or return one.
If you want to gain more access over a specific bitmap, see the GetMufasaBitmap function. It is highly unrecommended to create bitmaps like this, because Simba will not free them automatically for you. (There’s no problem doing it like this if you only want to perform operations on it and then free it again)
var bmp: TMufasaBitmap;
begin
bmp := TMufasBitmap.Create;
end;
Because there is no way to get a handle to this bitmap; as it will not be managed by Simba internally. (All Bitmaps created by CreateBitmap are managed by Simba, if you don’t know what this means: you generally want Simba to manage the bitmaps)
If you still want access to the TMufasaBitmap, use GetMufasaBitmap, described below.
function GetMufasaBitmap(bmp : integer) : TMufasaBitmap;
Returns the TMufasaBitmap for the given bitmap. They both reference the same bitmap. TMufasaBitmap is a more advanced interface to bitmaps in Simba. There is no way to get a internal (integer) reference to a bitmap if you create it with TMufasaBitmap.Create; so the recommended way is to use CreateBitmap to get the integer reference/handle and then call this function to get the class reference.
var bmp: TMufasaBitmap;
bmph: integer;
begin;
bmph := CreateBitmap(100, 100);
bmp := GetMufasaBitmap(bmph);
bmp.SetSize(150,150); // also changes bmph, as they are the same bitmap.
end;
function CreateBitmapString(bmp : integer) : string;
Creates a string for the given bitmap, you can use this to save a bitmap for later us, for example loading it again using BitmapFromString.
function CreateBitmap(w,h :integer) : integer;
Create a bitmap with width h and height h. Returns the reference to the created bitmap.
procedure FreeBitmap(Bmp : integer);
Free the bitmap. You should do this when you no longer need the bitmap. Be careful when working with bitmaps: not freeing it when you no longer need it leads to memory leaks, which will eventually make your script crash. (Unless you stop it in time, in which case Simba will free the bitmaps for you)
procedure SaveBitmap(Bmp : integer; path : string);
Save the given bitmap to the specified path.
function BitmapFromString(Width,Height : integer; Data : string): integer;
Load a bitmap from the given string. This command is usually generated with the Bitmap to String feature in Simba.
function LoadBitmap(Path : string) : integer;
Load a bitmap from a path to a file. Formats known to work are BMP and PNG images.
procedure SetBitmapSize(Bmp,NewW,NewH : integer);
Change the size of the bitmap. Previous data will be preserved (if possible), so enlarging the bitmap won’t destroy the old data, but shrinking it will inevitably destroy some data. (Everything that falls out of the new bounds)
procedure GetBitmapSize(Bmp : integer; var BmpW,BmpH : integer);
Returns the size of the bitmap in BmpW, BmpH.
procedure StretchBitmapResize(Bmp,NewW,NewH : integer);
function CreateMirroredBitmap(Bmp : integer) : integer;
function CreateMirroredBitmapEx(Bmp : integer; MirrorStyle : TBmpMirrorStyle) : integer;
procedure FastSetPixel(bmp,x,y : integer; Color : TColor);
Set the pixel on the bitmap at position x, y to color.
procedure FastSetPixels(bmp : integer; TPA : TPointArray; Colors : TIntegerArray);
Set the pixels on the bitmap at position TPA[index] to Colors[index].
function FastGetPixel(bmp, x,y : integer) : TColor;
Return the colour of pixel on the bitmap, position specified by x, y.
function FastGetPixels(Bmp : integer; TPA : TPointArray) : TIntegerArray;
Return an array of the colours on the bitmap; positions specified by TPA.
function GetBitmapAreaColors(bmp,xs, ys, xe, ye: Integer): T2DIntegerArray;
Returns all the colours in the area defined by (xs, xy, xe, ye) on the bitmap in a two dimensions integer array.
procedure FastDrawClear(bmp : integer; Color : TColor);
Draw Color on every pixel on the bitmap.
procedure FastDrawTransparent(x, y: Integer; SourceBitmap, TargetBitmap: Integer);
procedure SetTransparentColor(bmp : integer; Color : TColor);
function GetTransparentColor(bmp: integer) : TColor;
procedure FastReplaceColor(Bmp : integer; OldColor,NewColor : TColor);
procedure CopyClientToBitmap(bmp, xs, ys, xe, ye: Integer);
Copy client area xs, ys, xe, ye to specified bitmap.
function BitmapFromClient(const xs, ys, xe, ye: Integer): Integer;
Create a bitmap from the client. Area specified by xs, ye, xe, ye.
procedure SetBitmapName(Bmp : integer; name : string);
Assign a name to the bitmap. Mainly for debugging purposes. (It will write the name of the bitmap if it hasn’t been freed.)
program new;
var bmp: integer;
begin
bmp := CreateBitmap(10, 10);
SetBitmapName(bmp, 'We will not free this bitmap');
end.
// Simba will print what bitmap has not been freed (along with his long
// name)
function FindBitmap(bitmap: integer; var x, y: Integer): Boolean;
Searches for the Bitmap bmp on the entire client. Returns true if found. If found, x, y specifies the position where the bitmap was found.
function FindBitmapIn(bitmap: integer; var x, y: Integer; xs, ys, xe, ye: Integer): Boolean;
Searches for the Bitmap bmp on the client in the area defined by xs,ys,xe,ye. Returns true if found. If found, x, y specifies the position where the bitmap was found.
function FindBitmapToleranceIn(bitmap: integer; var x, y: Integer; xs, ys, xe, ye: Integer; tolerance: Integer): Boolean;
Searches for the Bitmap bmp on the client in the area defined by xs,ys,xe,ye. Tolerance defines the tolerance per pixel when matching bitmaps. See Colour tolerance for more information on tolerance. Returns true if found. If found, x, y specifies the position where the bitmap was found.
function FindBitmapSpiral(bitmap: Integer; var x, y: Integer; xs, ys, xe, ye: Integer): Boolean;
Searches for the Bitmap bmp on the client in the area defined by xs,ys,xe,ye. Returns true if found. If found, x, y specifies the position where the bitmap was found. Search starts from a point defined by x, y.
function FindBitmapsSpiralTolerance(bitmap: integer; x, y: Integer; var Points : TPointArray; xs, ys, xe, ye,tolerance: Integer): Boolean;
Searches for the Bitmap bmp on the client in the area defined by xs,ys,xe,ye. Tolerance defines the tolerance per pixel when matching bitmaps. See Colour tolerance for more information on tolerance. Search starts from a point defined by x, y. Returns true if found. If found, each point in TPA specifies a match.
function FindBitmapSpiralTolerance(bitmap: integer; var x, y: Integer; xs, ys, xe, ye,tolerance : integer): Boolean;
Searches for the Bitmap bmp on the client in the area defined by xs,ys,xe,ye. Tolerance defines the tolerance per pixel when matching bitmaps. See Colour tolerance for more information on tolerance. Search starts from a point defined by x, y. Returns true if found. If found, x, y specifies the position where the bitmap was found.
function RotateBitmap(bitmap: Integer; angle: Extended): Integer;
function DesaturateBitmap(Bitmap : integer) : integer;
procedure InvertBitmap(Bitmap : integer);
function CopyBitmap(Bitmap: integer) : integer)
Creates a copy of the Bitmap. Returns the bitmap copy.
function GreyScaleBitmap(bitmap : integer) : integer
Creates a copy of the bitmap, greyscaled.
function BrightnessBitmap(Bitmap,br : integer) : integer;
Changes the brightness of a bitmap, intensity defined by br. Returns a new bitmap with the brightness applied.
If you instead want to apply brightness to the current bitmap, see Applying a filter on the current bitmap
function ContrastBitmap(bitmap : integer; co : extended) : integer;
Changes the constrast of a bitmap, returns a new bitmap with the contrast applied.
function PosterizeBitmap(Bitmap : integer; po : integer) : integer;
Posterizes a bitmap, intensity defined by po; returns a new bitmap with the posterisation applied.
var b: integer;
begin
// Dummy bitmap. You'll want something that's not just a blank bitmap.
B:=CreateBitmap(100,100);
// Apply the filter (Posterize in this case) without making a copy.
GetMufasaBitmap(b).Posterize(GetMufasaBitmap(b), 10);
// Always free your bitmaps when you no longer use them. :)
FreeBitmap(b);
end.
function CreateMaskFromBitmap(Bitmap : integer) : TMask;
function FindMaskTolerance(const mask: TMask; var x, y: Integer; xs,ys, xe, ye: Integer; Tolerance, ContourTolerance: Integer): Boolean;
function FindBitmapMaskTolerance(mask: Integer; var x, y: Integer; xs, ys, xe, ye: Integer; Tolerance, ContourTolerance: Integer): Boolean;
function FindDeformedBitmapToleranceIn(bitmap: integer; var x,y: Integer; xs, ys, xe, ye: Integer; tolerance: Integer; Range: Integer; AllowPartialAccuracy: Boolean; var accuracy: Extended): Boolean;
procedure DrawTPABitmap(bitmap: integer; TPA: TPointArray; Color: integer);
Draws a TPointArray on a bitmap. Each point in the TPointArray is painted on the bitmap by setting the pixel on the bitmap (position defined by tpa point) to color.
procedure DrawATPABitmap(bitmap: integer; ATPA: T2DPointArray);
Draws a Array of TPointArray on a bitmap. Each point in the TPointArray is painted on the bitmap by setting the pixel on the bitmap (position defined by tpa point) to a color. Colors differ per TPointArray (group).
procedure DrawATPABitmapEx(bitmap: integer; ATPA: T2DPointArray; Colors: TIntegerArray);
Draws a Array of TPointArray on a bitmap. Each point in the TPointArray is painted on the bitmap by setting the pixel on the bitmap (position defined by tpa point) to a color. Colors are defined by Colors.
procedure DrawBitmap(Bmp: Integer; Dest: TCanvas; x, y: Integer);
Draw the bitmap to a TCanvas.
procedure RectangleBitmap(bitmap : integer; const box : TBox; Color : TColor);
procedure FloodFillBitmap(bitmap : integer; const StartPoint : TPoint; const SearchCol,ReplaceCol : TColor);
function CalculatePixelShift(Bmp1,Bmp2 : Integer; CompareBox : TBox) : integer;
function CalculatePixelTolerance(Bmp1,Bmp2 : Integer; CompareBox : TBox; CTS : integer) : extended;')