opengl
/
glBitmap
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Przeglądaj źródła

* added SDL support

master
Bergmann89 12 lat temu
rodzic
d52e74ca50
commit
68113a32f5
1 zmienionych plików z 89 dodań i 152 usunięć
Widok podzielony
Opcje porównania
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania
  1. +89
    -152
      glBitmap.pas

+ 89
- 152
glBitmap.pas Wyświetl plik

@@ -227,10 +227,10 @@ unit glBitmap;

// activate to enable build-in OpenGL support with dynamically linked methods
// use dglOpenGL.pas if not enabled
{$DEFINE GLB_NATIVE_OGL_DYNAMIC}
{.$DEFINE GLB_NATIVE_OGL_DYNAMIC}

// activate to enable the support for SDL_surfaces
{.$DEFINE GLB_SDL}
{$DEFINE GLB_SDL}

// activate to enable the support for TBitmap from Delphi (not lazarus)
{.$DEFINE GLB_DELPHI}
@@ -239,7 +239,7 @@ unit glBitmap;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// activate to enable the support of SDL_image to load files. (READ ONLY)
// If you enable SDL_image all other libraries will be ignored!
{.$DEFINE GLB_SDL_IMAGE}
{$DEFINE GLB_SDL_IMAGE}

// activate to enable png support with the unit pngimage. You can download it from http://pngdelphi.sourceforge.net/
// if you enable pngimage the libPNG will be ignored
@@ -681,7 +681,7 @@ type
EglBitmapException = class(Exception);
EglBitmapSizeToLargeException = class(EglBitmapException);
EglBitmapNonPowerOfTwoException = class(EglBitmapException);
EglBitmapUnsupportedFormatFormat = class(EglBitmapException);
EglBitmapUnsupportedFormat = class(EglBitmapException);

////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmapFormat = (
@@ -977,14 +977,12 @@ type
constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
{$ENDIF}
private
{$IFDEF GLB_SUPPORT_PNG_READ}
function LoadPNG(const aStream: TStream): Boolean; virtual;
procedure SavePNG(const aStream: TStream); virtual;
{$ENDIF}
{$IFDEF GLB_SUPPORT_JPEG_READ}
function LoadJPEG(const aStream: TStream): Boolean; virtual;
procedure SaveJPEG(const aStream: TStream); virtual;
{$ENDIF}
{$IFDEF GLB_SUPPORT_PNG_READ} function LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF}
{$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF}

{$IFDEF GLB_SUPPORT_JPEG_READ} function LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF}
{$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF}

function LoadBMP(const aStream: TStream): Boolean; virtual;
procedure SaveBMP(const aStream: TStream); virtual;

@@ -1140,10 +1138,10 @@ type

TFormatDescriptor = class(TObject)
private
function GetRedMask: UInt64;
function GetGreenMask: UInt64;
function GetBlueMask: UInt64;
function GetAlphaMask: UInt64;
function GetRedMask: QWord;
function GetGreenMask: QWord;
function GetBlueMask: QWord;
function GetAlphaMask: QWord;
protected
fFormat: TglBitmapFormat;
fWithAlpha: TglBitmapFormat;
@@ -1177,10 +1175,10 @@ type
property Range: TglBitmapColorRec read fRange;
property Shift: TShiftRec read fShift;

property RedMask: UInt64 read GetRedMask;
property GreenMask: UInt64 read GetGreenMask;
property BlueMask: UInt64 read GetBlueMask;
property AlphaMask: UInt64 read GetAlphaMask;
property RedMask: QWord read GetRedMask;
property GreenMask: QWord read GetGreenMask;
property BlueMask: QWord read GetBlueMask;
property AlphaMask: QWord read GetAlphaMask;

procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract;
procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract;
@@ -1193,7 +1191,7 @@ type

function IsEmpty: Boolean; virtual;
function HasAlpha: Boolean; virtual;
function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: UInt64): Boolean; virtual;
function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; virtual;

procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual;

@@ -1532,17 +1530,17 @@ type
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TbmpBitfieldFormat = class(TFormatDescriptor)
private
procedure SetRedMask (const aValue: UInt64);
procedure SetGreenMask(const aValue: UInt64);
procedure SetBlueMask (const aValue: UInt64);
procedure SetAlphaMask(const aValue: UInt64);
procedure SetRedMask (const aValue: QWord);
procedure SetGreenMask(const aValue: QWord);
procedure SetBlueMask (const aValue: QWord);
procedure SetAlphaMask(const aValue: QWord);

