{***********************************************************
glBitmap by Steffen Xonna aka Lossy eX (2003-2008)
http://www.opengl24.de/index.php?cat=header&file=glbitmap
+
+modified by Delphi OpenGL Community (http://delphigl.com/)
+
+
------------------------------------------------------------
The contents of this file are used with permission, subject to
the Mozilla Public License Version 1.1 (the "License"); you may
{.$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}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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/
+// PNG /////////////////////////////////////////////////////////////////////////////////////////////
+// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/
// if you enable pngimage the libPNG will be ignored
-{.$DEFINE GLB_PNGIMAGE}
+{$DEFINE GLB_PNGIMAGE}
-// activate to use the libPNG http://www.libpng.org/
-// You will need an aditional header.
-// http://www.opengl24.de/index.php?cat=header&file=libpng
+// activate to use the libPNG -> http://www.libpng.org/
+// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng
{.$DEFINE GLB_LIB_PNG}
+// JPEG ////////////////////////////////////////////////////////////////////////////////////////////
// if you enable delphi jpegs the libJPEG will be ignored
{.$DEFINE GLB_DELPHI_JPEG}
-// activateto use the libJPEG http://www.ijg.org/
-// You will need an aditional header.
-// http://www.opengl24.de/index.php?cat=header&file=libjpeg
+// activate to use the libJPEG -> http://www.ijg.org/
+// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg
{.$DEFINE GLB_LIB_JPEG}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// PRIVATE: DO not change anything! //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// PRIVATE: do not change anything! //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Delphi Versions
{$IFDEF fpc}
type
////////////////////////////////////////////////////////////////////////////////////////////////////
- EglBitmapException = class(Exception);
- EglBitmapSizeToLargeException = class(EglBitmapException);
- EglBitmapNonPowerOfTwoException = class(EglBitmapException);
- EglBitmapUnsupportedFormat = class(EglBitmapException);
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmapFormat = (
tfEmpty = 0, //must be smallest value!
nm3x3,
nm5x5);
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+ EglBitmapException = class(Exception);
+ EglBitmapSizeToLargeException = class(EglBitmapException);
+ EglBitmapNonPowerOfTwoException = class(EglBitmapException);
+ EglBitmapUnsupportedFormat = class(EglBitmapException)
+ constructor Create(const aFormat: TglBitmapFormat);
+ end;
+
////////////////////////////////////////////////////////////////////////////////////////////////////
TglBitmapColorRec = packed record
case Integer of
*)
uses
- Math, syncobjs;
+ Math, syncobjs, typinfo;
type
////////////////////////////////////////////////////////////////////////////////////////////////////
FormatDescriptorCS: TCriticalSection;
FormatDescriptors: array[TglBitmapFormat] of TFormatDescriptor;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat);
+begin
+ inherited Create('unsupported format: ' + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
+end;
+
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition;
begin
tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then
result := result + [ftDDS];
- (* TODO
{$IFDEF GLB_SUPPORT_PNG_WRITE}
if aFormat in [
- tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16,
- tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16,
- tfuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16,
- tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16,
- tfRGBA2, tfRGBA4, tfRGB5A1, tfRGBA8, tfRGB10A2, tfRGBA12, tfRGBA16,
- tfDepth16, tfDepth24, tfDepth32]
- then
+ tfAlpha8, tfLuminance8, tfLuminance8Alpha8,
+ tfRGB8, tfRGBA8,
+ tfBGR8, tfBGRA8] then
result := result + [ftPNG];
{$ENDIF}
{$IFDEF GLB_SUPPORT_JPEG_WRITE}
- if Format in [
- tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16,
- tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16,
- tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16,
- tfDepth16, tfDepth24, tfDepth32]
- then
+ if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] then
result := result + [ftJPEG];
{$ENDIF}
-
- if aFormat in [
- tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16,
- tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16,
- tfuminance4Alpha4, tfLuminance6Alpha2, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16,
- tfR3G3B2, tfRGB4, tfRGB5, tfRGB8, tfRGB10, tfRGB12, tfRGB16,
- tfRGBA2, tfRGBA4, tfRGB5A1, tfRGBA8, tfRGB10A2, tfRGBA12, tfRGBA16,
- tfDepth16, tfDepth24, tfDepth32]
- then
- result := result + [ftDDS, ftTGA, ftBMP];
- *)
end;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if fFormat = aValue then
exit;
if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then
- raise EglBitmapUnsupportedFormat.Create('SetFormat');
+ raise EglBitmapUnsupportedFormat.Create(Format);
SetDataPointer(Data, aValue, Width, Height);
end;
begin
case aFileType of
{$IFDEF GLB_SUPPORT_PNG_WRITE}
- ftPNG: SavePng(aStream);
+ ftPNG: SavePNG(aStream);
{$ENDIF}
{$IFDEF GLB_SUPPORT_JPEG_WRITE}
ftJPEG: SaveJPEG(aStream);
FormatDesc := TFormatDescriptor.Get(Format);
if FormatDesc.IsCompressed then
- raise EglBitmapUnsupportedFormat.Create('AssignToSurface');
+ raise EglBitmapUnsupportedFormat.Create(Format);
if Assigned(Data) then begin
case Trunc(FormatDesc.PixelSize) of
3: TempDepth := 24;
4: TempDepth := 32;
else
- raise EglBitmapUnsupportedFormat.Create('AssignToSurface');
+ raise EglBitmapUnsupportedFormat.Create(Format);
end;
aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
begin
- (* TODO
- if not FormatIsUncompressed(InternalFormat) then
- raise EglBitmapUnsupportedFormatFormat.Create('AddAlphaFromFunc - ' + UNSUPPORTED_FORMAT);
- *)
+ if TFormatDescriptor.Get(Format).IsCompressed then
+ raise EglBitmapUnsupportedFormat.Create(Format);
result := AddFunc(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs);
end;
FormatDesc := TFormatDescriptor.Get(Format);
if Assigned(Data) then begin
if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
- raise EglBitmapUnsupportedFormat.Create('RemoveAlpha');
+ raise EglBitmapUnsupportedFormat.Create(Format);
result := ConvertTo(FormatDesc.WithoutAlpha);
end;
end;
png_info: png_infop;
TempHeight, TempWidth: Integer;
- Format: TglBitmapInternalFormat;
+ Format: TglBitmapFormat;
png_data: pByte;
png_rows: array of pByte;
try
// signature
- StreamPos := Stream.Position;
- Stream.Read(signature, 8);
- Stream.Position := StreamPos;
+ StreamPos := aStream.Position;
+ aStream.Read(signature{%H-}, 8);
+ aStream.Position := StreamPos;
if png_check_sig(@signature, 8) <> 0 then begin
// png read struct
end;
// set read callback
- png_set_read_fn(png, stream, glBitmap_libPNG_read_func);
+ png_set_read_fn(png, aStream, glBitmap_libPNG_read_func);
// read informations
png_read_info(png, png_info);
var
StreamPos: Int64;
Png: TPNGObject;
- Header: Array[0..7] of Byte;
+ Header: String[8];
Row, Col, PixSize, LineSize: Integer;
NewImage, pSource, pDest, pAlpha: pByte;
- Format: TglBitmapInternalFormat;
+ PngFormat: TglBitmapFormat;
+ FormatDesc: TFormatDescriptor;
const
- PngHeader: Array[0..7] of Byte = (#137, #80, #78, #71, #13, #10, #26, #10);
+ PngHeader: String[8] = #137#80#78#71#13#10#26#10;
begin
result := false;
- StreamPos := Stream.Position;
- Stream.Read(Header[0], SizeOf(Header));
- Stream.Position := StreamPos;
+ StreamPos := aStream.Position;
+ aStream.Read(Header[0], SizeOf(Header));
+ aStream.Position := StreamPos;
{Test if the header matches}
if Header = PngHeader then begin
Png := TPNGObject.Create;
try
- Png.LoadFromStream(Stream);
+ Png.LoadFromStream(aStream);
case Png.Header.ColorType of
COLOR_GRAYSCALE:
- Format := ifLuminance;
+ PngFormat := tfLuminance8;
COLOR_GRAYSCALEALPHA:
- Format := ifLuminanceAlpha;
+ PngFormat := tfLuminance8Alpha8;
COLOR_RGB:
- Format := ifBGR8;
+ PngFormat := tfBGR8;
COLOR_RGBALPHA:
- Format := ifBGRA8;
+ PngFormat := tfBGRA8;
else
raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
end;
- PixSize := Trunc(FormatGetSize(Format));
- LineSize := Integer(Png.Header.Width) * PixSize;
+ FormatDesc := TFormatDescriptor.Get(PngFormat);
+ PixSize := Round(FormatDesc.PixelSize);
+ LineSize := FormatDesc.GetSize(Png.Header.Width, 1);
GetMem(NewImage, LineSize * Integer(Png.Header.Height));
try
raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
end;
- SetDataPointer(NewImage, Format, Png.Header.Width, Png.Header.Height);
+ SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height);
result := true;
except
LineSize: Integer;
ColorType: Integer;
Row: Integer;
+ FormatDesc: TFormatDescriptor;
begin
- if not (ftPNG in FormatGetSupportedFiles (InternalFormat)) then
- raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ if not (ftPNG in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
if not init_libPNG then
- raise Exception.Create('SavePNG - unable to initialize libPNG.');
+ raise Exception.Create('unable to initialize libPNG.');
try
- case FInternalFormat of
- ifAlpha, ifLuminance, ifDepth8:
+ case Format of
+ tfAlpha8, tfLuminance8:
ColorType := PNG_COLOR_TYPE_GRAY;
- ifLuminanceAlpha:
+ tfLuminance8Alpha8:
ColorType := PNG_COLOR_TYPE_GRAY_ALPHA;
- ifBGR8, ifRGB8:
+ tfBGR8, tfRGB8:
ColorType := PNG_COLOR_TYPE_RGB;
- ifBGRA8, ifRGBA8:
+ tfBGRA8, tfRGBA8:
ColorType := PNG_COLOR_TYPE_RGBA;
else
- raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormat.Create(Format);
end;
- LineSize := Trunc(FormatGetSize(FInternalFormat) * Width);
+
+ FormatDesc := TFormatDescriptor.Get(Format);
+ LineSize := FormatDesc.GetSize(Width, 1);
// creating array for scanline
SetLength(png_rows, Height);
end;
// set read callback
- png_set_write_fn(png, stream, glBitmap_libPNG_write_func, nil);
+ png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil);
// set compression
png_set_compression_level(png, 6);
- if InternalFormat in [ifBGR8, ifBGRA8] then
+ if Format in [tfBGR8, tfBGRA8] then
png_set_bgr(png);
png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
pTemp: pByte;
Temp: Byte;
begin
- if not (ftPNG in FormatGetSupportedFiles (InternalFormat)) then
- raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ if not (ftPNG in FormatGetSupportedFiles (Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
- case FInternalFormat of
- ifAlpha, ifLuminance, ifDepth8: begin
+ case Format of
+ tfAlpha8, tfLuminance8: begin
ColorType := COLOR_GRAYSCALE;
- PixSize := 1;
- Alpha := false;
+ PixSize := 1;
+ Alpha := false;
end;
- ifLuminanceAlpha: begin
+ tfLuminance8Alpha8: begin
ColorType := COLOR_GRAYSCALEALPHA;
- PixSize := 1;
- Alpha := true;
+ PixSize := 1;
+ Alpha := true;
end;
- ifBGR8, ifRGB8: begin
+ tfBGR8, tfRGB8: begin
ColorType := COLOR_RGB;
- PixSize := 3;
- Alpha := false;
+ PixSize := 3;
+ Alpha := false;
end;
- ifBGRA8, ifRGBA8: begin
+ tfBGRA8, tfRGBA8: begin
ColorType := COLOR_RGBALPHA;
- PixSize := 3;
- Alpha := true
+ PixSize := 3;
+ Alpha := true
end;
else
- raise EglBitmapUnsupportedInternalFormat.Create('SavePng - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormat.Create(Format);
end;
Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height);
end;
// convert RGB line to BGR
- if InternalFormat in [ifRGB8, ifRGBA8] then begin
+ if Format in [tfRGB8, tfRGBA8] then begin
pTemp := png.ScanLine[Y];
for X := 0 to Width -1 do begin
Temp := pByteArray(pTemp)^[0];
// Save to Stream
Png.CompressionLevel := 6;
- Png.SaveToStream(Stream);
+ Png.SaveToStream(aStream);
finally
FreeAndNil(Png);
end;
DestBuffer: array [1..4096] of byte;
end;
+procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl;
+begin
+ //DUMMY
+end;
+
+
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl;
var
jpeg: jpeg_decompress_struct;
jpeg_err: jpeg_error_mgr;
- IntFormat: TglBitmapInternalFormat;
+ IntFormat: TglBitmapFormat;
pImage: pByte;
TempHeight, TempWidth: Integer;
pTemp: pByte;
Row: Integer;
+
+ FormatDesc: TFormatDescriptor;
begin
result := false;
try
// reading first two bytes to test file and set cursor back to begin
- StreamPos := Stream.Position;
- Stream.Read(Temp[0], 2);
- Stream.Position := StreamPos;
+ StreamPos := aStream.Position;
+ aStream.Read({%H-}Temp[0], 2);
+ aStream.Position := StreamPos;
// if Bitmap then read file.
if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
- FillChar(jpeg, SizeOf(jpeg_decompress_struct), $00);
- FillChar(jpeg_err, SizeOf(jpeg_error_mgr), $00);
+ FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00);
+ FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
// error managment
jpeg.err := jpeg_std_error(@jpeg_err);
- jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
+ jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
jpeg_err.output_message := glBitmap_libJPEG_output_message;
// decompression struct
pub.bytes_in_buffer := 0; // forces fill_input_buffer on first read
pub.next_input_byte := nil; // until buffer loaded
- SrcStream := Stream;
+ SrcStream := aStream;
end;
// set global decoding state
JCS_GRAYSCALE:
begin
jpeg.out_color_space := JCS_GRAYSCALE;
- IntFormat := ifLuminance;
+ IntFormat := tfLuminance8;
end;
else
jpeg.out_color_space := JCS_RGB;
- IntFormat := ifRGB8;
+ IntFormat := tfRGB8;
end;
// reading image
TempHeight := jpeg.output_height;
TempWidth := jpeg.output_width;
+ FormatDesc := TFormatDescriptor.Get(IntFormat);
+
// creating new image
- GetMem(pImage, FormatGetImageSize(glBitmapPosition(TempWidth, TempHeight), IntFormat));
+ GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight));
try
pTemp := pImage;
for Row := 0 to TempHeight -1 do begin
jpeg_read_scanlines(@jpeg, @pTemp, 1);
- Inc(pTemp, Trunc(FormatGetSize(IntFormat) * TempWidth));
+ Inc(pTemp, FormatDesc.GetSize(TempWidth, 1));
end;
// finish decompression
{$ENDIF}
{$IFDEF GLB_SUPPORT_JPEG_WRITE}
-{$IF DEFEFINED(GLB_LIB_JPEG)}
+{$IF DEFINED(GLB_LIB_JPEG)}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveJPEG(Stream: TStream);
+procedure TglBitmap.SaveJPEG(const aStream: TStream);
var
jpeg: jpeg_compress_struct;
jpeg_err: jpeg_error_mgr;
begin
if not (ftJPEG in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedInternalFormat.Create('SaveJpg - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ raise EglBitmapUnsupportedFormat.Create(Format);
if not init_libJPEG then
raise Exception.Create('SaveJPG - unable to initialize libJPEG.');
try
- FillChar(jpeg, SizeOf(jpeg_compress_struct), $00);
- FillChar(jpeg_err, SizeOf(jpeg_error_mgr), $00);
+ FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00);
+ FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
// error managment
jpeg.err := jpeg_std_error(@jpeg_err);
- jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
+ jpeg_err.error_exit := glBitmap_libJPEG_error_exit;
jpeg_err.output_message := glBitmap_libJPEG_output_message;
// compression struct
pub.next_output_byte := @DestBuffer[1];
pub.free_in_buffer := Length(DestBuffer);
- DestStream := Stream;
+ DestStream := aStream;
end;
// very important state
jpeg.global_state := CSTATE_START;
jpeg.image_width := Width;
jpeg.image_height := Height;
- case InternalFormat of
- ifAlpha, ifLuminance, ifDepth8: begin
+ case Format of
+ tfAlpha8, tfLuminance8: begin
jpeg.input_components := 1;
- jpeg.in_color_space := JCS_GRAYSCALE;
+ jpeg.in_color_space := JCS_GRAYSCALE;
end;
- ifRGB8, ifBGR8: begin
+ tfRGB8, tfBGR8: begin
jpeg.input_components := 3;
- jpeg.in_color_space := JCS_RGB;
+ jpeg.in_color_space := JCS_RGB;
end;
end;
jpeg_start_compress(@jpeg, true);
pTemp := Data;
- if InternalFormat = ifBGR8 then
+ if Format = tfBGR8 then
GetMem(pTemp2, fRowSize)
else
pTemp2 := pTemp;
try
for Row := 0 to jpeg.image_height -1 do begin
// prepare row
- if InternalFormat = ifBGR8 then
+ if Format = tfBGR8 then
CopyRow(pTemp2, pTemp)
else
pTemp2 := pTemp;
end;
finally
// free memory
- if InternalFormat = ifBGR8 then
+ if Format = tfBGR8 then
FreeMem(pTemp2);
end;
jpeg_finish_compress(@jpeg);
begin
if not (ftBMP in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create('SaveBMP');
+ raise EglBitmapUnsupportedFormat.Create(Format);
Converter := nil;
FormatDesc := TFormatDescriptor.Get(Format);
Info.biCompression := BMP_COMP_BITFIELDS;
end;
else
- raise EglBitmapUnsupportedFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
+ raise EglBitmapUnsupportedFormat.Create(Format);
end;
Info.biXPelsPerMeter := 2835;
Info.biYPelsPerMeter := 2835;
Converter: TFormatDescriptor;
begin
if not (ftTGA in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create('SaveTGA');
+ raise EglBitmapUnsupportedFormat.Create(Format);
//prepare header
FillChar(Header{%H-}, SizeOf(Header), 0);
FormatDesc: TFormatDescriptor;
begin
if not (ftDDS in FormatGetSupportedFiles(Format)) then
- raise EglBitmapUnsupportedFormat.Create('SaveDDS');
+ raise EglBitmapUnsupportedFormat.Create(Format);
FormatDesc := TFormatDescriptor.Get(Format);
begin
FormatDesc := TFormatDescriptor.Get(Format);
if FormatDesc.IsCompressed then
- raise EglBitmapUnsupportedFormat.Create('TglBitmap2D.GrabScreen');
+ raise EglBitmapUnsupportedFormat.Create(Format);
w := aRight - aLeft;
h := aBottom - aTop;
end;
begin
- (* TODO Compression
- if not FormatIsUncompressed(InternalFormat) then
- raise EglBitmapUnsupportedFormatFormat.Create('TglBitmap2D.ToNormalMap - ' + UNSUPPORTED_FORMAT);
- *)
+ if TFormatDescriptor.Get(Format).IsCompressed then
+ raise EglBitmapUnsupportedFormat.Create(Format);
if aScale > 100 then
Rec.Scale := 100
projects / glBitmap.git / blobdiff