X-Git-Url: https://git.delphigl.com/?p=glBitmap.git;a=blobdiff_plain;f=glBitmap.pas;h=bde9922d63a4802483211831f47cb66900aa8466;hp=b1817054a283a804b46a85663356ae56b876a2df;hb=8b8a4ade7f33c7809f6d3e76154527bc1492e356;hpb=39d0b4a3cc4b5d49c02b79eac4f7fa7d40691c9e diff --git a/glBitmap.pas b/glBitmap.pas index b181705..bde9922 100644 --- a/glBitmap.pas +++ b/glBitmap.pas @@ -11,7 +11,7 @@ not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/MPL-1.1.html ------------------------------------------------------------ -Version 3.0.0 unstable +Version 3.0.1 ------------------------------------------------------------ History 20-11-2013 @@ -221,7 +221,7 @@ unit glBitmap; // Please uncomment the defines below to configure the glBitmap to your preferences. // If you have configured the unit you can uncomment the warning above. -{.$MESSAGE warn 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} +{$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Preferences /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -238,7 +238,7 @@ unit glBitmap; // activate to enable the support for SDL_surfaces {.$DEFINE GLB_SDL} -// activate to enable the support for TBitmap from Delphi (not lazarus) +// activate to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap) {.$DEFINE GLB_DELPHI} // activate to enable the support for TLazIntfImage from Lazarus @@ -773,62 +773,81 @@ var type //////////////////////////////////////////////////////////////////////////////////////////////////// +// the name of formats is composed of the following constituents: +// - multiple chanals: +// - channel (e.g. R, G, B, A or Alpha, Luminance or X (reserved) +// - width of the chanel in bit (4, 8, 16, ...) +// - data type (e.g. ub, us, ui) +// - number of data types + + TglBitmapFormat = ( - tfEmpty = 0, //must be smallest value! - - tfAlpha4, - tfAlpha8, - tfAlpha12, - tfAlpha16, - - tfLuminance4, - tfLuminance8, - tfLuminance12, - tfLuminance16, - - tfLuminance4Alpha4, - tfLuminance6Alpha2, - tfLuminance8Alpha8, - tfLuminance12Alpha4, - tfLuminance12Alpha12, - tfLuminance16Alpha16, - - tfR3G3B2, - tfRGB4, - tfR5G6B5, - tfRGB5, - tfRGB8, - tfRGB10, - tfRGB12, - tfRGB16, - - tfRGBA2, - tfRGBA4, - tfRGB5A1, - tfRGBA8, - tfRGB10A2, - tfRGBA12, - tfRGBA16, - - tfBGR4, - tfB5G6R5, - tfBGR5, - tfBGR8, - tfBGR10, - tfBGR12, - tfBGR16, - - tfBGRA2, - tfBGRA4, - tfBGR5A1, - tfBGRA8, - tfBGR10A2, - tfBGRA12, - tfBGRA16, - - tfDepth16, - tfDepth24, - tfDepth32, + tfEmpty = 0, //must be smallest value! + + tfAlpha4ub1, // 1 x unsigned byte + tfAlpha8ub1, // 1 x unsigned byte + tfAlpha16us1, // 1 x unsigned short + + tfLuminance4ub1, // 1 x unsigned byte + tfLuminance8ub1, // 1 x unsigned byte + tfLuminance16us1, // 1 x unsigned short + + tfLuminance4Alpha4ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance6Alpha2ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance8Alpha8ub2, // 1 x unsigned byte (lum), 1 x unsigned byte (alpha) + tfLuminance12Alpha4us2, // 1 x unsigned short (lum), 1 x unsigned short (alpha) + tfLuminance16Alpha16us2, // 1 x unsigned short (lum), 1 x unsigned short (alpha) + + tfR3G3B2ub1, // 1 x unsigned byte (3bit red, 3bit green, 2bit blue) + tfRGBX4us1, // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit reserverd) + tfXRGB4us1, // 1 x unsigned short (4bit reserved, 4bit red, 4bit green, 4bit blue) + tfR5G6B5us1, // 1 x unsigned short (5bit red, 6bit green, 5bit blue) + tfRGB5X1us1, // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit reserved) + tfX1RGB5us1, // 1 x unsigned short (1bit reserved, 5bit red, 5bit green, 5bit blue) + tfRGB8ub3, // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue) + tfRGBX8ui1, // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8bit reserved) + tfXRGB8ui1, // 1 x unsigned int (8bit reserved, 8bit red, 8bit green, 8bit blue) + tfRGB10X2ui1, // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit reserved) + tfX2RGB10ui1, // 1 x unsigned int (2bit reserved, 10bit red, 10bit green, 10bit blue) + tfRGB16us3, // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue) + + tfRGBA4us1, // 1 x unsigned short (4bit red, 4bit green, 4bit blue, 4bit alpha) + tfARGB4us1, // 1 x unsigned short (4bit alpha, 4bit red, 4bit green, 4bit blue) + tfRGB5A1us1, // 1 x unsigned short (5bit red, 5bit green, 5bit blue, 1bit alpha) + tfA1RGB5us1, // 1 x unsigned short (1bit alpha, 5bit red, 5bit green, 5bit blue) + tfRGBA8ui1, // 1 x unsigned int (8bit red, 8bit green, 8bit blue, 8 bit alpha) + tfARGB8ui1, // 1 x unsigned int (8 bit alpha, 8bit red, 8bit green, 8bit blue) + tfRGBA8ub4, // 1 x unsigned byte (red), 1 x unsigned byte (green), 1 x unsigned byte (blue), 1 x unsigned byte (alpha) + tfRGB10A2ui1, // 1 x unsigned int (10bit red, 10bit green, 10bit blue, 2bit alpha) + tfA2RGB10ui1, // 1 x unsigned int (2bit alpha, 10bit red, 10bit green, 10bit blue) + tfRGBA16us4, // 1 x unsigned short (red), 1 x unsigned short (green), 1 x unsigned short (blue), 1 x unsigned short (alpha) + + tfBGRX4us1, // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit reserved) + tfXBGR4us1, // 1 x unsigned short (4bit reserved, 4bit blue, 4bit green, 4bit red) + tfB5G6R5us1, // 1 x unsigned short (5bit blue, 6bit green, 5bit red) + tfBGR5X1us1, // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit reserved) + tfX1BGR5us1, // 1 x unsigned short (1bit reserved, 5bit blue, 5bit green, 5bit red) + tfBGR8ub3, // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red) + tfBGRX8ui1, // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit reserved) + tfXBGR8ui1, // 1 x unsigned int (8bit reserved, 8bit blue, 8bit green, 8bit red) + tfBGR10X2ui1, // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit reserved) + tfX2BGR10ui1, // 1 x unsigned int (2bit reserved, 10bit blue, 10bit green, 10bit red) + tfBGR16us3, // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red) + + tfBGRA4us1, // 1 x unsigned short (4bit blue, 4bit green, 4bit red, 4bit alpha) + tfABGR4us1, // 1 x unsigned short (4bit alpha, 4bit blue, 4bit green, 4bit red) + tfBGR5A1us1, // 1 x unsigned short (5bit blue, 5bit green, 5bit red, 1bit alpha) + tfA1BGR5us1, // 1 x unsigned short (1bit alpha, 5bit blue, 5bit green, 5bit red) + tfBGRA8ui1, // 1 x unsigned int (8bit blue, 8bit green, 8bit red, 8bit alpha) + tfABGR8ui1, // 1 x unsigned int (8bit alpha, 8bit blue, 8bit green, 8bit red) + tfBGRA8ub4, // 1 x unsigned byte (blue), 1 x unsigned byte (green), 1 x unsigned byte (red), 1 x unsigned byte (alpha) + tfBGR10A2ui1, // 1 x unsigned int (10bit blue, 10bit green, 10bit red, 2bit alpha) + tfA2BGR10ui1, // 1 x unsigned int (2bit alpha, 10bit blue, 10bit green, 10bit red) + tfBGRA16us4, // 1 x unsigned short (blue), 1 x unsigned short (green), 1 x unsigned short (red), 1 x unsigned short (alpha) + + tfDepth16us1, // 1 x unsigned short (depth) + tfDepth24ui1, // 1 x unsigned int (depth) + tfDepth32ui1, // 1 x unsigned int (depth) tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, @@ -866,47 +885,105 @@ type end; //////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmapColorRec = packed record + TglBitmapRec4ui = packed record case Integer of 0: (r, g, b, a: Cardinal); 1: (arr: array[0..3] of Cardinal); end; - TglBitmapPixelData = packed record - Data, Range: TglBitmapColorRec; - Format: TglBitmapFormat; + TglBitmapRec4ub = packed record + case Integer of + 0: (r, g, b, a: Byte); + 1: (arr: array[0..3] of Byte); end; - PglBitmapPixelData = ^TglBitmapPixelData; -//////////////////////////////////////////////////////////////////////////////////////////////////// - TglBitmapPixelPositionFields = set of (ffX, ffY); - TglBitmapPixelPosition = record - Fields : TglBitmapPixelPositionFields; - X : Word; - Y : Word; + TglBitmapRec4ul = packed record + case Integer of + 0: (r, g, b, a: QWord); + 1: (arr: array[0..3] of QWord); end; TglBitmapFormatDescriptor = class(TObject) + strict private + // cached properties + fBytesPerPixel: Single; + fChannelCount: Integer; + fMask: TglBitmapRec4ul; + fRange: TglBitmapRec4ui; + + function GetHasRed: Boolean; + function GetHasGreen: Boolean; + function GetHasBlue: Boolean; + function GetHasAlpha: Boolean; + function GetHasColor: Boolean; + function GetIsGrayscale: Boolean; protected - function GetIsCompressed: Boolean; virtual; abstract; - function GetHasRed: Boolean; virtual; abstract; - function GetHasGreen: Boolean; virtual; abstract; - function GetHasBlue: Boolean; virtual; abstract; - function GetHasAlpha: Boolean; virtual; abstract; - - function GetglDataFormat: GLenum; virtual; abstract; - function GetglFormat: GLenum; virtual; abstract; - function GetglInternalFormat: GLenum; virtual; abstract; + fFormat: TglBitmapFormat; + fWithAlpha: TglBitmapFormat; + fWithoutAlpha: TglBitmapFormat; + fOpenGLFormat: TglBitmapFormat; + fRGBInverted: TglBitmapFormat; + fUncompressed: TglBitmapFormat; + + fBitsPerPixel: Integer; + fIsCompressed: Boolean; + + fPrecision: TglBitmapRec4ub; + fShift: TglBitmapRec4ub; + + fglFormat: GLenum; + fglInternalFormat: GLenum; + fglDataFormat: GLenum; + + procedure SetValues; virtual; + procedure CalcValues; public - property IsCompressed: Boolean read GetIsCompressed; + property Format: TglBitmapFormat read fFormat; + property ChannelCount: Integer read fChannelCount; + property IsCompressed: Boolean read fIsCompressed; + property BitsPerPixel: Integer read fBitsPerPixel; + property BytesPerPixel: Single read fBytesPerPixel; + + property Precision: TglBitmapRec4ub read fPrecision; + property Shift: TglBitmapRec4ub read fShift; + property Range: TglBitmapRec4ui read fRange; + property Mask: TglBitmapRec4ul read fMask; + + property RGBInverted: TglBitmapFormat read fRGBInverted; + property WithAlpha: TglBitmapFormat read fWithAlpha; + property WithoutAlpha: TglBitmapFormat read fWithAlpha; + property OpenGLFormat: TglBitmapFormat read fOpenGLFormat; + property Uncompressed: TglBitmapFormat read fUncompressed; + + property glFormat: GLenum read fglFormat; + property glInternalFormat: GLenum read fglInternalFormat; + property glDataFormat: GLenum read fglDataFormat; + property HasRed: Boolean read GetHasRed; property HasGreen: Boolean read GetHasGreen; property HasBlue: Boolean read GetHasBlue; property HasAlpha: Boolean read GetHasAlpha; + property HasColor: Boolean read GetHasColor; + property IsGrayscale: Boolean read GetIsGrayscale; + + constructor Create; + public + class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; + end; + +//////////////////////////////////////////////////////////////////////////////////////////////////// + TglBitmapPixelData = packed record + Data: TglBitmapRec4ui; + Range: TglBitmapRec4ui; + Format: TglBitmapFormat; + end; + PglBitmapPixelData = ^TglBitmapPixelData; - property glFormat: GLenum read GetglFormat; - property glInternalFormat: GLenum read GetglInternalFormat; - property glDataFormat: GLenum read GetglDataFormat; + TglBitmapPixelPositionFields = set of (ffX, ffY); + TglBitmapPixelPosition = record + Fields : TglBitmapPixelPositionFields; + X : Word; + Y : Word; end; //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1213,8 +1290,12 @@ procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal); procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal); function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition; -function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; -function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean; +function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub; +function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui; +function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul; +function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean; + +function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; var glBitmapDefaultDeleteTextureOnFree: Boolean; @@ -1236,7 +1317,6 @@ implementation uses Math, syncobjs, typinfo - {$IFDEF GLB_DELPHI}, Types{$ENDIF} {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND}; type @@ -1249,61 +1329,8 @@ type {$ENDIF} //////////////////////////////////////////////////////////////////////////////////////////////////// - TShiftRec = packed record - case Integer of - 0: (r, g, b, a: Byte); - 1: (arr: array[0..3] of Byte); - end; - TFormatDescriptor = class(TglBitmapFormatDescriptor) - private - function GetRedMask: QWord; - function GetGreenMask: QWord; - function GetBlueMask: QWord; - function GetAlphaMask: QWord; - protected - fFormat: TglBitmapFormat; - fWithAlpha: TglBitmapFormat; - fWithoutAlpha: TglBitmapFormat; - fRGBInverted: TglBitmapFormat; - fUncompressed: TglBitmapFormat; - fPixelSize: Single; - fIsCompressed: Boolean; - - fRange: TglBitmapColorRec; - fShift: TShiftRec; - - fglFormat: GLenum; - fglInternalFormat: GLenum; - fglDataFormat: GLenum; - - function GetIsCompressed: Boolean; override; - function GetHasRed: Boolean; override; - function GetHasGreen: Boolean; override; - function GetHasBlue: Boolean; override; - function GetHasAlpha: Boolean; override; - - function GetglFormat: GLenum; override; - function GetglInternalFormat: GLenum; override; - function GetglDataFormat: GLenum; override; - - function GetComponents: Integer; virtual; public - property Format: TglBitmapFormat read fFormat; - property WithAlpha: TglBitmapFormat read fWithAlpha; - property WithoutAlpha: TglBitmapFormat read fWithoutAlpha; - property RGBInverted: TglBitmapFormat read fRGBInverted; - property Components: Integer read GetComponents; - property PixelSize: Single read fPixelSize; - - property Range: TglBitmapColorRec read fRange; - property Shift: TShiftRec read fShift; - - 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; @@ -1313,16 +1340,15 @@ type function CreateMappingData: Pointer; virtual; procedure FreeMappingData(var aMappingData: Pointer); virtual; - function IsEmpty: Boolean; virtual; - function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; virtual; + function IsEmpty: Boolean; virtual; + function MaskMatch(const aMask: TglBitmapRec4ul): Boolean; virtual; procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual; - - constructor Create; virtual; public class procedure Init; class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor; - class function GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; + class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; + class function GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer = 0): TFormatDescriptor; class procedure Clear; class procedure Finalize; end; @@ -1331,342 +1357,367 @@ type TfdEmpty = class(TFormatDescriptor); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha_UB1 = class(TFormatDescriptor) //1* unsigned byte + TfdAlphaUB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminance_UB1 = class(TFormatDescriptor) //1* unsigned byte + TfdLuminanceUB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdUniversal_UB1 = class(TFormatDescriptor) //1* unsigned byte + TfdUniversalUB1 = class(TFormatDescriptor) //1* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //2* unsigned byte + TfdLuminanceAlphaUB2 = class(TfdLuminanceUB1) //2* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGB_UB3 = class(TFormatDescriptor) //3* unsigned byte + TfdRGBub3 = class(TFormatDescriptor) //3* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGR_UB3 = class(TFormatDescriptor) //3* unsigned byte (inverse) + TfdBGRub3 = class(TFormatDescriptor) //3* unsigned byte (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGBA_UB4 = class(TfdRGB_UB3) //4* unsigned byte + TfdRGBAub4 = class(TfdRGBub3) //3* unsigned byte procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGRA_UB4 = class(TfdBGR_UB3) //4* unsigned byte (inverse) + TfdBGRAub4 = class(TfdBGRub3) //3* unsigned byte (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha_US1 = class(TFormatDescriptor) //1* unsigned short + TfdAlphaUS1 = class(TFormatDescriptor) //1* unsigned short + procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + end; + + TfdLuminanceUS1 = class(TFormatDescriptor) //1* unsigned short + procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; + procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; + end; + + TfdUniversalUS1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminance_US1 = class(TFormatDescriptor) //1* unsigned short + TfdDepthUS1 = class(TFormatDescriptor) //1* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdUniversal_US1 = class(TFormatDescriptor) //1* unsigned short + TfdLuminanceAlphaUS2 = class(TfdLuminanceUS1) //2* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdDepth_US1 = class(TFormatDescriptor) //1* unsigned short + TfdRGBus3 = class(TFormatDescriptor) //3* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //2* unsigned short + TfdBGRus3 = class(TFormatDescriptor) //3* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGB_US3 = class(TFormatDescriptor) //3* unsigned short + TfdRGBAus4 = class(TfdRGBus3) //4* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGR_US3 = class(TFormatDescriptor) //3* unsigned short (inverse) + TfdARGBus4 = class(TfdRGBus3) //4* unsigned short procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdRGBA_US4 = class(TfdRGB_US3) //4* unsigned short + TfdBGRAus4 = class(TfdBGRus3) //4* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdBGRA_US4 = class(TfdBGR_US3) //4* unsigned short (inverse) + TfdABGRus4 = class(TfdBGRus3) //4* unsigned short (inverse) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdUniversal_UI1 = class(TFormatDescriptor) //1* unsigned int + TfdUniversalUI1 = class(TFormatDescriptor) //1* unsigned int procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; - TfdDepth_UI1 = class(TFormatDescriptor) //1* unsigned int + TfdDepthUI1 = class(TFormatDescriptor) //1* unsigned int procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - TfdAlpha4 = class(TfdAlpha_UB1) - constructor Create; override; + TfdAlpha4ub1 = class(TfdAlphaUB1) + procedure SetValues; override; + end; + + TfdAlpha8ub1 = class(TfdAlphaUB1) + procedure SetValues; override; + end; + + TfdAlpha16us1 = class(TfdAlphaUS1) + procedure SetValues; override; + end; + + TfdLuminance4ub1 = class(TfdLuminanceUB1) + procedure SetValues; override; end; - TfdAlpha8 = class(TfdAlpha_UB1) - constructor Create; override; + TfdLuminance8ub1 = class(TfdLuminanceUB1) + procedure SetValues; override; end; - TfdAlpha12 = class(TfdAlpha_US1) - constructor Create; override; + TfdLuminance16us1 = class(TfdLuminanceUS1) + procedure SetValues; override; end; - TfdAlpha16 = class(TfdAlpha_US1) - constructor Create; override; + TfdLuminance4Alpha4ub2 = class(TfdLuminanceAlphaUB2) + procedure SetValues; override; end; - TfdLuminance4 = class(TfdLuminance_UB1) - constructor Create; override; + TfdLuminance6Alpha2ub2 = class(TfdLuminanceAlphaUB2) + procedure SetValues; override; end; - TfdLuminance8 = class(TfdLuminance_UB1) - constructor Create; override; + TfdLuminance8Alpha8ub2 = class(TfdLuminanceAlphaUB2) + procedure SetValues; override; end; - TfdLuminance12 = class(TfdLuminance_US1) - constructor Create; override; + TfdLuminance12Alpha4us2 = class(TfdLuminanceAlphaUS2) + procedure SetValues; override; end; - TfdLuminance16 = class(TfdLuminance_US1) - constructor Create; override; + TfdLuminance16Alpha16us2 = class(TfdLuminanceAlphaUS2) + procedure SetValues; override; end; - TfdLuminance4Alpha4 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdR3G3B2ub1 = class(TfdUniversalUB1) + procedure SetValues; override; + end; + + TfdRGBX4us1 = class(TfdUniversalUS1) + procedure SetValues; override; + end; + + TfdXRGB4us1 = class(TfdUniversalUS1) + procedure SetValues; override; + end; + + TfdR5G6B5us1 = class(TfdUniversalUS1) + procedure SetValues; override; + end; + + TfdRGB5X1us1 = class(TfdUniversalUS1) + procedure SetValues; override; + end; + + TfdX1RGB5us1 = class(TfdUniversalUS1) + procedure SetValues; override; + end; + + TfdRGB8ub3 = class(TfdRGBub3) + procedure SetValues; override; + end; + + TfdRGBX8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance6Alpha2 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; + TfdXRGB8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance8Alpha8 = class(TfdLuminanceAlpha_UB2) - constructor Create; override; + TfdRGB10X2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance12Alpha4 = class(TfdLuminanceAlpha_US2) - constructor Create; override; + TfdX2RGB10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdLuminance12Alpha12 = class(TfdLuminanceAlpha_US2) - constructor Create; override; + TfdRGB16us3 = class(TfdRGBus3) + procedure SetValues; override; end; - TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2) - constructor Create; override; + TfdRGBA4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdR3G3B2 = class(TfdUniversal_UB1) - constructor Create; override; + TfdARGB4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGB4 = class(TfdUniversal_US1) - constructor Create; override; + TfdRGB5A1us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdR5G6B5 = class(TfdUniversal_US1) - constructor Create; override; + TfdA1RGB5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGB5 = class(TfdUniversal_US1) - constructor Create; override; + TfdRGBA8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGB8 = class(TfdRGB_UB3) - constructor Create; override; + TfdARGB8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGB10 = class(TfdUniversal_UI1) - constructor Create; override; + TfdRGBA8ub4 = class(TfdRGBAub4) + procedure SetValues; override; end; - TfdRGB12 = class(TfdRGB_US3) - constructor Create; override; + TfdRGB10A2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGB16 = class(TfdRGB_US3) - constructor Create; override; + TfdA2RGB10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdRGBA2 = class(TfdRGBA_UB4) - constructor Create; override; + TfdRGBA16us4 = class(TfdRGBAus4) + procedure SetValues; override; end; - TfdRGBA4 = class(TfdUniversal_US1) - constructor Create; override; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + TfdBGRX4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGB5A1 = class(TfdUniversal_US1) - constructor Create; override; + TfdXBGR4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGBA8 = class(TfdRGBA_UB4) - constructor Create; override; + TfdB5G6R5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGB10A2 = class(TfdUniversal_UI1) - constructor Create; override; + TfdBGR5X1us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGBA12 = class(TfdRGBA_US4) - constructor Create; override; + TfdX1BGR5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdRGBA16 = class(TfdRGBA_US4) - constructor Create; override; + TfdBGR8ub3 = class(TfdBGRub3) + procedure SetValues; override; end; - TfdBGR4 = class(TfdUniversal_US1) - constructor Create; override; + TfdBGRX8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdB5G6R5 = class(TfdUniversal_US1) - constructor Create; override; + TfdXBGR8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR5 = class(TfdUniversal_US1) - constructor Create; override; + TfdBGR10X2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR8 = class(TfdBGR_UB3) - constructor Create; override; + TfdX2BGR10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR10 = class(TfdUniversal_UI1) - constructor Create; override; + TfdBGR16us3 = class(TfdBGRus3) + procedure SetValues; override; end; - TfdBGR12 = class(TfdBGR_US3) - constructor Create; override; + TfdBGRA4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGR16 = class(TfdBGR_US3) - constructor Create; override; + TfdABGR4us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGRA2 = class(TfdBGRA_UB4) - constructor Create; override; + TfdBGR5A1us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGRA4 = class(TfdUniversal_US1) - constructor Create; override; + TfdA1BGR5us1 = class(TfdUniversalUS1) + procedure SetValues; override; end; - TfdBGR5A1 = class(TfdUniversal_US1) - constructor Create; override; + TfdBGRA8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGRA8 = class(TfdBGRA_UB4) - constructor Create; override; + TfdABGR8ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGR10A2 = class(TfdUniversal_UI1) - constructor Create; override; + TfdBGRA8ub4 = class(TfdBGRAub4) + procedure SetValues; override; end; - TfdBGRA12 = class(TfdBGRA_US4) - constructor Create; override; + TfdBGR10A2ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdBGRA16 = class(TfdBGRA_US4) - constructor Create; override; + TfdA2BGR10ui1 = class(TfdUniversalUI1) + procedure SetValues; override; end; - TfdDepth16 = class(TfdDepth_US1) - constructor Create; override; + TfdBGRA16us4 = class(TfdBGRAus4) + procedure SetValues; override; end; - TfdDepth24 = class(TfdDepth_UI1) - constructor Create; override; + TfdDepth16us1 = class(TfdDepthUS1) + procedure SetValues; override; end; - TfdDepth32 = class(TfdDepth_UI1) - constructor Create; override; + TfdDepth24ui1 = class(TfdDepthUI1) + procedure SetValues; override; + end; + + TfdDepth32ui1 = class(TfdDepthUI1) + procedure SetValues; override; end; TfdS3tcDtx1RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure SetValues; override; end; TfdS3tcDtx3RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure SetValues; override; end; TfdS3tcDtx5RGBA = class(TFormatDescriptor) procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; - constructor Create; override; + procedure SetValues; override; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// TbmpBitfieldFormat = class(TFormatDescriptor) - private - procedure SetRedMask (const aValue: QWord); - procedure SetGreenMask(const aValue: QWord); - procedure SetBlueMask (const aValue: QWord); - procedure SetAlphaMask(const aValue: QWord); - - procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte); public - 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; - + procedure SetValues(const aBPP: Integer; aMask: TglBitmapRec4ul); overload; + procedure SetValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload; procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override; end; @@ -1678,14 +1729,16 @@ type TbmpColorTable = array of TbmpColorTableEnty; TbmpColorTableFormat = class(TFormatDescriptor) private + fBitsPerPixel: Integer; fColorTable: TbmpColorTable; + protected + procedure SetValues; override; overload; public - property PixelSize: Single read fPixelSize write fPixelSize; - property ColorTable: TbmpColorTable read fColorTable write fColorTable; - property Range: TglBitmapColorRec read fRange write fRange; - property Shift: TShiftRec read fShift write fShift; - property Format: TglBitmapFormat read fFormat write fFormat; + property ColorTable: TbmpColorTable read fColorTable write fColorTable; + property BitsPerPixel: Integer read fBitsPerPixel write fBitsPerPixel; + procedure SetValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); overload; + procedure CalcValues; procedure CreateColorTable; procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override; @@ -1706,64 +1759,73 @@ const DEPTH_WEIGHT_G = 0.333333333; DEPTH_WEIGHT_B = 0.333333333; - UNSUPPORTED_FORMAT = 'the given format isn''t supported by this function.'; - FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = ( TfdEmpty, - TfdAlpha4, - TfdAlpha8, - TfdAlpha12, - TfdAlpha16, - - TfdLuminance4, - TfdLuminance8, - TfdLuminance12, - TfdLuminance16, - - TfdLuminance4Alpha4, - TfdLuminance6Alpha2, - TfdLuminance8Alpha8, - TfdLuminance12Alpha4, - TfdLuminance12Alpha12, - TfdLuminance16Alpha16, - - TfdR3G3B2, - TfdRGB4, - TfdR5G6B5, - TfdRGB5, - TfdRGB8, - TfdRGB10, - TfdRGB12, - TfdRGB16, - - TfdRGBA2, - TfdRGBA4, - TfdRGB5A1, - TfdRGBA8, - TfdRGB10A2, - TfdRGBA12, - TfdRGBA16, - - TfdBGR4, - TfdB5G6R5, - TfdBGR5, - TfdBGR8, - TfdBGR10, - TfdBGR12, - TfdBGR16, - - TfdBGRA2, - TfdBGRA4, - TfdBGR5A1, - TfdBGRA8, - TfdBGR10A2, - TfdBGRA12, - TfdBGRA16, - - TfdDepth16, - TfdDepth24, - TfdDepth32, + TfdAlpha4ub1, + TfdAlpha8ub1, + TfdAlpha16us1, + + TfdLuminance4ub1, + TfdLuminance8ub1, + TfdLuminance16us1, + + TfdLuminance4Alpha4ub2, + TfdLuminance6Alpha2ub2, + TfdLuminance8Alpha8ub2, + TfdLuminance12Alpha4us2, + TfdLuminance16Alpha16us2, + + TfdR3G3B2ub1, + TfdRGBX4us1, + TfdXRGB4us1, + TfdR5G6B5us1, + TfdRGB5X1us1, + TfdX1RGB5us1, + TfdRGB8ub3, + TfdRGBX8ui1, + TfdXRGB8ui1, + TfdRGB10X2ui1, + TfdX2RGB10ui1, + TfdRGB16us3, + + TfdRGBA4us1, + TfdARGB4us1, + TfdRGB5A1us1, + TfdA1RGB5us1, + TfdRGBA8ui1, + TfdARGB8ui1, + TfdRGBA8ub4, + TfdRGB10A2ui1, + TfdA2RGB10ui1, + TfdRGBA16us4, + + TfdBGRX4us1, + TfdXBGR4us1, + TfdB5G6R5us1, + TfdBGR5X1us1, + TfdX1BGR5us1, + TfdBGR8ub3, + TfdBGRX8ui1, + TfdXBGR8ui1, + TfdBGR10X2ui1, + TfdX2BGR10ui1, + TfdBGR16us3, + + TfdBGRA4us1, + TfdABGR4us1, + TfdBGR5A1us1, + TfdA1BGR5us1, + TfdBGRA8ui1, + TfdABGR8ui1, + TfdBGRA8ub4, + TfdBGR10A2ui1, + TfdA2BGR10ui1, + TfdBGRA16us4, + + TfdDepth16us1, + TfdDepth24ui1, + TfdDepth32ui1, TfdS3tcDtx1RGBA, TfdS3tcDtx3RGBA, @@ -1787,7 +1849,7 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition; +function glBitmapPosition(X: Integer; Y: Integer): TglBitmapPixelPosition; begin result.Fields := []; @@ -1801,7 +1863,16 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec; +function glBitmapRec4ub(const r, g, b, a: Byte): TglBitmapRec4ub; +begin + result.r := r; + result.g := g; + result.b := b; + result.a := a; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapRec4ui(const r, g, b, a: Cardinal): TglBitmapRec4ui; begin result.r := r; result.g := g; @@ -1810,7 +1881,16 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean; +function glBitmapRec4ul(const r, g, b, a: QWord): TglBitmapRec4ul; +begin + result.r := r; + result.g := g; + result.b := b; + result.a := a; +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapRec4uiCompare(const r1, r2: TglBitmapRec4ui): Boolean; var i: Integer; begin @@ -1822,7 +1902,54 @@ begin end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function glBitmapShiftRec(const r, g, b, a: Byte): TShiftRec; +function glBitmapCreateTestTexture(const aFormat: TglBitmapFormat): TglBitmap2D; +var + desc: TFormatDescriptor; + p, tmp: PByte; + x, y, i: Integer; + md: Pointer; + px: TglBitmapPixelData; +begin + result := nil; + desc := TFormatDescriptor.Get(aFormat); + if (desc.IsCompressed) or (desc.glFormat = 0) then + exit; + + p := GetMem(ceil(25 * desc.BytesPerPixel)); // 5 x 5 pixel + md := desc.CreateMappingData; + try + tmp := p; + desc.PreparePixel(px); + for y := 0 to 4 do + for x := 0 to 4 do begin + px.Data := glBitmapRec4ui(0, 0, 0, 0); + for i := 0 to 3 do begin + if ((y < 3) and (y = i)) or + ((y = 3) and (i < 3)) or + ((y = 4) and (i = 3)) + then + px.Data.arr[i] := Trunc(px.Range.arr[i] / 4 * x) + else if ((y < 4) and (i = 3)) or + ((y = 4) and (i < 3)) + then + px.Data.arr[i] := px.Range.arr[i] + else + px.Data.arr[i] := 0; //px.Range.arr[i]; + end; + desc.Map(px, tmp, md); + end; + finally + desc.FreeMappingData(md); + end; + + result := TglBitmap2D.Create(glBitmapPosition(5, 5), aFormat, p); + result.FreeDataOnDestroy := true; + result.FreeDataAfterGenTexture := false; + result.SetFilter(GL_NEAREST, GL_NEAREST); +end; + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function glBitmapShiftRec(const r, g, b, a: Byte): TglBitmapRec4ub; begin result.r := r; result.g := g; @@ -1836,74 +1963,57 @@ begin result := []; if (aFormat in [ - //4 bbp - tfLuminance4, - //8bpp - tfR3G3B2, tfLuminance8, + tfAlpha4ub1, tfAlpha8ub1, + tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1, //16bpp - tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4, - tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4, + tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, + tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1, + tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1, //24bpp - tfBGR8, tfRGB8, + tfBGR8ub3, tfRGB8ub3, //32bpp - tfRGB10, tfRGB10A2, tfRGBA8, - tfBGR10, tfBGR10A2, tfBGRA8]) then - result := result + [ftBMP]; + tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1, + tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1]) + then + result := result + [ ftBMP ]; if (aFormat in [ - //8 bpp - tfLuminance8, tfAlpha8, + //8bbp + tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, - //16 bpp - tfLuminance16, tfLuminance8Alpha8, - tfRGB5, tfRGB5A1, tfRGBA4, - tfBGR5, tfBGR5A1, tfBGRA4, + //16bbp + tfAlpha16us1, tfLuminance16us1, + tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, + tfX1RGB5us1, tfARGB4us1, tfA1RGB5us1, tfDepth16us1, - //24 bpp - tfRGB8, tfBGR8, + //24bbp + tfBGR8ub3, - //32 bpp - tfRGB10A2, tfRGBA8, tfBGR10A2, tfBGRA8]) then + //32bbp + tfX2RGB10ui1, tfARGB8ui1, tfBGRA8ub4, tfA2RGB10ui1, + tfDepth24ui1, tfDepth32ui1]) + then result := result + [ftTGA]; - if (aFormat in [ - //8 bpp - tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2, - tfR3G3B2, tfRGBA2, tfBGRA2, - - //16 bpp - tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4, - tfRGB4, tfR5G6B5, tfRGB5, tfRGBA4, tfRGB5A1, - tfBGR4, tfB5G6R5, tfBGR5, tfBGRA4, tfBGR5A1, - - //24 bpp - tfRGB8, tfBGR8, - - //32 bbp - tfLuminance16Alpha16, - tfRGBA8, tfRGB10A2, - tfBGRA8, tfBGR10A2, - - //compressed - tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then + if not (aFormat in [tfEmpty, tfRGB16us3, tfBGR16us3]) then result := result + [ftDDS]; - {$IFDEF GLB_SUPPORT_PNG_WRITE} +{$IFDEF GLB_SUPPORT_PNG_WRITE} if aFormat in [ - tfAlpha8, tfLuminance8, tfLuminance8Alpha8, - tfRGB8, tfRGBA8, - tfBGR8, tfBGRA8] then + tfAlpha8ub1, tfLuminance8ub1, tfLuminance8Alpha8ub2, + tfRGB8ub3, tfRGBA8ui1, + tfBGR8ub3, tfBGRA8ui1] then result := result + [ftPNG]; - {$ENDIF} +{$ENDIF} - {$IFDEF GLB_SUPPORT_JPEG_WRITE} - if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] then +{$IFDEF GLB_SUPPORT_JPEG_WRITE} + if aFormat in [tfAlpha8ub1, tfLuminance8ub1, tfRGB8ub3, tfBGR8ub3] then result := result + [ftJPEG]; - {$ENDIF} +{$ENDIF} end; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2210,7 +2320,7 @@ begin result := SDL_AllocRW; if result = nil then - raise EglBitmapException.Create('glBitmapCreateRWops - SDL_AllocRW failed.'); + raise EglBitmap.Create('glBitmapCreateRWops - SDL_AllocRW failed.'); result^.seek := glBitmapRWseek; result^.read := glBitmapRWread; @@ -2293,14 +2403,14 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapGetDefaultFilter(var aMin, aMag: GLenum); +procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal); begin aMin := glBitmapDefaultFilterMin; aMag := glBitmapDefaultFilterMag; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum); +procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal); begin S := glBitmapDefaultWrapS; T := glBitmapDefaultWrapT; @@ -2319,89 +2429,6 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetRedMask: QWord; -begin - result := fRange.r shl fShift.r; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetGreenMask: QWord; -begin - result := fRange.g shl fShift.g; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetBlueMask: QWord; -begin - result := fRange.b shl fShift.b; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetAlphaMask: QWord; -begin - result := fRange.a shl fShift.a; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetIsCompressed: Boolean; -begin - result := fIsCompressed; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasRed: Boolean; -begin - result := (fRange.r > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasGreen: Boolean; -begin - result := (fRange.g > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasBlue: Boolean; -begin - result := (fRange.b > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetHasAlpha: Boolean; -begin - result := (fRange.a > 0); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetglFormat: GLenum; -begin - result := fglFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetglInternalFormat: GLenum; -begin - result := fglInternalFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetglDataFormat: GLenum; -begin - result := fglDataFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.GetComponents: Integer; -var - i: Integer; -begin - result := 0; - for i := 0 to 3 do - if (fRange.arr[i] > 0) then - inc(result); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer; var w, h: Integer; @@ -2420,7 +2447,7 @@ begin result := 0; if (aWidth <= 0) or (aHeight <= 0) then exit; - result := Ceil(aWidth * aHeight * fPixelSize); + result := Ceil(aWidth * aHeight * BytesPerPixel); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2442,19 +2469,18 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; +function TFormatDescriptor.MaskMatch(const aMask: TglBitmapRec4ul): Boolean; +var + i: Integer; + m: TglBitmapRec4ul; begin result := false; - if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then + if (aMask.r = 0) and (aMask.g = 0) and (aMask.b = 0) and (aMask.a = 0) then raise EglBitmap.Create('FormatCheckFormat - All Masks are 0'); - if (aRedMask <> RedMask) then - exit; - if (aGreenMask <> GreenMask) then - exit; - if (aBlueMask <> BlueMask) then - exit; - if (aAlphaMask <> AlphaMask) then - exit; + m := Mask; + for i := 0 to 3 do + if (aMask.arr[i] <> m.arr[i]) then + exit; result := true; end; @@ -2462,42 +2488,21 @@ end; procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData); begin FillChar(aPixel{%H-}, SizeOf(aPixel), 0); - aPixel.Data := fRange; - aPixel.Range := fRange; + aPixel.Data := Range; aPixel.Format := fFormat; -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TFormatDescriptor.Create; -begin - inherited Create; - - fFormat := tfEmpty; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfEmpty; - fRGBInverted := tfEmpty; - fUncompressed := tfEmpty; - fPixelSize := 0.0; - fIsCompressed := false; - - fglFormat := 0; - fglInternalFormat := 0; - fglDataFormat := 0; - - FillChar(fRange, 0, SizeOf(fRange)); - FillChar(fShift, 0, SizeOf(fShift)); + aPixel.Range := Range; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdAlpha_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdAlpha_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdAlphaUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdAlpha_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdAlphaUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := 0; aPixel.Data.g := 0; @@ -2506,25 +2511,16 @@ begin inc(aData); end; -constructor TfdAlpha_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; - fRange.a := $FF; - fglFormat := GL_ALPHA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminance_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminance_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := LuminanceWeight(aPixel); inc(aData); end; -procedure TfdLuminance_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := aData^; aPixel.Data.g := aData^; @@ -2533,77 +2529,50 @@ begin inc(aData); end; -constructor TfdLuminance_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fglFormat := GL_LUMINANCE; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdUniversal_UB1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdUniversal_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdUniversalUB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var i: Integer; begin aData^ := 0; for i := 0 to 3 do - if (fRange.arr[i] > 0) then - aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + if (Range.arr[i] > 0) then + aData^ := aData^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]); inc(aData); end; -procedure TfdUniversal_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversalUB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin for i := 0 to 3 do - aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and fRange.arr[i]; + aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and Range.arr[i]; inc(aData); end; -constructor TfdUniversal_UB1.Create; -begin - inherited Create; - fPixelSize := 1.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminanceAlpha_UB2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminanceAlpha_UB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceAlphaUB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdLuminanceAlpha_UB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceAlphaUB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := aData^; inc(aData); end; -constructor TfdLuminanceAlpha_UB2.Create; -begin - inherited Create; - fPixelSize := 2.0; - fRange.a := $FF; - fShift.a := 8; - fglFormat := GL_LUMINANCE_ALPHA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdRGB_UB3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGB_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdRGBub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := aPixel.Data.r; inc(aData); @@ -2613,7 +2582,7 @@ begin inc(aData); end; -procedure TfdRGB_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := aData^; inc(aData); @@ -2624,24 +2593,10 @@ begin aPixel.Data.a := 0; end; -constructor TfdRGB_UB3.Create; -begin - inherited Create; - fPixelSize := 3.0; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 0; - fShift.g := 8; - fShift.b := 16; - fglFormat := GL_RGB; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdBGR_UB3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGR_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdBGRub3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin aData^ := aPixel.Data.b; inc(aData); @@ -2651,7 +2606,7 @@ begin inc(aData); end; -procedure TfdBGR_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRub3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.b := aData^; inc(aData); @@ -2662,83 +2617,50 @@ begin aPixel.Data.a := 0; end; -constructor TfdBGR_UB3.Create; -begin - fPixelSize := 3.0; - fRange.r := $FF; - fRange.g := $FF; - fRange.b := $FF; - fShift.r := 16; - fShift.g := 8; - fShift.b := 0; - fglFormat := GL_BGR; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TdfRGBA_UB4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdRGBA_UB4////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGBA_UB4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdRGBAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdRGBA_UB4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := aData^; inc(aData); end; -constructor TfdRGBA_UB4.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FF; - fShift.a := 24; - fglFormat := GL_RGBA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//TfdBGRA_UB4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdBGRA_UB4////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGRA_UB4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdBGRAub4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); aData^ := aPixel.Data.a; inc(aData); end; -procedure TfdBGRA_UB4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRAub4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := aData^; inc(aData); end; -constructor TfdBGRA_UB4.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FF; - fShift.a := 24; - fglFormat := GL_BGRA; - fglDataFormat := GL_UNSIGNED_BYTE; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdAlpha_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdAlpha_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdAlphaUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := aPixel.Data.a; inc(aData, 2); end; -procedure TfdAlpha_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdAlphaUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := 0; aPixel.Data.g := 0; @@ -2747,25 +2669,16 @@ begin inc(aData, 2); end; -constructor TfdAlpha_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fRange.a := $FFFF; - fglFormat := GL_ALPHA; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminance_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminance_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := LuminanceWeight(aPixel); inc(aData, 2); end; -procedure TfdLuminance_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PWord(aData)^; aPixel.Data.g := PWord(aData)^; @@ -2774,106 +2687,68 @@ begin inc(aData, 2); end; -constructor TfdLuminance_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fglFormat := GL_LUMINANCE; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdUniversal_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdUniversal_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdUniversalUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var i: Integer; begin PWord(aData)^ := 0; for i := 0 to 3 do - if (fRange.arr[i] > 0) then - PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + if (Range.arr[i] > 0) then + PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]); inc(aData, 2); end; -procedure TfdUniversal_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversalUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin for i := 0 to 3 do - aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and fRange.arr[i]; + aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and Range.arr[i]; inc(aData, 2); end; -constructor TfdUniversal_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_US1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdDepth_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdDepthUS1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := DepthWeight(aPixel); inc(aData, 2); end; -procedure TfdDepth_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdDepthUS1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PWord(aData)^; aPixel.Data.g := PWord(aData)^; aPixel.Data.b := PWord(aData)^; - aPixel.Data.a := 0; + aPixel.Data.a := PWord(aData)^;; inc(aData, 2); end; -constructor TfdDepth_US1.Create; -begin - inherited Create; - fPixelSize := 2.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fglFormat := GL_DEPTH_COMPONENT; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdLuminanceAlpha_US2/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdLuminanceAlpha_US2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdLuminanceAlphaUS2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); PWord(aData)^ := aPixel.Data.a; inc(aData, 2); end; -procedure TfdLuminanceAlpha_US2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdLuminanceAlphaUS2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := PWord(aData)^; inc(aData, 2); end; -constructor TfdLuminanceAlpha_US2.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.a := $FFFF; - fShift.a := 16; - fglFormat := GL_LUMINANCE_ALPHA; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdRGB_US3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGB_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdRGBus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := aPixel.Data.r; inc(aData, 2); @@ -2883,7 +2758,7 @@ begin inc(aData, 2); end; -procedure TfdRGB_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PWord(aData)^; inc(aData, 2); @@ -2894,24 +2769,10 @@ begin aPixel.Data.a := 0; end; -constructor TfdRGB_US3.Create; -begin - inherited Create; - fPixelSize := 6.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fShift.r := 0; - fShift.g := 16; - fShift.b := 32; - fglFormat := GL_RGB; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdBGR_US3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGR_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdBGRus3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PWord(aData)^ := aPixel.Data.b; inc(aData, 2); @@ -2921,7 +2782,7 @@ begin inc(aData, 2); end; -procedure TfdBGR_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRus3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.b := PWord(aData)^; inc(aData, 2); @@ -2932,714 +2793,1011 @@ begin aPixel.Data.a := 0; end; -constructor TfdBGR_US3.Create; -begin - inherited Create; - fPixelSize := 6.0; - fRange.r := $FFFF; - fRange.g := $FFFF; - fRange.b := $FFFF; - fShift.r := 32; - fShift.g := 16; - fShift.b := 0; - fglFormat := GL_BGR; - fglDataFormat := GL_UNSIGNED_SHORT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdRGBA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdRGBAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); PWord(aData)^ := aPixel.Data.a; inc(aData, 2); end; -procedure TfdRGBA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdRGBAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := PWord(aData)^; inc(aData, 2); end; -constructor TfdRGBA_US4.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdARGB_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdARGBus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Create; - fPixelSize := 8.0; - fRange.a := $FFFF; - fShift.a := 48; - fglFormat := GL_RGBA; - fglDataFormat := GL_UNSIGNED_SHORT; + PWord(aData)^ := aPixel.Data.a; + inc(aData, 2); + inherited Map(aPixel, aData, aMapData); +end; + +procedure TfdARGBus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +begin + aPixel.Data.a := PWord(aData)^; + inc(aData, 2); + inherited Unmap(aData, aPixel, aMapData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdBGRA_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdBGRA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdBGRAus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin inherited Map(aPixel, aData, aMapData); PWord(aData)^ := aPixel.Data.a; inc(aData, 2); end; -procedure TfdBGRA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdBGRAus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin inherited Unmap(aData, aPixel, aMapData); aPixel.Data.a := PWord(aData)^; inc(aData, 2); end; -constructor TfdBGRA_US4.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TfdABGR_US4///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdABGRus4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin - inherited Create; - fPixelSize := 8.0; - fRange.a := $FFFF; - fShift.a := 48; - fglFormat := GL_BGRA; - fglDataFormat := GL_UNSIGNED_SHORT; + PWord(aData)^ := aPixel.Data.a; + inc(aData, 2); + inherited Map(aPixel, aData, aMapData); +end; + +procedure TfdABGRus4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +begin + aPixel.Data.a := PWord(aData)^; + inc(aData, 2); + inherited Unmap(aData, aPixel, aMapData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdUniversal_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdUniversal_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdUniversalUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var i: Integer; begin PCardinal(aData)^ := 0; for i := 0 to 3 do - if (fRange.arr[i] > 0) then - PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]); + if (Range.arr[i] > 0) then + PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and Range.arr[i]) shl fShift.arr[i]); inc(aData, 4); end; -procedure TfdUniversal_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdUniversalUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var i: Integer; begin for i := 0 to 3 do - aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and fRange.arr[i]; + aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and Range.arr[i]; inc(aData, 2); end; -constructor TfdUniversal_UI1.Create; -begin - inherited Create; - fPixelSize := 4.0; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TfdDepth_UI1//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TfdDepth_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); +procedure TfdDepthUI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); begin PCardinal(aData)^ := DepthWeight(aPixel); inc(aData, 4); end; -procedure TfdDepth_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); +procedure TfdDepthUI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); begin aPixel.Data.r := PCardinal(aData)^; aPixel.Data.g := PCardinal(aData)^; aPixel.Data.b := PCardinal(aData)^; - aPixel.Data.a := 0; + aPixel.Data.a := PCardinal(aData)^; inc(aData, 4); end; -constructor TfdDepth_UI1.Create; -begin - inherited Create; - fPixelSize := 4.0; - fRange.r := $FFFFFFFF; - fRange.g := $FFFFFFFF; - fRange.b := $FFFFFFFF; - fglFormat := GL_DEPTH_COMPONENT; - fglDataFormat := GL_UNSIGNED_INT; -end; - ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TfdAlpha4.Create; +procedure TfdAlpha4ub1.SetValues; begin - inherited Create; - fFormat := tfAlpha4; - fWithAlpha := tfAlpha4; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfAlpha4ub1; + fWithAlpha := tfAlpha4ub1; + fOpenGLFormat := tfAlpha4ub1; + fPrecision := glBitmapRec4ub(0, 0, 0, 8); + fShift := glBitmapRec4ub(0, 0, 0, 0); + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdAlpha8.Create; +procedure TfdAlpha8ub1.SetValues; begin - inherited Create; - fFormat := tfAlpha8; - fWithAlpha := tfAlpha8; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfAlpha8ub1; + fWithAlpha := tfAlpha8ub1; + fOpenGLFormat := tfAlpha8ub1; + fPrecision := glBitmapRec4ub(0, 0, 0, 8); + fShift := glBitmapRec4ub(0, 0, 0, 0); + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA8; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdAlpha12.Create; -begin - inherited Create; - fFormat := tfAlpha12; - fWithAlpha := tfAlpha12; - fglInternalFormat := GL_ALPHA12; -end; - -constructor TfdAlpha16.Create; +procedure TfdAlpha16us1.SetValues; begin - inherited Create; - fFormat := tfAlpha16; - fWithAlpha := tfAlpha16; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfAlpha16us1; + fWithAlpha := tfAlpha16us1; + fOpenGLFormat := tfAlpha16us1; + fPrecision := glBitmapRec4ub(0, 0, 0, 16); + fShift := glBitmapRec4ub(0, 0, 0, 0); + fglFormat := GL_ALPHA; fglInternalFormat := GL_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdLuminance4.Create; +procedure TfdLuminance4ub1.SetValues; begin - inherited Create; - fFormat := tfLuminance4; - fWithAlpha := tfLuminance4Alpha4; - fWithoutAlpha := tfLuminance4; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfLuminance4ub1; + fWithAlpha := tfLuminance4Alpha4ub2; + fWithoutAlpha := tfLuminance4ub1; + fOpenGLFormat := tfLuminance4ub1; + fPrecision := glBitmapRec4ub(8, 8, 8, 0); + fShift := glBitmapRec4ub(0, 0, 0, 0); + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE4; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdLuminance8.Create; +procedure TfdLuminance8ub1.SetValues; begin - inherited Create; - fFormat := tfLuminance8; - fWithAlpha := tfLuminance8Alpha8; - fWithoutAlpha := tfLuminance8; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfLuminance8ub1; + fWithAlpha := tfLuminance8Alpha8ub2; + fWithoutAlpha := tfLuminance8ub1; + fOpenGLFormat := tfLuminance8ub1; + fPrecision := glBitmapRec4ub(8, 8, 8, 0); + fShift := glBitmapRec4ub(0, 0, 0, 0); + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE8; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdLuminance12.Create; -begin - inherited Create; - fFormat := tfLuminance12; - fWithAlpha := tfLuminance12Alpha12; - fWithoutAlpha := tfLuminance12; - fglInternalFormat := GL_LUMINANCE12; -end; - -constructor TfdLuminance16.Create; +procedure TfdLuminance16us1.SetValues; begin - inherited Create; - fFormat := tfLuminance16; - fWithAlpha := tfLuminance16Alpha16; - fWithoutAlpha := tfLuminance16; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance16us1; + fWithAlpha := tfLuminance16Alpha16us2; + fWithoutAlpha := tfLuminance16us1; + fOpenGLFormat := tfLuminance16us1; + fPrecision := glBitmapRec4ub(16, 16, 16, 0); + fShift := glBitmapRec4ub( 0, 0, 0, 0); + fglFormat := GL_LUMINANCE; fglInternalFormat := GL_LUMINANCE16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdLuminance4Alpha4.Create; +procedure TfdLuminance4Alpha4ub2.SetValues; begin - inherited Create; - fFormat := tfLuminance4Alpha4; - fWithAlpha := tfLuminance4Alpha4; - fWithoutAlpha := tfLuminance4; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance4Alpha4ub2; + fWithAlpha := tfLuminance4Alpha4ub2; + fWithoutAlpha := tfLuminance4ub1; + fOpenGLFormat := tfLuminance4Alpha4ub2; + fPrecision := glBitmapRec4ub(8, 8, 8, 8); + fShift := glBitmapRec4ub(0, 0, 0, 8); + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE4_ALPHA4; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdLuminance6Alpha2.Create; +procedure TfdLuminance6Alpha2ub2.SetValues; begin - inherited Create; - fFormat := tfLuminance6Alpha2; - fWithAlpha := tfLuminance6Alpha2; - fWithoutAlpha := tfLuminance8; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance6Alpha2ub2; + fWithAlpha := tfLuminance6Alpha2ub2; + fWithoutAlpha := tfLuminance8ub1; + fOpenGLFormat := tfLuminance6Alpha2ub2; + fPrecision := glBitmapRec4ub(8, 8, 8, 8); + fShift := glBitmapRec4ub(0, 0, 0, 8); + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE6_ALPHA2; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdLuminance8Alpha8.Create; +procedure TfdLuminance8Alpha8ub2.SetValues; begin - inherited Create; - fFormat := tfLuminance8Alpha8; - fWithAlpha := tfLuminance8Alpha8; - fWithoutAlpha := tfLuminance8; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfLuminance8Alpha8ub2; + fWithAlpha := tfLuminance8Alpha8ub2; + fWithoutAlpha := tfLuminance8ub1; + fOpenGLFormat := tfLuminance8Alpha8ub2; + fPrecision := glBitmapRec4ub(8, 8, 8, 8); + fShift := glBitmapRec4ub(0, 0, 0, 8); + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE8_ALPHA8; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdLuminance12Alpha4.Create; +procedure TfdLuminance12Alpha4us2.SetValues; begin - inherited Create; - fFormat := tfLuminance12Alpha4; - fWithAlpha := tfLuminance12Alpha4; - fWithoutAlpha := tfLuminance12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfLuminance12Alpha4us2; + fWithAlpha := tfLuminance12Alpha4us2; + fWithoutAlpha := tfLuminance16us1; + fOpenGLFormat := tfLuminance12Alpha4us2; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 0, 0, 16); + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE12_ALPHA4; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdLuminance12Alpha12.Create; -begin - inherited Create; - fFormat := tfLuminance12Alpha12; - fWithAlpha := tfLuminance12Alpha12; - fWithoutAlpha := tfLuminance12; - fglInternalFormat := GL_LUMINANCE12_ALPHA12; -end; - -constructor TfdLuminance16Alpha16.Create; +procedure TfdLuminance16Alpha16us2.SetValues; begin - inherited Create; - fFormat := tfLuminance16Alpha16; - fWithAlpha := tfLuminance16Alpha16; - fWithoutAlpha := tfLuminance16; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfLuminance16Alpha16us2; + fWithAlpha := tfLuminance16Alpha16us2; + fWithoutAlpha := tfLuminance16us1; + fOpenGLFormat := tfLuminance16Alpha16us2; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 0, 0, 16); + fglFormat := GL_LUMINANCE_ALPHA; fglInternalFormat := GL_LUMINANCE16_ALPHA16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdR3G3B2.Create; +procedure TfdR3G3B2ub1.SetValues; begin - inherited Create; - fFormat := tfR3G3B2; - fWithAlpha := tfRGBA2; - fWithoutAlpha := tfR3G3B2; - fRange.r := $7; - fRange.g := $7; - fRange.b := $3; - fShift.r := 0; - fShift.g := 3; - fShift.b := 6; + inherited SetValues; + fBitsPerPixel := 8; + fFormat := tfR3G3B2ub1; + fWithAlpha := tfRGBA4us1; + fWithoutAlpha := tfR3G3B2ub1; + fOpenGLFormat := tfR3G3B2ub1; + fRGBInverted := tfEmpty; + fPrecision := glBitmapRec4ub(3, 3, 2, 0); + fShift := glBitmapRec4ub(5, 2, 0, 0); fglFormat := GL_RGB; fglInternalFormat := GL_R3_G3_B2; - fglDataFormat := GL_UNSIGNED_BYTE_2_3_3_REV; + fglDataFormat := GL_UNSIGNED_BYTE_3_3_2; end; -constructor TfdRGB4.Create; +procedure TfdRGBX4us1.SetValues; begin - inherited Create; - fFormat := tfRGB4; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGB4; - fRGBInverted := tfBGR4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fShift.r := 0; - fShift.g := 4; - fShift.b := 8; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGBX4us1; + fWithAlpha := tfRGBA4us1; + fWithoutAlpha := tfRGBX4us1; + fOpenGLFormat := tfRGBX4us1; + fRGBInverted := tfBGRX4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 0); + fShift := glBitmapRec4ub(12, 8, 4, 0); fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +procedure TfdXRGB4us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfXRGB4us1; + fWithAlpha := tfARGB4us1; + fWithoutAlpha := tfXRGB4us1; + fOpenGLFormat := tfXRGB4us1; + fRGBInverted := tfXBGR4us1; + fPrecision := glBitmapRec4ub(4, 4, 4, 0); + fShift := glBitmapRec4ub(8, 4, 0, 0); + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; -constructor TfdR5G6B5.Create; +procedure TfdR5G6B5us1.SetValues; begin - inherited Create; - fFormat := tfR5G6B5; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfR5G6B5; - fRGBInverted := tfB5G6R5; - fRange.r := $1F; - fRange.g := $3F; - fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 11; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfR5G6B5us1; + fWithAlpha := tfRGB5A1us1; + fWithoutAlpha := tfR5G6B5us1; + fOpenGLFormat := tfR5G6B5us1; + fRGBInverted := tfB5G6R5us1; + fPrecision := glBitmapRec4ub( 5, 6, 5, 0); + fShift := glBitmapRec4ub(11, 5, 0, 0); fglFormat := GL_RGB; fglInternalFormat := GL_RGB565; - fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5; end; -constructor TfdRGB5.Create; +procedure TfdRGB5X1us1.SetValues; begin - inherited Create; - fFormat := tfRGB5; - fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5; - fRGBInverted := tfBGR5; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fShift.r := 0; - fShift.g := 5; - fShift.b := 10; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGB5X1us1; + fWithAlpha := tfRGB5A1us1; + fWithoutAlpha := tfRGB5X1us1; + fOpenGLFormat := tfRGB5X1us1; + fRGBInverted := tfBGR5X1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub(11, 6, 1, 0); fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +procedure TfdX1RGB5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfX1RGB5us1; + fWithAlpha := tfA1RGB5us1; + fWithoutAlpha := tfX1RGB5us1; + fOpenGLFormat := tfX1RGB5us1; + fRGBInverted := tfX1BGR5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub(10, 5, 0, 0); + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB5; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; end; -constructor TfdRGB8.Create; +procedure TfdRGB8ub3.SetValues; begin - inherited Create; - fFormat := tfRGB8; - fWithAlpha := tfRGBA8; - fWithoutAlpha := tfRGB8; - fRGBInverted := tfBGR8; + inherited SetValues; + fBitsPerPixel := 24; + fFormat := tfRGB8ub3; + fWithAlpha := tfRGBA8ub4; + fWithoutAlpha := tfRGB8ub3; + fOpenGLFormat := tfRGB8ub3; + fRGBInverted := tfBGR8ub3; + fPrecision := glBitmapRec4ub(8, 8, 8, 0); + fShift := glBitmapRec4ub(0, 8, 16, 0); + fglFormat := GL_RGB; fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdRGB10.Create; +procedure TfdRGBX8ui1.SetValues; begin - inherited Create; - fFormat := tfRGB10; - fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10; - fRGBInverted := tfBGR10; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fShift.r := 0; - fShift.g := 10; - fShift.b := 20; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGBX8ui1; + fWithAlpha := tfRGBA8ui1; + fWithoutAlpha := tfRGBX8ui1; + fOpenGLFormat := tfRGB8ub3; + fRGBInverted := tfBGRX8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub(24, 16, 8, 0); + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; +end; + +procedure TfdXRGB8ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfXRGB8ui1; + fWithAlpha := tfXRGB8ui1; + fWithoutAlpha := tfXRGB8ui1; + fOpenGLFormat := tfRGB8ub3; + fRGBInverted := tfXBGR8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub(16, 8, 0, 0); + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; +end; + +procedure TfdRGB10X2ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGB10X2ui1; + fWithAlpha := tfRGB10A2ui1; + fWithoutAlpha := tfRGB10X2ui1; + fOpenGLFormat := tfRGB10X2ui1; + fRGBInverted := tfBGR10X2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub(22, 12, 2, 0); fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB10; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdRGB12.Create; +procedure TfdX2RGB10ui1.SetValues; begin - inherited Create; - fFormat := tfRGB12; - fWithAlpha := tfRGBA12; - fWithoutAlpha := tfRGB12; - fRGBInverted := tfBGR12; - fglInternalFormat := GL_RGB12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfX2RGB10ui1; + fWithAlpha := tfA2RGB10ui1; + fWithoutAlpha := tfX2RGB10ui1; + fOpenGLFormat := tfX2RGB10ui1; + fRGBInverted := tfX2BGR10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub(20, 10, 0, 0); + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB10; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; -constructor TfdRGB16.Create; +procedure TfdRGB16us3.SetValues; begin - inherited Create; - fFormat := tfRGB16; - fWithAlpha := tfRGBA16; - fWithoutAlpha := tfRGB16; - fRGBInverted := tfBGR16; + inherited SetValues; + fBitsPerPixel := 48; + fFormat := tfRGB16us3; + fWithAlpha := tfRGBA16us4; + fWithoutAlpha := tfRGB16us3; + fOpenGLFormat := tfRGB16us3; + fRGBInverted := tfBGR16us3; + fPrecision := glBitmapRec4ub(16, 16, 16, 0); + fShift := glBitmapRec4ub( 0, 16, 32, 0); + fglFormat := GL_RGB; fglInternalFormat := GL_RGB16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdRGBA2.Create; +procedure TfdRGBA4us1.SetValues; begin - inherited Create; - fFormat := tfRGBA2; - fWithAlpha := tfRGBA2; - fWithoutAlpha := tfR3G3B2; - fRGBInverted := tfBGRA2; - fglInternalFormat := GL_RGBA2; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGBA4us1; + fWithAlpha := tfRGBA4us1; + fWithoutAlpha := tfRGBX4us1; + fOpenGLFormat := tfRGBA4us1; + fRGBInverted := tfBGRA4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub(12, 8, 4, 0); + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; end; -constructor TfdRGBA4.Create; +procedure TfdARGB4us1.SetValues; begin - inherited Create; - fFormat := tfRGBA4; - fWithAlpha := tfRGBA4; - fWithoutAlpha := tfRGB4; - fRGBInverted := tfBGRA4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fRange.a := $F; - fShift.r := 0; - fShift.g := 4; - fShift.b := 8; - fShift.a := 12; - fglFormat := GL_RGBA; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfARGB4us1; + fWithAlpha := tfARGB4us1; + fWithoutAlpha := tfXRGB4us1; + fOpenGLFormat := tfARGB4us1; + fRGBInverted := tfABGR4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub( 8, 4, 0, 12); + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; -constructor TfdRGB5A1.Create; +procedure TfdRGB5A1us1.SetValues; begin - inherited Create; - fFormat := tfRGB5A1; - fWithAlpha := tfRGB5A1; - fWithoutAlpha := tfRGB5; - fRGBInverted := tfBGR5A1; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fRange.a := $01; - fShift.r := 0; - fShift.g := 5; - fShift.b := 10; - fShift.a := 15; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfRGB5A1us1; + fWithAlpha := tfRGB5A1us1; + fWithoutAlpha := tfRGB5X1us1; + fOpenGLFormat := tfRGB5A1us1; + fRGBInverted := tfBGR5A1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub(11, 6, 1, 0); fglFormat := GL_RGBA; fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +procedure TfdA1RGB5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfA1RGB5us1; + fWithAlpha := tfA1RGB5us1; + fWithoutAlpha := tfX1RGB5us1; + fOpenGLFormat := tfA1RGB5us1; + fRGBInverted := tfA1BGR5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub(10, 5, 0, 15); + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5_A1; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; end; -constructor TfdRGBA8.Create; +procedure TfdRGBA8ui1.SetValues; begin - inherited Create; - fFormat := tfRGBA8; - fWithAlpha := tfRGBA8; - fWithoutAlpha := tfRGB8; - fRGBInverted := tfBGRA8; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGBA8ui1; + fWithAlpha := tfRGBA8ui1; + fWithoutAlpha := tfRGBX8ui1; + fOpenGLFormat := tfRGBA8ui1; + fRGBInverted := tfBGRA8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub(24, 16, 8, 0); + fglFormat := GL_RGBA; fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; end; -constructor TfdRGB10A2.Create; +procedure TfdARGB8ui1.SetValues; begin - inherited Create; - fFormat := tfRGB10A2; - fWithAlpha := tfRGB10A2; - fWithoutAlpha := tfRGB10; - fRGBInverted := tfBGR10A2; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fRange.a := $003; - fShift.r := 0; - fShift.g := 10; - fShift.b := 20; - fShift.a := 30; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfARGB8ui1; + fWithAlpha := tfARGB8ui1; + fWithoutAlpha := tfXRGB8ui1; + fOpenGLFormat := tfARGB8ui1; + fRGBInverted := tfABGR8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub(16, 8, 0, 24); + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; +end; + +procedure TfdRGBA8ub4.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGBA8ub4; + fWithAlpha := tfRGBA8ub4; + fWithoutAlpha := tfRGB8ub3; + fOpenGLFormat := tfRGBA8ub4; + fRGBInverted := tfBGRA8ub4; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub( 0, 8, 16, 24); + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +procedure TfdRGB10A2ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfRGB10A2ui1; + fWithAlpha := tfRGB10A2ui1; + fWithoutAlpha := tfRGB10X2ui1; + fOpenGLFormat := tfRGB10A2ui1; + fRGBInverted := tfBGR10A2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub(22, 12, 2, 0); fglFormat := GL_RGBA; fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdRGBA12.Create; +procedure TfdA2RGB10ui1.SetValues; begin - inherited Create; - fFormat := tfRGBA12; - fWithAlpha := tfRGBA12; - fWithoutAlpha := tfRGB12; - fRGBInverted := tfBGRA12; - fglInternalFormat := GL_RGBA12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfA2RGB10ui1; + fWithAlpha := tfA2RGB10ui1; + fWithoutAlpha := tfX2RGB10ui1; + fOpenGLFormat := tfA2RGB10ui1; + fRGBInverted := tfA2BGR10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub(20, 10, 0, 30); + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; -constructor TfdRGBA16.Create; +procedure TfdRGBA16us4.SetValues; begin - inherited Create; - fFormat := tfRGBA16; - fWithAlpha := tfRGBA16; - fWithoutAlpha := tfRGB16; - fRGBInverted := tfBGRA16; + inherited SetValues; + fBitsPerPixel := 64; + fFormat := tfRGBA16us4; + fWithAlpha := tfRGBA16us4; + fWithoutAlpha := tfRGB16us3; + fOpenGLFormat := tfRGBA16us4; + fRGBInverted := tfBGRA16us4; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 16, 32, 48); + fglFormat := GL_RGBA; fglInternalFormat := GL_RGBA16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdBGR4.Create; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TfdBGRX4us1.SetValues; begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGR4; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGR4; - fRGBInverted := tfRGB4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fRange.a := $0; - fShift.r := 8; - fShift.g := 4; - fShift.b := 0; - fShift.a := 0; - fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGRX4us1; + fWithAlpha := tfBGRA4us1; + fWithoutAlpha := tfBGRX4us1; + fOpenGLFormat := tfBGRX4us1; + fRGBInverted := tfRGBX4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 0); + fShift := glBitmapRec4ub( 4, 8, 12, 0); + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; +end; + +procedure TfdXBGR4us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfXBGR4us1; + fWithAlpha := tfABGR4us1; + fWithoutAlpha := tfXBGR4us1; + fOpenGLFormat := tfXBGR4us1; + fRGBInverted := tfXRGB4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 0); + fShift := glBitmapRec4ub( 0, 4, 8, 0); + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -constructor TfdB5G6R5.Create; +procedure TfdB5G6R5us1.SetValues; begin - inherited Create; - fFormat := tfB5G6R5; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfB5G6R5; - fRGBInverted := tfR5G6B5; - fRange.r := $1F; - fRange.g := $3F; - fRange.b := $1F; - fShift.r := 11; - fShift.g := 5; - fShift.b := 0; - fglFormat := GL_RGB; //B5G6R5 is only possible as R5G6B5 -> use reverted dataformat + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfB5G6R5us1; + fWithAlpha := tfBGR5A1us1; + fWithoutAlpha := tfB5G6R5us1; + fOpenGLFormat := tfB5G6R5us1; + fRGBInverted := tfR5G6B5us1; + fPrecision := glBitmapRec4ub( 5, 6, 5, 0); + fShift := glBitmapRec4ub( 0, 5, 11, 0); + fglFormat := GL_RGB; + fglInternalFormat := GL_RGB565; + fglDataFormat := GL_UNSIGNED_SHORT_5_6_5_REV; +end; + +procedure TfdBGR5X1us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGR5X1us1; + fWithAlpha := tfBGR5A1us1; + fWithoutAlpha := tfBGR5X1us1; + fOpenGLFormat := tfBGR5X1us1; + fRGBInverted := tfRGB5X1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub( 1, 6, 11, 0); + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +procedure TfdX1BGR5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfX1BGR5us1; + fWithAlpha := tfA1BGR5us1; + fWithoutAlpha := tfX1BGR5us1; + fOpenGLFormat := tfX1BGR5us1; + fRGBInverted := tfX1RGB5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 0); + fShift := glBitmapRec4ub( 0, 5, 10, 0); + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB5; + fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; +end; + +procedure TfdBGR8ub3.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 24; + fFormat := tfBGR8ub3; + fWithAlpha := tfBGRA8ub4; + fWithoutAlpha := tfBGR8ub3; + fOpenGLFormat := tfBGR8ub3; + fRGBInverted := tfRGB8ub3; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub(16, 8, 0, 0); + fglFormat := GL_BGR; fglInternalFormat := GL_RGB8; - fglDataFormat := GL_UNSIGNED_SHORT_5_6_5; + fglDataFormat := GL_UNSIGNED_BYTE; end; -constructor TfdBGR5.Create; +procedure TfdBGRX8ui1.SetValues; begin - inherited Create; - fPixelSize := 2.0; - fFormat := tfBGR5; - fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5; - fRGBInverted := tfRGB5; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fRange.a := $00; - fShift.r := 10; - fShift.g := 5; - fShift.b := 0; - fShift.a := 0; - fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA - fglInternalFormat := GL_RGB5; - fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGRX8ui1; + fWithAlpha := tfBGRA8ui1; + fWithoutAlpha := tfBGRX8ui1; + fOpenGLFormat := tfBGRX8ui1; + fRGBInverted := tfRGBX8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub( 8, 16, 24, 0); + fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; end; -constructor TfdBGR8.Create; +procedure TfdXBGR8ui1.SetValues; begin - inherited Create; - fFormat := tfBGR8; - fWithAlpha := tfBGRA8; - fWithoutAlpha := tfBGR8; - fRGBInverted := tfRGB8; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfXBGR8ui1; + fWithAlpha := tfABGR8ui1; + fWithoutAlpha := tfXBGR8ui1; + fOpenGLFormat := tfXBGR8ui1; + fRGBInverted := tfXRGB8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 0); + fShift := glBitmapRec4ub( 0, 8, 16, 0); + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; end; -constructor TfdBGR10.Create; +procedure TfdBGR10X2ui1.SetValues; begin - inherited Create; - fFormat := tfBGR10; - fWithAlpha := tfBGR10A2; - fWithoutAlpha := tfBGR10; - fRGBInverted := tfRGB10; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fRange.a := $000; - fShift.r := 20; - fShift.g := 10; - fShift.b := 0; - fShift.a := 0; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGR10X2ui1; + fWithAlpha := tfBGR10A2ui1; + fWithoutAlpha := tfBGR10X2ui1; + fOpenGLFormat := tfBGR10X2ui1; + fRGBInverted := tfRGB10X2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub( 2, 12, 22, 0); fglFormat := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA fglInternalFormat := GL_RGB10; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdBGR12.Create; +procedure TfdX2BGR10ui1.SetValues; begin - inherited Create; - fFormat := tfBGR12; - fWithAlpha := tfBGRA12; - fWithoutAlpha := tfBGR12; - fRGBInverted := tfRGB12; - fglInternalFormat := GL_RGB12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfX2BGR10ui1; + fWithAlpha := tfA2BGR10ui1; + fWithoutAlpha := tfX2BGR10ui1; + fOpenGLFormat := tfX2BGR10ui1; + fRGBInverted := tfX2RGB10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 0); + fShift := glBitmapRec4ub( 0, 10, 20, 0); + fglFormat := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA + fglInternalFormat := GL_RGB10; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; -constructor TfdBGR16.Create; +procedure TfdBGR16us3.SetValues; begin - inherited Create; - fFormat := tfBGR16; - fWithAlpha := tfBGRA16; - fWithoutAlpha := tfBGR16; - fRGBInverted := tfRGB16; + inherited SetValues; + fBitsPerPixel := 48; + fFormat := tfBGR16us3; + fWithAlpha := tfBGRA16us4; + fWithoutAlpha := tfBGR16us3; + fOpenGLFormat := tfBGR16us3; + fRGBInverted := tfRGB16us3; + fPrecision := glBitmapRec4ub(16, 16, 16, 0); + fShift := glBitmapRec4ub(32, 16, 0, 0); + fglFormat := GL_BGR; fglInternalFormat := GL_RGB16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdBGRA2.Create; +procedure TfdBGRA4us1.SetValues; begin - inherited Create; - fFormat := tfBGRA2; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGR4; - fRGBInverted := tfRGBA2; - fglInternalFormat := GL_RGBA2; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGRA4us1; + fWithAlpha := tfBGRA4us1; + fWithoutAlpha := tfBGRX4us1; + fOpenGLFormat := tfBGRA4us1; + fRGBInverted := tfRGBA4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub( 4, 8, 12, 0); + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA4; + fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4; end; -constructor TfdBGRA4.Create; +procedure TfdABGR4us1.SetValues; begin - inherited Create; - fFormat := tfBGRA4; - fWithAlpha := tfBGRA4; - fWithoutAlpha := tfBGR4; - fRGBInverted := tfRGBA4; - fRange.r := $F; - fRange.g := $F; - fRange.b := $F; - fRange.a := $F; - fShift.r := 8; - fShift.g := 4; - fShift.b := 0; - fShift.a := 12; - fglFormat := GL_BGRA; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfABGR4us1; + fWithAlpha := tfABGR4us1; + fWithoutAlpha := tfXBGR4us1; + fOpenGLFormat := tfABGR4us1; + fRGBInverted := tfARGB4us1; + fPrecision := glBitmapRec4ub( 4, 4, 4, 4); + fShift := glBitmapRec4ub( 0, 4, 8, 12); + fglFormat := GL_RGBA; fglInternalFormat := GL_RGBA4; fglDataFormat := GL_UNSIGNED_SHORT_4_4_4_4_REV; end; -constructor TfdBGR5A1.Create; +procedure TfdBGR5A1us1.SetValues; begin - inherited Create; - fFormat := tfBGR5A1; - fWithAlpha := tfBGR5A1; - fWithoutAlpha := tfBGR5; - fRGBInverted := tfRGB5A1; - fRange.r := $1F; - fRange.g := $1F; - fRange.b := $1F; - fRange.a := $01; - fShift.r := 10; - fShift.g := 5; - fShift.b := 0; - fShift.a := 15; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfBGR5A1us1; + fWithAlpha := tfBGR5A1us1; + fWithoutAlpha := tfBGR5X1us1; + fOpenGLFormat := tfBGR5A1us1; + fRGBInverted := tfRGB5A1us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub( 1, 6, 11, 0); fglFormat := GL_BGRA; fglInternalFormat := GL_RGB5_A1; + fglDataFormat := GL_UNSIGNED_SHORT_5_5_5_1; +end; + +procedure TfdA1BGR5us1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfA1BGR5us1; + fWithAlpha := tfA1BGR5us1; + fWithoutAlpha := tfX1BGR5us1; + fOpenGLFormat := tfA1BGR5us1; + fRGBInverted := tfA1RGB5us1; + fPrecision := glBitmapRec4ub( 5, 5, 5, 1); + fShift := glBitmapRec4ub( 0, 5, 10, 15); + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB5_A1; fglDataFormat := GL_UNSIGNED_SHORT_1_5_5_5_REV; end; -constructor TfdBGRA8.Create; +procedure TfdBGRA8ui1.SetValues; begin - inherited Create; - fFormat := tfBGRA8; - fWithAlpha := tfBGRA8; - fWithoutAlpha := tfBGR8; - fRGBInverted := tfRGBA8; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGRA8ui1; + fWithAlpha := tfBGRA8ui1; + fWithoutAlpha := tfBGRX8ui1; + fOpenGLFormat := tfBGRA8ui1; + fRGBInverted := tfRGBA8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub( 8, 16, 24, 0); + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8; end; -constructor TfdBGR10A2.Create; +procedure TfdABGR8ui1.SetValues; begin - inherited Create; - fFormat := tfBGR10A2; - fWithAlpha := tfBGR10A2; - fWithoutAlpha := tfBGR10; - fRGBInverted := tfRGB10A2; - fRange.r := $3FF; - fRange.g := $3FF; - fRange.b := $3FF; - fRange.a := $003; - fShift.r := 20; - fShift.g := 10; - fShift.b := 0; - fShift.a := 30; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfABGR8ui1; + fWithAlpha := tfABGR8ui1; + fWithoutAlpha := tfXBGR8ui1; + fOpenGLFormat := tfABGR8ui1; + fRGBInverted := tfARGB8ui1; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub( 0, 8, 16, 24); + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_INT_8_8_8_8_REV; +end; + +procedure TfdBGRA8ub4.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGRA8ub4; + fWithAlpha := tfBGRA8ub4; + fWithoutAlpha := tfBGR8ub3; + fOpenGLFormat := tfBGRA8ub4; + fRGBInverted := tfRGBA8ub4; + fPrecision := glBitmapRec4ub( 8, 8, 8, 8); + fShift := glBitmapRec4ub(16, 8, 0, 24); + fglFormat := GL_BGRA; + fglInternalFormat := GL_RGBA8; + fglDataFormat := GL_UNSIGNED_BYTE; +end; + +procedure TfdBGR10A2ui1.SetValues; +begin + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfBGR10A2ui1; + fWithAlpha := tfBGR10A2ui1; + fWithoutAlpha := tfBGR10X2ui1; + fOpenGLFormat := tfBGR10A2ui1; + fRGBInverted := tfRGB10A2ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub( 2, 12, 22, 0); fglFormat := GL_BGRA; fglInternalFormat := GL_RGB10_A2; - fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; + fglDataFormat := GL_UNSIGNED_INT_10_10_10_2; end; -constructor TfdBGRA12.Create; +procedure TfdA2BGR10ui1.SetValues; begin - inherited Create; - fFormat := tfBGRA12; - fWithAlpha := tfBGRA12; - fWithoutAlpha := tfBGR12; - fRGBInverted := tfRGBA12; - fglInternalFormat := GL_RGBA12; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfA2BGR10ui1; + fWithAlpha := tfA2BGR10ui1; + fWithoutAlpha := tfX2BGR10ui1; + fOpenGLFormat := tfA2BGR10ui1; + fRGBInverted := tfA2RGB10ui1; + fPrecision := glBitmapRec4ub(10, 10, 10, 2); + fShift := glBitmapRec4ub( 0, 10, 20, 30); + fglFormat := GL_RGBA; + fglInternalFormat := GL_RGB10_A2; + fglDataFormat := GL_UNSIGNED_INT_2_10_10_10_REV; end; -constructor TfdBGRA16.Create; +procedure TfdBGRA16us4.SetValues; begin - inherited Create; - fFormat := tfBGRA16; - fWithAlpha := tfBGRA16; - fWithoutAlpha := tfBGR16; - fRGBInverted := tfRGBA16; + inherited SetValues; + fBitsPerPixel := 64; + fFormat := tfBGRA16us4; + fWithAlpha := tfBGRA16us4; + fWithoutAlpha := tfBGR16us3; + fOpenGLFormat := tfBGRA16us4; + fRGBInverted := tfRGBA16us4; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub(32, 16, 0, 48); + fglFormat := GL_BGRA; fglInternalFormat := GL_RGBA16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdDepth16.Create; +procedure TfdDepth16us1.SetValues; begin - inherited Create; - fFormat := tfDepth16; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfDepth16; + inherited SetValues; + fBitsPerPixel := 16; + fFormat := tfDepth16us1; + fWithoutAlpha := tfDepth16us1; + fOpenGLFormat := tfDepth16us1; + fPrecision := glBitmapRec4ub(16, 16, 16, 16); + fShift := glBitmapRec4ub( 0, 0, 0, 0); + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT16; + fglDataFormat := GL_UNSIGNED_SHORT; end; -constructor TfdDepth24.Create; +procedure TfdDepth24ui1.SetValues; begin - inherited Create; - fFormat := tfDepth24; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfDepth24; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfDepth24ui1; + fWithoutAlpha := tfDepth24ui1; + fOpenGLFormat := tfDepth24ui1; + fPrecision := glBitmapRec4ub(32, 32, 32, 32); + fShift := glBitmapRec4ub( 0, 0, 0, 0); + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT24; + fglDataFormat := GL_UNSIGNED_INT; end; -constructor TfdDepth32.Create; +procedure TfdDepth32ui1.SetValues; begin - inherited Create; - fFormat := tfDepth32; - fWithAlpha := tfEmpty; - fWithoutAlpha := tfDepth32; + inherited SetValues; + fBitsPerPixel := 32; + fFormat := tfDepth32ui1; + fWithoutAlpha := tfDepth32ui1; + fOpenGLFormat := tfDepth32ui1; + fPrecision := glBitmapRec4ub(32, 32, 32, 32); + fShift := glBitmapRec4ub( 0, 0, 0, 0); + fglFormat := GL_DEPTH_COMPONENT; fglInternalFormat := GL_DEPTH_COMPONENT32; + fglDataFormat := GL_UNSIGNED_INT; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -3655,13 +3813,14 @@ begin raise EglBitmap.Create('mapping for compressed formats is not supported'); end; -constructor TfdS3tcDtx1RGBA.Create; +procedure TfdS3tcDtx1RGBA.SetValues; begin - inherited Create; + inherited SetValues; fFormat := tfS3tcDtx1RGBA; fWithAlpha := tfS3tcDtx1RGBA; - fUncompressed := tfRGB5A1; - fPixelSize := 0.5; + fOpenGLFormat := tfS3tcDtx1RGBA; + fUncompressed := tfRGB5A1us1; + fBitsPerPixel := 4; fIsCompressed := true; fglFormat := GL_COMPRESSED_RGBA; fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; @@ -3681,13 +3840,14 @@ begin raise EglBitmap.Create('mapping for compressed formats is not supported'); end; -constructor TfdS3tcDtx3RGBA.Create; +procedure TfdS3tcDtx3RGBA.SetValues; begin - inherited Create; + inherited SetValues; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; - fUncompressed := tfRGBA8; - fPixelSize := 1.0; + fOpenGLFormat := tfS3tcDtx3RGBA; + fUncompressed := tfRGBA8ub4; + fBitsPerPixel := 8; fIsCompressed := true; fglFormat := GL_COMPRESSED_RGBA; fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; @@ -3707,13 +3867,14 @@ begin raise EglBitmap.Create('mapping for compressed formats is not supported'); end; -constructor TfdS3tcDtx5RGBA.Create; +procedure TfdS3tcDtx5RGBA.SetValues; begin inherited Create; fFormat := tfS3tcDtx3RGBA; fWithAlpha := tfS3tcDtx3RGBA; - fUncompressed := tfRGBA8; - fPixelSize := 1.0; + fOpenGLFormat := tfS3tcDtx3RGBA; + fUncompressed := tfRGBA8ub4; + fBitsPerPixel := 8; fIsCompressed := true; fglFormat := GL_COMPRESSED_RGBA; fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; @@ -3721,6 +3882,94 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//TglBitmapFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +function TglBitmapFormatDescriptor.GetHasRed: Boolean; +begin + result := (fPrecision.r > 0); +end; + +function TglBitmapFormatDescriptor.GetHasGreen: Boolean; +begin + result := (fPrecision.g > 0); +end; + +function TglBitmapFormatDescriptor.GetHasBlue: Boolean; +begin + result := (fPrecision.b > 0); +end; + +function TglBitmapFormatDescriptor.GetHasAlpha: Boolean; +begin + result := (fPrecision.a > 0); +end; + +function TglBitmapFormatDescriptor.GetHasColor: Boolean; +begin + result := HasRed or HasGreen or HasBlue; +end; + +function TglBitmapFormatDescriptor.GetIsGrayscale: Boolean; +begin + result := (Mask.r = Mask.g) and (Mask.g = Mask.b) and (Mask.r > 0); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TglBitmapFormatDescriptor.SetValues; +begin + fFormat := tfEmpty; + fWithAlpha := tfEmpty; + fWithoutAlpha := tfEmpty; + fOpenGLFormat := tfEmpty; + fRGBInverted := tfEmpty; + fUncompressed := tfEmpty; + + fBitsPerPixel := 0; + fIsCompressed := false; + + fglFormat := 0; + fglInternalFormat := 0; + fglDataFormat := 0; + + FillChar(fPrecision, 0, SizeOf(fPrecision)); + FillChar(fShift, 0, SizeOf(fShift)); +end; + +procedure TglBitmapFormatDescriptor.CalcValues; +var + i: Integer; +begin + fBytesPerPixel := fBitsPerPixel / 8; + fChannelCount := 0; + for i := 0 to 3 do begin + if (fPrecision.arr[i] > 0) then + inc(fChannelCount); + fRange.arr[i] := (1 shl fPrecision.arr[i]) - 1; + fMask.arr[i] := fRange.arr[i] shl fShift.arr[i]; + end; +end; + +constructor TglBitmapFormatDescriptor.Create; +begin + inherited Create; + SetValues; + CalcValues; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +class function TglBitmapFormatDescriptor.GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor; +var + f: TglBitmapFormat; +begin + for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin + result := TFormatDescriptor.Get(f); + if (result.glInternalFormat = aInternalFormat) then + exit; + end; + result := TFormatDescriptor.Get(tfEmpty); +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TFormatDescriptor/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class procedure TFormatDescriptor.Init; @@ -3745,12 +3994,38 @@ begin end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -class function TFormatDescriptor.GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; +class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor; begin result := Get(Get(aFormat).WithAlpha); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +class function TFormatDescriptor.GetFromMask(const aMask: TglBitmapRec4ul; const aBitCount: Integer): TFormatDescriptor; +var + ft: TglBitmapFormat; +begin + // find matching format with OpenGL support + for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + result := Get(ft); + if (result.MaskMatch(aMask)) and + (result.glFormat <> 0) and + (result.glInternalFormat <> 0) and + ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) + then + exit; + end; + + // find matching format without OpenGL Support + for ft := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin + result := Get(ft); + if result.MaskMatch(aMask) and ((aBitCount = 0) or (aBitCount = result.BitsPerPixel)) then + exit; + end; + + result := FormatDescriptors[tfEmpty]; +end; + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// class procedure TFormatDescriptor.Clear; var f: TglBitmapFormat; @@ -3774,209 +4049,149 @@ end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TBitfieldFormat///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetRedMask(const aValue: QWord); -begin - Update(aValue, fRange.r, fShift.r); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord); -begin - Update(aValue, fRange.g, fShift.g); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord); -begin - Update(aValue, fRange.b, fShift.b); -end; - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord); +procedure TbmpBitfieldFormat.SetValues(const aBPP: Integer; aMask: TglBitmapRec4ul); +var + i: Integer; begin - Update(aValue, fRange.a, fShift.a); + for i := 0 to 3 do begin + fShift.arr[i] := 0; + while (aMask.arr[i] > 0) and (aMask.arr[i] and 1 > 0) do begin + aMask.arr[i] := aMask.arr[i] shr 1; + inc(fShift.arr[i]); + end; + fPrecision.arr[i] := CountSetBits(aMask.arr[i]); + end; + CalcValues; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out - aShift: Byte); +procedure TbmpBitfieldFormat.SetValues(const aBBP: Integer; const aPrec, aShift: TglBitmapRec4ub); begin - aShift := 0; - aRange := 0; - if (aMask = 0) then - exit; - while (aMask > 0) and ((aMask and 1) = 0) do begin - inc(aShift); - aMask := aMask shr 1; - end; - aRange := 1; - while (aMask > 0) do begin - aRange := aRange shl 1; - aMask := aMask shr 1; - end; - dec(aRange); - - fPixelSize := Round(GetTopMostBit(RedMask or GreenMask or BlueMask or AlphaMask) / 8); + fBitsPerPixel := aBBP; + fPrecision := aPrec; + fShift := aShift; + CalcValues; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); var data: QWord; - s: Integer; begin data := - ((aPixel.Data.r and fRange.r) shl fShift.r) or - ((aPixel.Data.g and fRange.g) shl fShift.g) or - ((aPixel.Data.b and fRange.b) shl fShift.b) or - ((aPixel.Data.a and fRange.a) shl fShift.a); - s := Round(fPixelSize); - case s of - 1: aData^ := data; - 2: PWord(aData)^ := data; - 4: PCardinal(aData)^ := data; - 8: PQWord(aData)^ := data; + ((aPixel.Data.r and Range.r) shl Shift.r) or + ((aPixel.Data.g and Range.g) shl Shift.g) or + ((aPixel.Data.b and Range.b) shl Shift.b) or + ((aPixel.Data.a and Range.a) shl Shift.a); + case BitsPerPixel of + 8: aData^ := data; + 16: PWord(aData)^ := data; + 32: PCardinal(aData)^ := data; + 64: PQWord(aData)^ := data; else - raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]); end; - inc(aData, s); + inc(aData, Round(BytesPerPixel)); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); var data: QWord; - s, i: Integer; -begin - s := Round(fPixelSize); - case s of - 1: data := aData^; - 2: data := PWord(aData)^; - 4: data := PCardinal(aData)^; - 8: data := PQWord(aData)^; + i: Integer; +begin + case BitsPerPixel of + 8: data := aData^; + 16: data := PWord(aData)^; + 32: data := PCardinal(aData)^; + 64: data := PQWord(aData)^; else - raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]); + raise EglBitmap.CreateFmt('invalid pixel size: %d', [BitsPerPixel]); end; for i := 0 to 3 do - aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i]; - inc(aData, s); + aPixel.Data.arr[i] := (data shr fShift.arr[i]) and Range.arr[i]; + inc(aData, Round(BytesPerPixel)); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TColorTableFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure TbmpColorTableFormat.CreateColorTable; -var - i: Integer; +procedure TbmpColorTableFormat.SetValues; begin - if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmap.Create(UNSUPPORTED_FORMAT); + inherited SetValues; + fShift := glBitmapRec4ub(8, 8, 8, 0); +end; - if (Format = tfLuminance4) then - SetLength(fColorTable, 16) - else - SetLength(fColorTable, 256); +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.SetValues(const aFormat: TglBitmapFormat; const aBPP: Integer; const aPrec, aShift: TglBitmapRec4ub); +begin + fFormat := aFormat; + fBitsPerPixel := aBPP; + fPrecision := aPrec; + fShift := aShift; + CalcValues; +end; - case Format of - tfLuminance4: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := 16 * i; - fColorTable[i].g := 16 * i; - fColorTable[i].b := 16 * i; - fColorTable[i].a := 0; - end; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.CalcValues; +begin + inherited CalcValues; +end; - tfLuminance8: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := i; - fColorTable[i].g := i; - fColorTable[i].b := i; - fColorTable[i].a := 0; - end; +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +procedure TbmpColorTableFormat.CreateColorTable; +var + i: Integer; +begin + SetLength(fColorTable, 256); + if not HasColor then begin + // alpha + for i := 0 to High(fColorTable) do begin + fColorTable[i].r := Round(((i shr Shift.a) and Range.a) / Range.a * 255); + fColorTable[i].g := Round(((i shr Shift.a) and Range.a) / Range.a * 255); + fColorTable[i].b := Round(((i shr Shift.a) and Range.a) / Range.a * 255); + fColorTable[i].a := 0; end; - - tfR3G3B2: begin - for i := 0 to High(fColorTable) do begin - fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255); - fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255); - fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255); - fColorTable[i].a := 0; - end; + end else begin + // normal + for i := 0 to High(fColorTable) do begin + fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255); + fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255); + fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255); + fColorTable[i].a := 0; end; end; end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); -var - d: Byte; begin - if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then - raise EglBitmap.Create(UNSUPPORTED_FORMAT); - - case Format of - tfLuminance4: begin - if (aMapData = nil) then - aData^ := 0; - d := LuminanceWeight(aPixel) and Range.r; - aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData))); - inc(PByte(aMapData), 4); - if ({%H-}PtrUInt(aMapData) >= 8) then begin - inc(aData); - aMapData := nil; - end; - end; - - tfLuminance8: begin - aData^ := LuminanceWeight(aPixel) and Range.r; - inc(aData); - end; - - tfR3G3B2: begin - aData^ := Round( - ((aPixel.Data.r and Range.r) shl Shift.r) or - ((aPixel.Data.g and Range.g) shl Shift.g) or - ((aPixel.Data.b and Range.b) shl Shift.b)); - inc(aData); - end; - end; + if (BitsPerPixel <> 8) then + raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats'); + if not HasColor then + // alpha + aData^ := aPixel.Data.a + else + // normal + aData^ := Round( + ((aPixel.Data.r and Range.r) shl Shift.r) or + ((aPixel.Data.g and Range.g) shl Shift.g) or + ((aPixel.Data.b and Range.b) shl Shift.b)); + inc(aData); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); -var - idx: QWord; - s: Integer; - bits: Byte; - f: Single; -begin - s := Trunc(fPixelSize); - f := fPixelSize - s; - bits := Round(8 * f); - case s of - 0: idx := (aData^ shr (8 - bits - {%H-}PtrInt(aMapData))) and ((1 shl bits) - 1); - 1: idx := aData^; - 2: idx := PWord(aData)^; - 4: idx := PCardinal(aData)^; - 8: idx := PQWord(aData)^; - else - raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]); - end; - if (idx >= Length(fColorTable)) then - raise EglBitmap.CreateFmt('invalid color index: %d', [idx]); - with fColorTable[idx] do begin +begin + if (BitsPerPixel <> 8) then + raise EglBitmapUnsupportedFormat.Create('color table are only supported for 8bit formats'); + with fColorTable[aData^] do begin aPixel.Data.r := r; aPixel.Data.g := g; aPixel.Data.b := b; aPixel.Data.a := a; end; - inc(PByte(aMapData), bits); - if ({%H-}PtrUInt(aMapData) >= 8) then begin - inc(aData, 1); - dec(PByte(aMapData), 8); - end; - inc(aData, s); + inc(aData, 1); end; destructor TbmpColorTableFormat.Destroy; @@ -3997,7 +4212,7 @@ begin if (aSourceFD.Range.arr[i] > 0) then aPixel.Data.arr[i] := Round(aPixel.Data.arr[i] / aSourceFD.Range.arr[i] * aDestFD.Range.arr[i]) else - aPixel.Data.arr[i] := aDestFD.Range.arr[i]; + aPixel.Data.arr[i] := 0; end; end; end; @@ -4227,7 +4442,7 @@ procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat); begin if fFormat = aValue then exit; - if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then + if TFormatDescriptor.Get(Format).BitsPerPixel <> TFormatDescriptor.Get(aValue).BitsPerPixel then raise EglBitmapUnsupportedFormat.Create(Format); SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method end; @@ -4344,7 +4559,7 @@ begin fDimension.Y := aHeight; end; - s := TFormatDescriptor.Get(aFormat).PixelSize; + s := TFormatDescriptor.Get(aFormat).BytesPerPixel; fFormat := aFormat; fPixelSize := Ceil(s); fRowSize := Ceil(s * aWidth); @@ -4550,7 +4765,7 @@ begin raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format); // inkompatible Formats so CreateTemp - if (SourceFD.PixelSize <> DestFD.PixelSize) then + if (SourceFD.BitsPerPixel <> DestFD.BitsPerPixel) then aCreateTemp := true; // Values @@ -4664,7 +4879,8 @@ var pSource, pData, pTempData: PByte; Row, RowSize, TempWidth, TempHeight: Integer; IntFormat: TglBitmapFormat; - FormatDesc: TFormatDescriptor; + fd: TFormatDescriptor; + Mask: TglBitmapMask; function GetRowPointer(Row: Integer): pByte; begin @@ -4676,18 +4892,19 @@ begin result := false; 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; + Mask.r := RMask; + Mask.g := GMask; + Mask.b := BMask; + Mask.a := AMask; + IntFormat := TFormatDescriptor.GetFromMask(Mask).Format; if (IntFormat = tfEmpty) then - raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.'); + raise EglBitmap.Create('AssignFromSurface - Invalid Pixelformat.'); end; + fd := TFormatDescriptor.Get(IntFormat); TempWidth := aSurface^.w; TempHeight := aSurface^.h; - RowSize := FormatDesc.GetSize(TempWidth, 1); + RowSize := fd.GetSize(TempWidth, 1); GetMem(pData, TempHeight * RowSize); try pTempData := pData; @@ -4723,14 +4940,14 @@ var begin result := false; if Assigned(Data) then begin - if Format in [tfAlpha8, tfLuminance8Alpha8, tfBGRA8, tfRGBA8] then begin + if Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfBGRA8ub4, tfRGBA8ub4] then begin aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0); AlphaInterleave := 0; case Format of - tfLuminance8Alpha8: + tfLuminance8Alpha8ub2: AlphaInterleave := 1; - tfBGRA8, tfRGBA8: + tfBGRA8ub4, tfRGBA8ub4: AlphaInterleave := 3; end; @@ -4801,17 +5018,17 @@ begin aBitmap.Height := Height; case Format of - tfAlpha8, tfLuminance8: begin + tfAlpha8ub1, tfLuminance8ub1: begin aBitmap.PixelFormat := pf8bit; aBitmap.Palette := CreateGrayPalette; end; - tfRGB5A1: + tfRGB5A1us1: aBitmap.PixelFormat := pf15bit; - tfR5G6B5: + tfR5G6B5us1: aBitmap.PixelFormat := pf16bit; - tfRGB8, tfBGR8: + tfRGB8ub3, tfBGR8ub3: aBitmap.PixelFormat := pf24bit; - tfRGBA8, tfBGRA8: + tfRGBA8ub4, tfBGRA8ub4: aBitmap.PixelFormat := pf32bit; else raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.'); @@ -4822,8 +5039,8 @@ begin pData := aBitmap.Scanline[Row]; Move(pSource^, pData^, fRowSize); Inc(pSource, fRowSize); - if (Format in [tfRGB8, tfRGBA8]) then // swap RGB(A) to BGR(A) - SwapRGB(pData, FileWidth, Format = tfRGBA8); + if (Format in [tfRGB8ub3, tfRGBA8ub4]) then // swap RGB(A) to BGR(A) + SwapRGB(pData, FileWidth, Format = tfRGBA8ub4); end; result := true; end; @@ -4842,15 +5059,15 @@ begin if (Assigned(aBitmap)) then begin case aBitmap.PixelFormat of pf8bit: - IntFormat := tfLuminance8; + IntFormat := tfLuminance8ub1; pf15bit: - IntFormat := tfRGB5A1; + IntFormat := tfRGB5A1us1; pf16bit: - IntFormat := tfR5G6B5; + IntFormat := tfR5G6B5us1; pf24bit: - IntFormat := tfBGR8; + IntFormat := tfBGR8ub3; pf32bit: - IntFormat := tfBGRA8; + IntFormat := tfBGRA8ub4; else raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.'); end; @@ -4887,7 +5104,7 @@ begin result := false; if Assigned(Data) then begin - if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin + if (Format in [tfAlpha8ub1, tfLuminance8Alpha8ub2, tfRGBA8ub4, tfBGRA8ub4]) then begin if Assigned(aBitmap) then begin aBitmap.PixelFormat := pf8bit; aBitmap.Palette := CreateGrayPalette; @@ -4895,9 +5112,9 @@ begin aBitmap.Height := Height; case Format of - tfLuminance8Alpha8: + tfLuminance8Alpha8ub2: AlphaInterleave := 1; - tfRGBA8, tfBGRA8: + tfRGBA8ub4, tfBGRA8ub4: AlphaInterleave := 3; else AlphaInterleave := 0; @@ -4945,6 +5162,9 @@ var rid: TRawImageDescription; FormatDesc: TFormatDescriptor; begin + if not Assigned(Data) then + raise EglBitmap.Create('no pixel data assigned. load data before save'); + result := false; if not Assigned(aImage) or (Format = tfEmpty) then exit; @@ -4953,22 +5173,19 @@ begin exit; FillChar(rid{%H-}, SizeOf(rid), 0); - if (Format in [ - tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16, - tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16, - tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16]) then + if FormatDesc.IsGrayscale then rid.Format := ricfGray else rid.Format := ricfRGBA; rid.Width := Width; rid.Height := Height; - rid.Depth := CountSetBits(FormatDesc.RedMask or FormatDesc.GreenMask or FormatDesc.BlueMask or FormatDesc.AlphaMask); + rid.Depth := FormatDesc.BitsPerPixel; rid.BitOrder := riboBitsInOrder; rid.ByteOrder := riboLSBFirst; rid.LineOrder := riloTopToBottom; rid.LineEnd := rileTight; - rid.BitsPerPixel := Round(8 * FormatDesc.PixelSize); + rid.BitsPerPixel := FormatDesc.BitsPerPixel; rid.RedPrec := CountSetBits(FormatDesc.Range.r); rid.GreenPrec := CountSetBits(FormatDesc.Range.g); rid.BluePrec := CountSetBits(FormatDesc.Range.b); @@ -4984,6 +5201,8 @@ begin aImage.DataDescription := rid; aImage.CreateData; + if not Assigned(aImage.PixelData) then + raise EglBitmap.Create('error while creating LazIntfImage'); Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension)); result := true; @@ -4997,29 +5216,35 @@ var ImageData: PByte; ImageSize: Integer; CanCopy: Boolean; + Mask: TglBitmapRec4ul; procedure CopyConvert; var bfFormat: TbmpBitfieldFormat; pSourceLine, pDestLine: PByte; pSourceMD, pDestMD: Pointer; + Shift, Prec: TglBitmapRec4ub; x, y: Integer; pixel: TglBitmapPixelData; begin bfFormat := TbmpBitfieldFormat.Create; with aImage.DataDescription do begin - bfFormat.RedMask := ((1 shl RedPrec) - 1) shl RedShift; - bfFormat.GreenMask := ((1 shl GreenPrec) - 1) shl GreenShift; - bfFormat.BlueMask := ((1 shl BluePrec) - 1) shl BlueShift; - bfFormat.AlphaMask := ((1 shl AlphaPrec) - 1) shl AlphaShift; - bfFormat.PixelSize := BitsPerPixel / 8; + Prec.r := RedPrec; + Prec.g := GreenPrec; + Prec.b := BluePrec; + Prec.a := AlphaPrec; + Shift.r := RedShift; + Shift.g := GreenShift; + Shift.b := BlueShift; + Shift.a := AlphaShift; + bfFormat.SetValues(BitsPerPixel, Prec, Shift); end; pSourceMD := bfFormat.CreateMappingData; pDestMD := FormatDesc.CreateMappingData; try for y := 0 to aImage.Height-1 do begin - pSourceLine := aImage.PixelData + y * aImage.DataDescription.BytesPerLine; - pDestLine := ImageData + y * Round(FormatDesc.PixelSize * aImage.Width); + pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine; + pDestLine := ImageData + y * Round(FormatDesc.BytesPerPixel * aImage.Width); for x := 0 to aImage.Width-1 do begin bfFormat.Unmap(pSourceLine, pixel, pSourceMD); FormatDesc.Map(pixel, pDestLine, pDestMD); @@ -5036,22 +5261,20 @@ begin result := false; if not Assigned(aImage) then exit; - for f := High(f) downto Low(f) do begin - FormatDesc := TFormatDescriptor.Get(f); - with aImage.DataDescription do - if FormatDesc.MaskMatch( - (QWord(1 shl RedPrec )-1) shl RedShift, - (QWord(1 shl GreenPrec)-1) shl GreenShift, - (QWord(1 shl BluePrec )-1) shl BlueShift, - (QWord(1 shl AlphaPrec)-1) shl AlphaShift) then - break; - end; + with aImage.DataDescription do begin + Mask.r := (QWord(1 shl RedPrec )-1) shl RedShift; + Mask.g := (QWord(1 shl GreenPrec)-1) shl GreenShift; + Mask.b := (QWord(1 shl BluePrec )-1) shl BlueShift; + Mask.a := (QWord(1 shl AlphaPrec)-1) shl AlphaShift; + end; + FormatDesc := TFormatDescriptor.GetFromMask(Mask); + f := FormatDesc.Format; if (f = tfEmpty) then exit; CanCopy := - (Round(FormatDesc.PixelSize * 8) = aImage.DataDescription.Depth) and + (FormatDesc.BitsPerPixel = aImage.DataDescription.Depth) and (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth); ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height); @@ -5307,7 +5530,7 @@ function TglBitmap.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); result := AddAlphaFromColorKeyFloat( aRed / PixelData.Range.r, aGreen / PixelData.Range.g, @@ -5323,7 +5546,7 @@ var i: Integer; PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); with PixelData do begin values[0] := aRed; values[1] := aGreen; @@ -5351,7 +5574,7 @@ function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean; var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a); end; @@ -5360,7 +5583,7 @@ function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean; var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); with PixelData do Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha))); result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a); @@ -5440,6 +5663,11 @@ var SourcePD, DestPD: TglBitmapPixelData; ShiftData: TShiftData; + function DataIsIdentical: Boolean; + begin + result := SourceFD.MaskMatch(DestFD.Mask); + end; + function CanCopyDirect: Boolean; begin result := @@ -5472,6 +5700,12 @@ begin SourceFD := TFormatDescriptor.Get(Format); DestFD := TFormatDescriptor.Get(aFormat); + if DataIsIdentical then begin + result := true; + Format := aFormat; + exit; + end; + SourceFD.PreparePixel(SourcePD); DestFD.PreparePixel (DestPD); @@ -5532,7 +5766,7 @@ procedure TglBitmap.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; cons var PixelData: TglBitmapPixelData; begin - TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData); + TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData); FillWithColorFloat( aRed / PixelData.Range.r, aGreen / PixelData.Range.g, @@ -5895,13 +6129,13 @@ begin // format case png_get_color_type(png, png_info) of PNG_COLOR_TYPE_GRAY: - Format := tfLuminance8; + Format := tfLuminance8ub1; PNG_COLOR_TYPE_GRAY_ALPHA: - Format := tfLuminance8Alpha8; + Format := tfLuminance8Alpha8us1; PNG_COLOR_TYPE_RGB: - Format := tfRGB8; + Format := tfRGB8ub3; PNG_COLOR_TYPE_RGB_ALPHA: - Format := tfRGBA8; + Format := tfRGBA8ub4; else raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); end; @@ -5980,13 +6214,13 @@ begin case Png.Header.ColorType of COLOR_GRAYSCALE: - PngFormat := tfLuminance8; + PngFormat := tfLuminance8ub1; COLOR_GRAYSCALEALPHA: - PngFormat := tfLuminance8Alpha8; + PngFormat := tfLuminance8Alpha8us1; COLOR_RGB: - PngFormat := tfBGR8; + PngFormat := tfBGR8ub3; COLOR_RGBALPHA: - PngFormat := tfBGRA8; + PngFormat := tfBGRA8ub4; else raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.'); end; @@ -6097,13 +6331,13 @@ begin try case Format of - tfAlpha8, tfLuminance8: + tfAlpha8ub1, tfLuminance8ub1: ColorType := PNG_COLOR_TYPE_GRAY; - tfLuminance8Alpha8: + tfLuminance8Alpha8us1: ColorType := PNG_COLOR_TYPE_GRAY_ALPHA; - tfBGR8, tfRGB8: + tfBGR8ub3, tfRGB8ub3: ColorType := PNG_COLOR_TYPE_RGB; - tfBGRA8, tfRGBA8: + tfBGRA8ub4, tfRGBA8ub4: ColorType := PNG_COLOR_TYPE_RGBA; else raise EglBitmapUnsupportedFormat.Create(Format); @@ -6138,7 +6372,7 @@ begin // set compression png_set_compression_level(png, 6); - if Format in [tfBGR8, tfBGRA8] then + if Format in [tfBGR8ub3, tfBGRA8ub4] 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); @@ -6172,22 +6406,22 @@ begin raise EglBitmapUnsupportedFormat.Create(Format); case Format of - tfAlpha8, tfLuminance8: begin + tfAlpha8ub1, tfLuminance8ub1: begin ColorType := COLOR_GRAYSCALE; PixSize := 1; Alpha := false; end; - tfLuminance8Alpha8: begin + tfLuminance8Alpha8us1: begin ColorType := COLOR_GRAYSCALEALPHA; PixSize := 1; Alpha := true; end; - tfBGR8, tfRGB8: begin + tfBGR8ub3, tfRGB8ub3: begin ColorType := COLOR_RGB; PixSize := 3; Alpha := false; end; - tfBGRA8, tfRGBA8: begin + tfBGRA8ub4, tfRGBA8ub4: begin ColorType := COLOR_RGBALPHA; PixSize := 3; Alpha := true @@ -6213,7 +6447,7 @@ begin end; // convert RGB line to BGR - if Format in [tfRGB8, tfRGBA8] then begin + if Format in [tfRGB8ub3, tfRGBA8ub4] then begin pTemp := png.ScanLine[Y]; for X := 0 to Width -1 do begin Temp := pByteArray(pTemp)^[0]; @@ -6503,11 +6737,11 @@ begin JCS_GRAYSCALE: begin jpeg.out_color_space := JCS_GRAYSCALE; - IntFormat := tfLuminance8; + IntFormat := tfLuminance8ub1; end; else jpeg.out_color_space := JCS_RGB; - IntFormat := tfRGB8; + IntFormat := tfRGB8ub3; end; // reading image @@ -6668,11 +6902,11 @@ begin jpeg.image_width := Width; jpeg.image_height := Height; case Format of - tfAlpha8, tfLuminance8: begin + tfAlpha8ub1, tfLuminance8ub1: begin jpeg.input_components := 1; jpeg.in_color_space := JCS_GRAYSCALE; end; - tfRGB8, tfBGR8: begin + tfRGB8ub3, tfBGR8ub3: begin jpeg.input_components := 3; jpeg.in_color_space := JCS_RGB; end; @@ -6683,7 +6917,7 @@ begin jpeg_start_compress(@jpeg, true); pTemp := Data; - if Format = tfBGR8 then + if Format = tfBGR8ub3 then GetMem(pTemp2, fRowSize) else pTemp2 := pTemp; @@ -6691,7 +6925,7 @@ begin try for Row := 0 to jpeg.image_height -1 do begin // prepare row - if Format = tfBGR8 then + if Format = tfBGR8ub3 then CopyRow(pTemp2, pTemp) else pTemp2 := pTemp; @@ -6702,7 +6936,7 @@ begin end; finally // free memory - if Format = tfBGR8 then + if Format = tfBGR8ub3 then FreeMem(pTemp2); end; jpeg_finish_compress(@jpeg); @@ -6727,7 +6961,7 @@ begin Jpg := TJPEGImage.Create; try AssignToBitmap(Bmp); - if (Format in [tfAlpha8, tfLuminance8]) then begin + if (Format in [tfAlpha8ub1, tfLuminance8ub1]) then begin Jpg.Grayscale := true; Jpg.PixelFormat := jf8Bit; end; @@ -6781,7 +7015,7 @@ type function TglBitmap.LoadBMP(const aStream: TStream): Boolean; ////////////////////////////////////////////////////////////////////////////////////////////////// - function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapColorRec): TglBitmapFormat; + function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapRec4ul): TglBitmapFormat; begin result := tfEmpty; aStream.Read(aInfo{%H-}, SizeOf(aInfo)); @@ -6806,10 +7040,10 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean; //get suitable format case aInfo.biBitCount of - 8: result := tfLuminance8; - 16: result := tfBGR5; - 24: result := tfBGR8; - 32: result := tfBGRA8; + 8: result := tfLuminance8ub1; + 16: result := tfX1RGB5us1; + 24: result := tfBGR8ub3; + 32: result := tfXRGB8ui1; end; end; @@ -6821,7 +7055,7 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean; result := nil; if (aInfo.biBitCount >= 16) then exit; - aFormat := tfLuminance8; + aFormat := tfLuminance8ub1; c := aInfo.biClrUsed; if (c = 0) then c := 1 shl aInfo.biBitCount; @@ -6829,43 +7063,33 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean; for i := 0 to c-1 do begin aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty)); if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then - aFormat := tfRGB8; + aFormat := tfRGB8ub3; end; result := TbmpColorTableFormat.Create; - result.PixelSize := aInfo.biBitCount / 8; - result.ColorTable := ColorTable; - result.Range := glBitmapColorRec($FF, $FF, $FF, $00); + result.BitsPerPixel := aInfo.biBitCount; + result.ColorTable := ColorTable; + result.CalcValues; end; ////////////////////////////////////////////////////////////////////////////////////////////////// - function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapColorRec; - const aInfo: TBMPInfo): TbmpBitfieldFormat; + function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapRec4ul; const aInfo: TBMPInfo): TbmpBitfieldFormat; var - TmpFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; begin result := nil; if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin - for TmpFormat := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin - FormatDesc := TFormatDescriptor.Get(TmpFormat); - if FormatDesc.MaskMatch(aMask.r, aMask.g, aMask.b, aMask.a) then begin - aFormat := FormatDesc.Format; - exit; - end; - end; - + FormatDesc := TFormatDescriptor.GetFromMask(aMask); + if (FormatDesc.Format = tfEmpty) then + exit; + aFormat := FormatDesc.Format; if (aMask.a = 0) and TFormatDescriptor.Get(aFormat).HasAlpha then aFormat := TFormatDescriptor.Get(aFormat).WithoutAlpha; if (aMask.a <> 0) and not TFormatDescriptor.Get(aFormat).HasAlpha then aFormat := TFormatDescriptor.Get(aFormat).WithAlpha; result := TbmpBitfieldFormat.Create; - result.PixelSize := aInfo.biBitCount / 8; - result.RedMask := aMask.r; - result.GreenMask := aMask.g; - result.BlueMask := aMask.b; - result.AlphaMask := aMask.a; + result.SetValues(aInfo.biBitCount, aMask); end; end; @@ -6879,7 +7103,7 @@ var BmpFormat: TglBitmapFormat; //records - Mask: TglBitmapColorRec; + Mask: TglBitmapRec4ul; Header: TBMPHeader; Info: TBMPInfo; @@ -6925,7 +7149,7 @@ begin if (BmpFormat <> tfEmpty) then begin FormatDesc := TFormatDescriptor.Get(BmpFormat); rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize - wbLineSize := Trunc(Info.biWidth * FormatDesc.PixelSize); + wbLineSize := Trunc(Info.biWidth * FormatDesc.BytesPerPixel); Padding := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize; //get Memory @@ -7027,50 +7251,36 @@ begin try case Format of - tfLuminance4: begin - Info.biBitCount := 4; - Header.bfSize := Header.bfSize + 16 * SizeOf(Cardinal); - Header.bfOffBits := Header.bfOffBits + 16 * SizeOf(Cardinal); //16 ColorTable entries - Converter := TbmpColorTableFormat.Create; - with (Converter as TbmpColorTableFormat) do begin - PixelSize := 0.5; - Format := Format; - Range := glBitmapColorRec($F, $F, $F, $0); - CreateColorTable; - end; - end; - - tfR3G3B2, tfLuminance8: begin + tfAlpha4ub1, tfAlpha8ub1, tfLuminance4ub1, tfLuminance8ub1, tfR3G3B2ub1: + begin Info.biBitCount := 8; Header.bfSize := Header.bfSize + 256 * SizeOf(Cardinal); Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries Converter := TbmpColorTableFormat.Create; with (Converter as TbmpColorTableFormat) do begin - PixelSize := 1; - Format := Format; - if (Format = tfR3G3B2) then begin - Range := glBitmapColorRec($7, $7, $3, $0); - Shift := glBitmapShiftRec(0, 3, 6, 0); - end else - Range := glBitmapColorRec($FF, $FF, $FF, $0); + SetValues(fFormat, 1, FormatDesc.Precision, FormatDesc.Shift); CreateColorTable; end; end; - tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4, - tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4: begin + tfLuminance4Alpha4ub2, tfLuminance6Alpha2ub2, tfLuminance8Alpha8ub2, + tfRGBX4us1, tfXRGB4us1, tfRGB5X1us1, tfX1RGB5us1, tfR5G6B5us1, tfRGB5A1us1, tfA1RGB5us1, tfRGBA4us1, tfARGB4us1, + tfBGRX4us1, tfXBGR4us1, tfBGR5X1us1, tfX1BGR5us1, tfB5G6R5us1, tfBGR5A1us1, tfA1BGR5us1, tfBGRA4us1, tfABGR4us1: + begin Info.biBitCount := 16; Info.biCompression := BMP_COMP_BITFIELDS; end; - tfBGR8, tfRGB8: begin + tfBGR8ub3, tfRGB8ub3: + begin Info.biBitCount := 24; - if (Format = tfRGB8) then - Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values + if (Format = tfRGB8ub3) then + Converter := TfdBGR8ub3.Create; //use BGR8 Format Descriptor to Swap RGB Values end; - tfRGB10, tfRGB10A2, tfRGBA8, - tfBGR10, tfBGR10A2, tfBGRA8: begin + tfRGBX8ui1, tfXRGB8ui1, tfRGB10X2ui1, tfX2RGB10ui1, tfRGBA8ui1, tfARGB8ui1, tfRGBA8ub4, tfRGB10A2ui1, tfA2RGB10ui1, + tfBGRX8ui1, tfXBGR8ui1, tfBGR10X2ui1, tfX2BGR10ui1, tfBGRA8ui1, tfABGR8ui1, tfBGRA8ub4, tfBGR10A2ui1, tfA2BGR10ui1: + begin Info.biBitCount := 32; Info.biCompression := BMP_COMP_BITFIELDS; end; @@ -7085,10 +7295,10 @@ begin Header.bfSize := Header.bfSize + 4 * SizeOf(Cardinal); Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal); - RedMask := FormatDesc.RedMask; - GreenMask := FormatDesc.GreenMask; - BlueMask := FormatDesc.BlueMask; - AlphaMask := FormatDesc.AlphaMask; + RedMask := FormatDesc.Mask.r; + GreenMask := FormatDesc.Mask.g; + BlueMask := FormatDesc.Mask.b; + AlphaMask := FormatDesc.Mask.a; end; // headers @@ -7110,7 +7320,7 @@ begin end; // image data - rbLineSize := Round(Info.biWidth * FormatDesc.PixelSize); + rbLineSize := Round(Info.biWidth * FormatDesc.BytesPerPixel); wbLineSize := Round(Info.biWidth * Info.biBitCount / 8); Padding := GetLineWidth - wbLineSize; PaddingBuff := 0; @@ -7390,26 +7600,29 @@ begin tgaFormat := tfEmpty; case Header.Bpp of 8: if IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfLuminance8; - 8: tgaFormat := tfAlpha8; + 0: tgaFormat := tfLuminance8ub1; + 8: tgaFormat := tfAlpha8ub1; end; 16: if IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfLuminance16; - 8: tgaFormat := tfLuminance8Alpha8; + 0: tgaFormat := tfLuminance16us1; + 8: tgaFormat := tfLuminance8Alpha8ub2; end else case (Header.ImageDesc and $F) of - 0: tgaFormat := tfBGR5; - 1: tgaFormat := tfBGR5A1; - 4: tgaFormat := tfBGRA4; + 0: tgaFormat := tfX1RGB5us1; + 1: tgaFormat := tfA1RGB5us1; + 4: tgaFormat := tfARGB4us1; end; 24: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 0: tgaFormat := tfBGR8; + 0: tgaFormat := tfBGR8ub3; end; - 32: if not IsGrayFormat then case (Header.ImageDesc and $F) of - 2: tgaFormat := tfBGR10A2; - 8: tgaFormat := tfBGRA8; + 32: if IsGrayFormat then case (Header.ImageDesc and $F) of + 0: tgaFormat := tfDepth32ui1; + end else case (Header.ImageDesc and $F) of + 0: tgaFormat := tfX2RGB10ui1; + 2: tgaFormat := tfA2RGB10ui1; + 8: tgaFormat := tfARGB8ui1; end; end; @@ -7470,89 +7683,29 @@ end; procedure TglBitmap.SaveTGA(const aStream: TStream); var Header: TTGAHeader; - LineSize, Size, x, y: Integer; - Pixel: TglBitmapPixelData; - LineBuf, SourceData, DestData: PByte; - SourceMD, DestMD: Pointer; + Size: Integer; FormatDesc: TFormatDescriptor; - Converter: TFormatDescriptor; begin if not (ftTGA in FormatGetSupportedFiles(Format)) then raise EglBitmapUnsupportedFormat.Create(Format); //prepare header + FormatDesc := TFormatDescriptor.Get(Format); FillChar(Header{%H-}, SizeOf(Header), 0); - - //set ImageType - if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8, - tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8]) then - Header.ImageType := TGA_UNCOMPRESSED_GRAY - else - Header.ImageType := TGA_UNCOMPRESSED_RGB; - - //set BitsPerPixel - if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8]) then - Header.Bpp := 8 - else if (Format in [tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8, - tfRGB5, tfBGR5, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then - Header.Bpp := 16 - else if (Format in [tfBGR8, tfRGB8]) then - Header.Bpp := 24 - else - Header.Bpp := 32; - - //set AlphaBitCount - case Format of - tfRGB5A1, tfBGR5A1: - Header.ImageDesc := 1 and $F; - tfRGB10A2, tfBGR10A2: - Header.ImageDesc := 2 and $F; - tfRGBA4, tfBGRA4: - Header.ImageDesc := 4 and $F; - tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8: - Header.ImageDesc := 8 and $F; - end; - + Header.ImageDesc := CountSetBits(FormatDesc.Range.a) and $F; + Header.Bpp := FormatDesc.BitsPerPixel; Header.Width := Width; Header.Height := Height; Header.ImageDesc := Header.ImageDesc or $20; //flip y + if FormatDesc.IsGrayscale or (not FormatDesc.IsGrayscale and not FormatDesc.HasRed and FormatDesc.HasAlpha) then + Header.ImageType := TGA_UNCOMPRESSED_GRAY + else + Header.ImageType := TGA_UNCOMPRESSED_RGB; aStream.Write(Header, SizeOf(Header)); - // convert RGB(A) to BGR(A) - Converter := nil; - FormatDesc := TFormatDescriptor.Get(Format); - Size := FormatDesc.GetSize(Dimension); - if Format in [tfRGB5, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin - if (FormatDesc.RGBInverted = tfEmpty) then - raise EglBitmap.Create('inverted RGB format is empty'); - Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted); - if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or - (Converter.PixelSize <> FormatDesc.PixelSize) then - raise EglBitmap.Create('invalid inverted RGB format'); - end; - - if Assigned(Converter) then begin - LineSize := FormatDesc.GetSize(Width, 1); - GetMem(LineBuf, LineSize); - SourceMD := FormatDesc.CreateMappingData; - DestMD := Converter.CreateMappingData; - try - SourceData := Data; - for y := 0 to Height-1 do begin - DestData := LineBuf; - for x := 0 to Width-1 do begin - FormatDesc.Unmap(SourceData, Pixel, SourceMD); - Converter.Map(Pixel, DestData, DestMD); - end; - aStream.Write(LineBuf^, LineSize); - end; - finally - FreeMem(LineBuf); - FormatDesc.FreeMappingData(SourceMD); - FormatDesc.FreeMappingData(DestMD); - end; - end else - aStream.Write(Data^, Size); + // write Data + Size := FormatDesc.GetSize(Dimension); + aStream.Write(Data^, Size); end; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -7627,7 +7780,8 @@ var var fd: TFormatDescriptor; i: Integer; - Range: TglBitmapColorRec; + Mask: TglBitmapRec4ul; + Range: TglBitmapRec4ui; match: Boolean; begin result := tfEmpty; @@ -7639,25 +7793,31 @@ var D3DFMT_DXT3: result := tfS3tcDtx3RGBA; D3DFMT_DXT5: result := tfS3tcDtx5RGBA; end; - end else if ((Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0) then begin + end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE or DDPF_ALPHA)) > 0) then begin + // prepare masks + if ((dwFlags and DDPF_LUMINANCE) = 0) then begin + Mask.r := dwRBitMask; + Mask.g := dwGBitMask; + Mask.b := dwBBitMask; + end else begin + Mask.r := dwRBitMask; + Mask.g := dwRBitMask; + Mask.b := dwRBitMask; + end; + if (dwFlags and DDPF_ALPHAPIXELS > 0) then + Mask.a := dwABitMask + else + Mask.a := 0;; //find matching format - for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin - fd := TFormatDescriptor.Get(result); - if fd.MaskMatch(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask) and - (8 * fd.PixelSize = dwRGBBitCount) then - exit; - end; + fd := TFormatDescriptor.GetFromMask(Mask, dwRGBBitCount); + result := fd.Format; + if (result <> tfEmpty) then + exit; //find format with same Range - Range.r := dwRBitMask; - Range.g := dwGBitMask; - Range.b := dwBBitMask; - Range.a := dwABitMask; - for i := 0 to 3 do begin - while ((Range.arr[i] and 1) = 0) and (Range.arr[i] > 0) do - Range.arr[i] := Range.arr[i] shr 1; - end; + for i := 0 to 3 do + Range.arr[i] := (2 shl CountSetBits(Mask.arr[i])) - 1; for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin fd := TFormatDescriptor.Get(result); match := true; @@ -7673,17 +7833,13 @@ var //no format with same range found -> use default if (result = tfEmpty) then begin if (dwABitMask > 0) then - result := tfBGRA8 + result := tfRGBA8ui1 else - result := tfBGR8; + result := tfRGB8ub3; end; Converter := TbmpBitfieldFormat.Create; - Converter.RedMask := dwRBitMask; - Converter.GreenMask := dwGBitMask; - Converter.BlueMask := dwBBitMask; - Converter.AlphaMask := dwABitMask; - Converter.PixelSize := dwRGBBitCount / 8; + Converter.SetValues(dwRGBBitCount, glBitmapRec4ul(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask)); end; end; end; @@ -7728,7 +7884,7 @@ begin raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.'); FormatDesc := TFormatDescriptor.Get(ddsFormat); - LineSize := Trunc(Header.dwWidth * FormatDesc.PixelSize); + LineSize := Trunc(Header.dwWidth * FormatDesc.BytesPerPixel); GetMem(NewImage, Header.dwHeight * LineSize); try TmpData := NewImage; @@ -7820,22 +7976,22 @@ begin tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3; tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5; end; - end else if (Format in [tfAlpha8, tfAlpha16]) then begin + end else if not FormatDesc.HasColor and FormatDesc.HasAlpha then begin Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHA; - Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); - Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; - end else if (FormatDesc.RedMask = FormatDesc.GreenMask) and (FormatDesc.GreenMask = FormatDesc.BlueMask) then begin + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; + end else if FormatDesc.IsGrayscale then begin Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_LUMINANCE; - Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); - Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; - Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; end else begin Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB; - Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8); - Header.PixelFormat.dwRBitMask := FormatDesc.RedMask; - Header.PixelFormat.dwGBitMask := FormatDesc.GreenMask; - Header.PixelFormat.dwBBitMask := FormatDesc.BlueMask; - Header.PixelFormat.dwABitMask := FormatDesc.AlphaMask; + Header.PixelFormat.dwRGBBitCount := FormatDesc.BitsPerPixel; + Header.PixelFormat.dwRBitMask := FormatDesc.Mask.r; + Header.PixelFormat.dwGBitMask := FormatDesc.Mask.g; + Header.PixelFormat.dwBBitMask := FormatDesc.Mask.b; + Header.PixelFormat.dwABitMask := FormatDesc.Mask.a; end; if (FormatDesc.HasAlpha) then @@ -7977,7 +8133,7 @@ begin // Assigning Data if Assigned(Data) then begin SetLength(fLines, GetHeight); - LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).PixelSize); + LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).BytesPerPixel); for Idx := 0 to GetHeight-1 do begin fLines[Idx] := Data; @@ -8003,7 +8159,7 @@ begin raise EglBitmap.Create('compressed formats not supported by video adapter'); glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data) end else if aBuildWithGlu then begin - gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height, + gluBuild2DMipmaps(aTarget, FormatDesc.ChannelCount, Width, Height, FormatDesc.glFormat, FormatDesc.glDataFormat, Data) end else begin glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, @@ -8055,7 +8211,7 @@ var Temp: PByte; TempWidth, TempHeight: Integer; TempIntFormat: GLint; - IntFormat, f: TglBitmapFormat; + IntFormat: TglBitmapFormat; FormatDesc: TFormatDescriptor; begin Bind; @@ -8065,14 +8221,9 @@ begin glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_HEIGHT, @TempHeight); glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_INTERNAL_FORMAT, @TempIntFormat); - IntFormat := tfEmpty; - for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin - FormatDesc := TFormatDescriptor.Get(f); - if (FormatDesc.glInternalFormat = TempIntFormat) then begin - IntFormat := FormatDesc.Format; - break; - end; - end; + IntFormat := tfEmpty; + FormatDesc := (TglBitmapFormatDescriptor.GetByFormat(TempIntFormat) as TFormatDescriptor); + IntFormat := FormatDesc.Format; // Getting data from OpenGL FormatDesc := TFormatDescriptor.Get(IntFormat); @@ -8142,7 +8293,7 @@ begin Dec(TempDestData, fPixelSize); end; end; - SetDataPointer(DestData, Format); //be careful, Data could be freed by this method + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method result := true; except if Assigned(DestData) then @@ -8170,7 +8321,7 @@ begin Dec(TempDestData, fRowSize); Inc(SourceData, fRowSize); end; - SetDataPointer(DestData, Format); //be careful, Data could be freed by this method + SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method result := true; except if Assigned(DestData) then @@ -8585,32 +8736,32 @@ begin // Positive X Rec.Func := glBitmapNormalMapPosX; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize); // Negative X Rec.Func := glBitmapNormalMapNegX; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize); // Positive Y Rec.Func := glBitmapNormalMapPosY; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize); // Negative Y Rec.Func := glBitmapNormalMapNegY; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize); // Positive Z Rec.Func := glBitmapNormalMapPosZ; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize); // Negative Z Rec.Func := glBitmapNormalMapNegZ; - LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec); + LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8ub3, @Rec); GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize); end;