procedure Update(aMask: UInt64; out aRange: Cardinal; out aShift: Byte);
procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte);
public
property RedMask: UInt64 read GetRedMask write SetRedMask;
property GreenMask: UInt64 read GetGreenMask write SetGreenMask;
property BlueMask: UInt64 read GetBlueMask write SetBlueMask;
property AlphaMask: UInt64 read GetAlphaMask write SetAlphaMask;
property RedMask: QWord read GetRedMask write SetRedMask;
property GreenMask: QWord read GetGreenMask write SetGreenMask;
property BlueMask: QWord read GetBlueMask write SetBlueMask;
property AlphaMask: QWord read GetAlphaMask write SetAlphaMask;

property PixelSize: Single read fPixelSize write fPixelSize;

@@ -1803,7 +1801,7 @@ begin
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function GetTopMostBit(aBitSet: UInt64): Integer;
function GetTopMostBit(aBitSet: QWord): Integer;
begin
result := 0;
while aBitSet > 0 do begin
@@ -1813,7 +1811,7 @@ begin
end;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CountSetBits(aBitSet: UInt64): Integer;
function CountSetBits(aBitSet: QWord): Integer;
begin
result := 0;
while aBitSet > 0 do begin
@@ -2126,8 +2124,10 @@ end;
{$ENDIF}
*)

(* TODO GLB_SDL_IMAGE
{$IFDEF GLB_SDL_IMAGE}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
begin
result := TStream(context^.unknown.data1).Seek(offset, whence);
@@ -2162,7 +2162,6 @@ begin
result^.unknown.data1 := Stream;
end;
{$ENDIF}
*)

(* TODO LoadFuncs
function LoadTexture(Filename: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal{$ENDIF}): Boolean;
@@ -2366,25 +2365,25 @@ end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TFormatDescriptor.GetRedMask: UInt64;
function TFormatDescriptor.GetRedMask: QWord;
begin
result := fRange.r shl fShift.r;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TFormatDescriptor.GetGreenMask: UInt64;
function TFormatDescriptor.GetGreenMask: QWord;
begin
result := fRange.g shl fShift.g;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TFormatDescriptor.GetBlueMask: UInt64;
function TFormatDescriptor.GetBlueMask: QWord;
begin
result := fRange.b shl fShift.b;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TFormatDescriptor.GetAlphaMask: UInt64;
function TFormatDescriptor.GetAlphaMask: QWord;
begin
result := fRange.a shl fShift.a;
end;
@@ -2447,7 +2446,7 @@ begin
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: UInt64): Boolean;
function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean;
begin
result := false;

@@ -3781,31 +3780,31 @@ end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TBitfieldFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpBitfieldFormat.SetRedMask(const aValue: UInt64);
procedure TbmpBitfieldFormat.SetRedMask(const aValue: QWord);
begin
Update(aValue, fRange.r, fShift.r);
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpBitfieldFormat.SetGreenMask(const aValue: UInt64);
procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord);
begin
Update(aValue, fRange.g, fShift.g);
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpBitfieldFormat.SetBlueMask(const aValue: UInt64);
procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord);
begin
Update(aValue, fRange.b, fShift.b);
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: UInt64);
procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord);
begin
Update(aValue, fRange.a, fShift.a);
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpBitfieldFormat.Update(aMask: UInt64; out aRange: Cardinal; out
procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out
aShift: Byte);
begin
aShift := 0;
@@ -3829,10 +3828,8 @@ end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
var
data: UInt64;
data: QWord;
s: Integer;
type
PUInt64 = ^UInt64;
begin
data :=
((aPixel.Data.r and fRange.r) shl fShift.r) or
@@ -3844,7 +3841,7 @@ begin
1: aData^ := data;
2: PWord(aData)^ := data;
4: PCardinal(aData)^ := data;
8: PUInt64(aData)^ := data;
8: PQWord(aData)^ := data;
else
raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
end;
@@ -3854,17 +3851,15 @@ end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
var
data: UInt64;
data: QWord;
s, i: Integer;
type
PUInt64 = ^UInt64;
begin
s := Round(fPixelSize);
case s of
1: data := aData^;
2: data := PWord(aData)^;
4: data := PCardinal(aData)^;
8: data := PUInt64(aData)^;
8: data := PQWord(aData)^;
else
raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
end;
@@ -3956,10 +3951,8 @@ end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
type
PUInt64 = ^UInt64;
var
idx: UInt64;
idx: QWord;
s: Integer;
bits: Byte;
f: Single;
@@ -3972,7 +3965,7 @@ begin
1: idx := aData^;
2: idx := PWord(aData)^;
4: idx := PCardinal(aData)^;
8: idx := PUInt64(aData)^;
8: idx := PQWord(aData)^;
else
raise EglBitmapException.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
end;
@@ -4227,7 +4220,7 @@ begin
if fFormat = aValue then
exit;
if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then
raise EglBitmapUnsupportedFormatFormat.Create('SetInternalFormat - ' + UNSUPPORTED_FORMAT);
raise EglBitmapUnsupportedFormat.Create('SetFormat');
SetDataPointer(Data, aValue, Width, Height);
end;

@@ -4603,42 +4596,37 @@ var
Row, RowSize: Integer;
SourceData, TmpData: PByte;
TempDepth: Integer;
Pix: TglBitmapPixelData;
FormatDesc: TglBitmapFormatDescriptor;
FormatDesc: TFormatDescriptor;

function GetRowPointer(Row: Integer): pByte;
begin
result := Surface.pixels;
result := aSurface.pixels;
Inc(result, Row * RowSize);
end;

begin
result := false;

(* TODO
if not FormatIsUncompressed(InternalFormat) then
raise EglBitmapUnsupportedInternalFormat.Create('AssignToSurface - ' + UNSUPPORTED_INTERNAL_FORMAT);
*)
FormatDesc := TFormatDescriptor.Get(Format);
if FormatDesc.IsCompressed then
raise EglBitmapUnsupportedFormat.Create('AssignToSurface');

FormatDesc := FORMAT_DESCRIPTORS[Format];
if Assigned(Data) then begin
case Trunc(FormatDesc.GetSize) of
case Trunc(FormatDesc.PixelSize) of
1: TempDepth := 8;
2: TempDepth := 16;
3: TempDepth := 24;
4: TempDepth := 32;
else
raise EglBitmapException.Create('AssignToSurface - ' + UNSUPPORTED_INTERNAL_FORMAT);
raise EglBitmapUnsupportedFormat.Create('AssignToSurface');
end;
FormatDesc.PreparePixel(Pix);
with Pix.PixelDesc do
Surface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
RedRange shl RedShift, GreenRange shl GreenShift, BlueRange shl BlueShift, AlphaRange shl AlphaShift);

aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask);
SourceData := Data;
RowSize := Ceil(FileWidth * FormatDesc.GetSize);
RowSize := FormatDesc.GetSize(FileWidth, 1);

for Row := 0 to FileHeight -1 do begin
for Row := 0 to FileHeight-1 do begin
TmpData := GetRowPointer(Row);
if Assigned(TmpData) then begin
Move(SourceData^, TmpData^, RowSize);
@@ -4654,34 +4642,31 @@ function TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
var
pSource, pData, pTempData: PByte;
Row, RowSize, TempWidth, TempHeight: Integer;
IntFormat, f: TglBitmapInternalFormat;
FormatDesc: TglBitmapFormatDescriptor;
IntFormat: TglBitmapFormat;
FormatDesc: TFormatDescriptor;

function GetRowPointer(Row: Integer): pByte;
begin
result := Surface^.pixels;
result := aSurface^.pixels;
Inc(result, Row * RowSize);
end;

begin
result := false;
if (Assigned(Surface)) then begin
with Surface^.format^ do begin
IntFormat := tfEmpty;
for f := Low(f) to High(f) do begin
if FORMAT_DESCRIPTORS[f].MaskMatch(RMask, GMask, BMask, AMask) then begin
IntFormat := f;
if (Assigned(aSurface)) then begin
with aSurface^.format^ do begin
for IntFormat := High(TglBitmapFormat) to Low(TglBitmapFormat) do begin
FormatDesc := TFormatDescriptor.Get(IntFormat);
if (FormatDesc.MaskMatch(RMask, GMask, BMask, AMask)) then
break;
end;
end;
if (IntFormat = tfEmpty) then
raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.');
end;

FormatDesc := FORMAT_DESCRIPTORS[IntFormat];
TempWidth := Surface^.w;
TempHeight := Surface^.h;
RowSize := Trunc(TempWidth * FormatDesc.GetSize);
TempWidth := aSurface^.w;
TempHeight := aSurface^.h;
RowSize := FormatDesc.GetSize(TempWidth, 1);
GetMem(pData, TempHeight * RowSize);
try
pTempData := pData;
@@ -4721,9 +4706,9 @@ begin

AlphaInterleave := 0;
case Format of
ifLuminance8Alpha8:
tfLuminance8Alpha8:
AlphaInterleave := 1;
ifBGRA8, ifRGBA8:
tfBGRA8, tfRGBA8:
AlphaInterleave := 3;
end;

@@ -4745,14 +4730,14 @@ begin
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean;
function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
var
bmp: TglBitmap2D;
begin
bmp := TglBitmap2D.Create;
try
bmp.AssignFromSurface(Surface);
result := AddAlphaFromGlBitmap(bmp, Func, CustomData);
bmp.AssignFromSurface(aSurface);
result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs);
finally
bmp.Free;
end;
@@ -5147,7 +5132,7 @@ begin
FormatDesc := TFormatDescriptor.Get(Format);
if Assigned(Data) then begin
if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
raise EglBitmapUnsupportedFormatFormat.Create('RemoveAlpha - ' + UNSUPPORTED_FORMAT);
raise EglBitmapUnsupportedFormat.Create('RemoveAlpha');
result := ConvertTo(FormatDesc.WithoutAlpha);
end;
end;
@@ -5522,7 +5507,7 @@ begin
Surface := IMG_LoadPNG_RW(RWops);
try
AssignFromSurface(Surface);
Rresult := true;
result := true;
finally
SDL_FreeSurface(Surface);
end;
@@ -5922,40 +5907,6 @@ type
DestBuffer: array [1..4096] of byte;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl;
var
Msg: String;
begin
SetLength(Msg, 256);
cinfo^.err^.format_message(cinfo, pChar(Msg));
Writeln('ERROR [' + IntToStr(cinfo^.err^.msg_code) + '] ' + Msg);
cinfo^.global_state := 0;
jpeg_abort(cinfo);
end;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl;
var
Msg: String;
begin
SetLength(Msg, 256);
cinfo^.err^.format_message(cinfo, pChar(Msg));
Writeln('OUTPUT [' + IntToStr(cinfo^.err^.msg_code) + '] ' + Msg);
cinfo^.global_state := 0;
end;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl;
begin
end;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl;
var
@@ -5997,20 +5948,6 @@ begin
end;
end;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl;
begin
end;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl;
begin
end;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl;
var
@@ -6062,7 +5999,7 @@ var
begin
result := false;

RWops := glBitmapCreateRWops(Stream);
RWops := glBitmapCreateRWops(aStream);
try
if IMG_isJPG(RWops) > 0 then begin
Surface := IMG_LoadJPG_RW(RWops);
@@ -6622,7 +6559,7 @@ var

begin
if not (ftBMP in FormatGetSupportedFiles(Format)) then
raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
raise EglBitmapUnsupportedFormat.Create('SaveBMP');

Converter := nil;
FormatDesc := TFormatDescriptor.Get(Format);
@@ -6687,7 +6624,7 @@ begin
Info.biCompression := BMP_COMP_BITFIELDS;
end;
else
raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
raise EglBitmapUnsupportedFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
end;
Info.biXPelsPerMeter := 2835;
Info.biYPelsPerMeter := 2835;
@@ -6804,7 +6741,7 @@ const
function TglBitmap.LoadTGA(const aStream: TStream): Boolean;
var
Header: TTGAHeader;
ImageData: PByte;
ImageData: System.PByte;
StartPosition: Int64;
PixelSize, LineSize: Integer;
tgaFormat: TglBitmapFormat;
@@ -6822,7 +6759,7 @@ const
procedure ReadUncompressed;
var
i, j: Integer;
buf, tmp1, tmp2: PByte;
buf, tmp1, tmp2: System.PByte;
begin
buf := nil;
if (Counter.X.dir < 0) then
@@ -6856,7 +6793,7 @@ const

/////////////////////////////////////////////////////////////////
var
TmpData: PByte;
TmpData: System.PByte;
LinePixelsRead: Integer;
procedure CheckLine;
begin
@@ -7083,7 +7020,7 @@ var
Converter: TFormatDescriptor;
begin
if not (ftTGA in FormatGetSupportedFiles(Format)) then
raise EglBitmapUnsupportedFormatFormat.Create('SaveTGA - ' + UNSUPPORTED_FORMAT);
raise EglBitmapUnsupportedFormat.Create('SaveTGA');

//prepare header
FillChar(Header{%H-}, SizeOf(Header), 0);
@@ -7296,7 +7233,7 @@ var
var
StreamPos: Int64;
x, y, LineSize, RowSize, Magic: Cardinal;
NewImage, TmpData, RowData, SrcData: PByte;
NewImage, TmpData, RowData, SrcData: System.PByte;
SourceMD, DestMD: Pointer;
Pixel: TglBitmapPixelData;
ddsFormat: TglBitmapFormat;
@@ -7399,7 +7336,7 @@ var
FormatDesc: TFormatDescriptor;
begin
if not (ftDDS in FormatGetSupportedFiles(Format)) then
raise EglBitmapUnsupportedFormatFormat.Create('SaveDDS - ' + UNSUPPORTED_FORMAT);
raise EglBitmapUnsupportedFormat.Create('SaveDDS');

FormatDesc := TFormatDescriptor.Get(Format);

@@ -7542,7 +7479,7 @@ var
begin
FormatDesc := TFormatDescriptor.Get(Format);
if FormatDesc.IsCompressed then
raise EglBitmapUnsupportedFormatFormat.Create('TglBitmap2D.GrabScreen - ' + UNSUPPORTED_FORMAT);
raise EglBitmapUnsupportedFormat.Create('TglBitmap2D.GrabScreen');

w := aRight - aLeft;
h := aBottom - aTop;


Napisz Podgląd
Ładowanie…
Anuluj
Zapisz