* fixed some format issues

* added new formats e.g. RGBX8, XRGB8, RGBA8. ARGB8, ...
* removed old, non usefull formats e.g. Alpha12, Luminance12, RGBA2

diff --git a/glBitmap.pas b/glBitmap.pas
index 1be10f8..4ee797b 100644 (file)
--- a/glBitmap.pas
+++ b/glBitmap.pas
@@ -778,52 +778,61 @@ type
 
     tfAlpha4,
     tfAlpha8,
 
     tfAlpha4,
     tfAlpha8,

-    tfAlpha12,

     tfAlpha16,
 
     tfLuminance4,
     tfLuminance8,
     tfAlpha16,
 
     tfLuminance4,
     tfLuminance8,

-    tfLuminance12,

     tfLuminance16,
 
     tfLuminance4Alpha4,
     tfLuminance6Alpha2,
     tfLuminance8Alpha8,
     tfLuminance12Alpha4,
     tfLuminance16,
 
     tfLuminance4Alpha4,
     tfLuminance6Alpha2,
     tfLuminance8Alpha8,
     tfLuminance12Alpha4,

-    tfLuminance12Alpha12,

     tfLuminance16Alpha16,
 
     tfR3G3B2,
     tfLuminance16Alpha16,
 
     tfR3G3B2,

-    tfRGB4,
+    tfRGBX4,
+    tfXRGB4,

     tfR5G6B5,
     tfR5G6B5,

-    tfRGB5,
+    tfRGB5X1,
+    tfX1RGB5,

     tfRGB8,
     tfRGB8,

-    tfRGB10,
-    tfRGB12,
+    tfRGBX8,
+    tfXRGB8,
+    tfRGB10X2,
+    tfX2RGB10,

     tfRGB16,
 
     tfRGB16,
 

-    tfRGBA2,

     tfRGBA4,
     tfRGBA4,

+    tfARGB4,

     tfRGB5A1,
     tfRGB5A1,

+    tfA1RGB5,

     tfRGBA8,
     tfRGBA8,

+    tfARGB8,

     tfRGB10A2,
     tfRGB10A2,

-    tfRGBA12,
+    tfA2RGB10,

     tfRGBA16,
 
     tfRGBA16,
 

-    tfBGR4,
+    tfBGRX4,
+    tfXBGR4,

     tfB5G6R5,
     tfB5G6R5,

-    tfBGR5,
+    tfBGR5X1,
+    tfX1BGR5,

     tfBGR8,
     tfBGR8,

-    tfBGR10,
-    tfBGR12,
+    tfBGRX8,
+    tfXBGR8,
+    tfBGR10X2,
+    tfX2BGR10,

     tfBGR16,
 
     tfBGR16,
 

-    tfBGRA2,

     tfBGRA4,
     tfBGRA4,

+    tfABGR4,

     tfBGR5A1,
     tfBGR5A1,

+    tfA1BGR5,

     tfBGRA8,
     tfBGRA8,

+    tfABGR8,

     tfBGR10A2,
     tfBGR10A2,

-    tfBGRA12,
+    tfA2BGR10,

     tfBGRA16,
 
     tfDepth16,
     tfBGRA16,
 
     tfDepth16,


@@ -894,6 +903,12 @@ type
     function GetHasBlue:      Boolean; virtual; abstract;
     function GetHasAlpha:     Boolean; virtual; abstract;
 
     function GetHasBlue:      Boolean; virtual; abstract;
     function GetHasAlpha:     Boolean; virtual; abstract;
 

+    function GetRGBInverted:  TglBitmapFormat; virtual; abstract;
+    function GetWithAlpha:    TglBitmapFormat; virtual; abstract;
+    function GetWithoutAlpha: TglBitmapFormat; virtual; abstract;
+    function GetOpenGLFormat: TglBitmapFormat; virtual; abstract;
+    function GetUncompressed: TglBitmapFormat; virtual; abstract;
+

     function GetglDataFormat:     GLenum;  virtual; abstract;
     function GetglFormat:         GLenum;  virtual; abstract;
     function GetglInternalFormat: GLenum;  virtual; abstract;
     function GetglDataFormat:     GLenum;  virtual; abstract;
     function GetglFormat:         GLenum;  virtual; abstract;
     function GetglInternalFormat: GLenum;  virtual; abstract;


@@ -904,6 +919,12 @@ type
     property HasBlue:      Boolean read GetHasBlue;
     property HasAlpha:     Boolean read GetHasAlpha;
 
     property HasBlue:      Boolean read GetHasBlue;
     property HasAlpha:     Boolean read GetHasAlpha;
 

+    property RGBInverted:  TglBitmapFormat read GetRGBInverted;
+    property WithAlpha:    TglBitmapFormat read GetWithAlpha;
+    property WithoutAlpha: TglBitmapFormat read GetWithoutAlpha;
+    property OpenGLFormat: TglBitmapFormat read GetOpenGLFormat;
+    property Uncompressed: TglBitmapFormat read GetUncompressed;
+

     property glFormat:         GLenum  read GetglFormat;
     property glInternalFormat: GLenum  read GetglInternalFormat;
     property glDataFormat:     GLenum  read GetglDataFormat;
     property glFormat:         GLenum  read GetglFormat;
     property glInternalFormat: GLenum  read GetglInternalFormat;
     property glDataFormat:     GLenum  read GetglDataFormat;


@@ -1266,8 +1287,10 @@ type
     fFormat: TglBitmapFormat;
     fWithAlpha: TglBitmapFormat;
     fWithoutAlpha: TglBitmapFormat;
     fFormat: TglBitmapFormat;
     fWithAlpha: TglBitmapFormat;
     fWithoutAlpha: TglBitmapFormat;

+    fOpenGLFormat: TglBitmapFormat;

     fRGBInverted: TglBitmapFormat;
     fUncompressed: TglBitmapFormat;
     fRGBInverted: TglBitmapFormat;
     fUncompressed: TglBitmapFormat;

+

     fPixelSize: Single;
     fIsCompressed: Boolean;
 
     fPixelSize: Single;
     fIsCompressed: Boolean;
 


@@ -1284,6 +1307,12 @@ type
     function GetHasBlue: Boolean; override;
     function GetHasAlpha: Boolean; override;
 
     function GetHasBlue: Boolean; override;
     function GetHasAlpha: Boolean; override;
 

+    function GetRGBInverted:  TglBitmapFormat; override;
+    function GetWithAlpha:    TglBitmapFormat; override;
+    function GetWithoutAlpha: TglBitmapFormat; override;
+    function GetOpenGLFormat: TglBitmapFormat; override;
+    function GetUncompressed: TglBitmapFormat; override;
+

     function GetglFormat: GLenum; override;
     function GetglInternalFormat: GLenum; override;
     function GetglDataFormat: GLenum; override;
     function GetglFormat: GLenum; override;
     function GetglInternalFormat: GLenum; override;
     function GetglDataFormat: GLenum; override;


@@ -1291,9 +1320,6 @@ type
     function GetComponents: Integer; virtual;
   public
     property Format:       TglBitmapFormat read fFormat;
     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 Components:   Integer         read GetComponents;
     property PixelSize:    Single          read fPixelSize;
 


@@ -1323,7 +1349,7 @@ type
   public
     class procedure Init;
     class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
   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 procedure Clear;
     class procedure Finalize;
   end;
     class procedure Clear;
     class procedure Finalize;
   end;


@@ -1335,117 +1361,98 @@ type
   TfdAlpha_UB1 = 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;
   TfdAlpha_UB1 = 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
     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;
 
   TfdLuminance_UB1 = 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
     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;
 
   TfdUniversal_UB1 = 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
     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;
 
   TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //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
     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;
 
   TfdRGB_UB3 = 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)
     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;
 
   TfdBGR_UB3 = 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
-    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)
-    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
     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;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   TfdAlpha_US1 = 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
     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;
 
   TfdLuminance_US1 = 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
     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;
 
   TfdUniversal_US1 = 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;
 
   TfdDepth_US1 = 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;
 
   TfdDepth_US1 = 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;
 
   TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //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;
   end;
 
   TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //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;
 
   TfdRGB_US3 = 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;
   end;
 
   TfdRGB_US3 = 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;
 
   TfdBGR_US3 = 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;
   end;
 
   TfdBGR_US3 = 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;
 
   TfdRGBA_US4 = class(TfdRGB_US3) //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;
   end;
 
   TfdRGBA_US4 = class(TfdRGB_US3) //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;
+
+  TfdARGB_US4 = class(TfdRGB_US3) //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;

   end;
 
   TfdBGRA_US4 = class(TfdBGR_US3) //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;
   end;
 
   TfdBGRA_US4 = class(TfdBGR_US3) //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;
+
+  TfdABGR_US4 = class(TfdBGR_US3) //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;

   end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   TfdUniversal_UI1 = 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;
   end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   TfdUniversal_UI1 = 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
     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;
 
   TfdDepth_UI1 = 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;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -1457,10 +1464,6 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdAlpha12 = class(TfdAlpha_US1)
-    constructor Create; override;
-  end;
-

   TfdAlpha16 = class(TfdAlpha_US1)
     constructor Create; override;
   end;
   TfdAlpha16 = class(TfdAlpha_US1)
     constructor Create; override;
   end;


@@ -1473,10 +1476,6 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdLuminance12 = class(TfdLuminance_US1)
-    constructor Create; override;
-  end;
-

   TfdLuminance16 = class(TfdLuminance_US1)
     constructor Create; override;
   end;
   TfdLuminance16 = class(TfdLuminance_US1)
     constructor Create; override;
   end;


@@ -1497,19 +1496,20 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdLuminance12Alpha12 = class(TfdLuminanceAlpha_US2)
+  TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2)
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdR3G3B2 = class(TfdUniversal_UB1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdR3G3B2 = class(TfdUniversal_UB1)
+  TfdRGBX4 = class(TfdUniversal_US1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGB4 = class(TfdUniversal_US1)
+  TfdXRGB4 = class(TfdUniversal_US1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1517,7 +1517,11 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGB5 = class(TfdUniversal_US1)
+  TfdRGB5X1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdX1RGB5 = class(TfdUniversal_US1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1525,19 +1529,23 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGB10 = class(TfdUniversal_UI1)
+  TfdRGBX8 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGB12 = class(TfdRGB_US3)
+  TfdXRGB8 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGB16 = class(TfdRGB_US3)
+  TfdRGB10X2 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGBA2 = class(TfdRGBA_UB4)
+  TfdX2RGB10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGB16 = class(TfdRGB_US3)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1545,11 +1553,23 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

+  TfdARGB4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+

   TfdRGB5A1 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 
   TfdRGB5A1 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 

-  TfdRGBA8 = class(TfdRGBA_UB4)
+  TfdA1RGB5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGBA8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdARGB8 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1557,15 +1577,20 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGBA12 = class(TfdRGBA_US4)
+  TfdA2RGB10 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdRGBA16 = class(TfdRGBA_US4)
+  TfdRGBA16 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdBGR4 = class(TfdUniversal_US1)
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdBGRX4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdXBGR4 = class(TfdUniversal_US1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1573,7 +1598,11 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdBGR5 = class(TfdUniversal_US1)
+  TfdBGR5X1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdX1BGR5 = class(TfdUniversal_US1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1581,19 +1610,23 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdBGR10 = class(TfdUniversal_UI1)
+  TfdBGRX8 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdBGR12 = class(TfdBGR_US3)
+  TfdXBGR8 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdBGR16 = class(TfdBGR_US3)
+  TfdBGR10X2 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdBGRA2 = class(TfdBGRA_UB4)
+  TfdX2BGR10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGR16 = class(TfdBGR_US3)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1601,11 +1634,23 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

+  TfdABGR4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+

   TfdBGR5A1 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 
   TfdBGR5A1 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 

-  TfdBGRA8 = class(TfdBGRA_UB4)
+  TfdA1BGR5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGRA8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdABGR8 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1613,7 +1658,7 @@ type
     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 

-  TfdBGRA12 = class(TfdBGRA_US4)
+  TfdA2BGR10 = class(TfdUniversal_UI1)

     constructor Create; override;
   end;
 
     constructor Create; override;
   end;
 


@@ -1714,52 +1759,61 @@ const
 
     TfdAlpha4,
     TfdAlpha8,
 
     TfdAlpha4,
     TfdAlpha8,

-    TfdAlpha12,

     TfdAlpha16,
 
     TfdLuminance4,
     TfdLuminance8,
     TfdAlpha16,
 
     TfdLuminance4,
     TfdLuminance8,

-    TfdLuminance12,

     TfdLuminance16,
 
     TfdLuminance4Alpha4,
     TfdLuminance6Alpha2,
     TfdLuminance8Alpha8,
     TfdLuminance12Alpha4,
     TfdLuminance16,
 
     TfdLuminance4Alpha4,
     TfdLuminance6Alpha2,
     TfdLuminance8Alpha8,
     TfdLuminance12Alpha4,

-    TfdLuminance12Alpha12,

     TfdLuminance16Alpha16,
 
     TfdR3G3B2,
     TfdLuminance16Alpha16,
 
     TfdR3G3B2,

-    TfdRGB4,
+    TfdRGBX4,
+    TfdXRGB4,

     TfdR5G6B5,
     TfdR5G6B5,

-    TfdRGB5,
+    TfdRGB5X1,
+    TfdX1RGB5,

     TfdRGB8,
     TfdRGB8,

-    TfdRGB10,
-    TfdRGB12,
+    TfdRGBX8,
+    TfdXRGB8,
+    TfdRGB10X2,
+    TfdX2RGB10,

     TfdRGB16,
 
     TfdRGB16,
 

-    TfdRGBA2,

     TfdRGBA4,
     TfdRGBA4,

+    TfdARGB4,

     TfdRGB5A1,
     TfdRGB5A1,

+    TfdA1RGB5,

     TfdRGBA8,
     TfdRGBA8,

+    TfdARGB8,

     TfdRGB10A2,
     TfdRGB10A2,

-    TfdRGBA12,
+    TfdA2RGB10,

     TfdRGBA16,
 
     TfdRGBA16,
 

-    TfdBGR4,
+    TfdBGRX4,
+    TfdXBGR4,

     TfdB5G6R5,
     TfdB5G6R5,

-    TfdBGR5,
+    TfdBGR5X1,
+    TfdX1BGR5,

     TfdBGR8,
     TfdBGR8,

-    TfdBGR10,
-    TfdBGR12,
+    TfdBGRX8,
+    TfdXBGR8,
+    TfdBGR10X2,
+    TfdX2BGR10,

     TfdBGR16,
 
     TfdBGR16,
 

-    TfdBGRA2,

     TfdBGRA4,
     TfdBGRA4,

+    TfdABGR4,

     TfdBGR5A1,
     TfdBGR5A1,

+    TfdA1BGR5,

     TfdBGRA8,
     TfdBGRA8,

+    TfdABGR8,

     TfdBGR10A2,
     TfdBGR10A2,

-    TfdBGRA12,
+    TfdA2BGR10,

     TfdBGRA16,
 
     TfdDepth16,
     TfdBGRA16,
 
     TfdDepth16,


@@ -1844,15 +1898,15 @@ begin
         tfR3G3B2, tfLuminance8,
 
         //16bpp
         tfR3G3B2, tfLuminance8,
 
         //16bpp

-        tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4,
-        tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4,
+        tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
+        tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4,

 
         //24bpp
         tfBGR8, tfRGB8,
 
         //32bpp
 
         //24bpp
         tfBGR8, tfRGB8,
 
         //32bpp

-        tfRGB10, tfRGB10A2, tfRGBA8,
-        tfBGR10, tfBGR10A2, tfBGRA8]) then
+        tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8,
+        tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8]) then

     result := result + [ftBMP];
 
   if (aFormat in [
     result := result + [ftBMP];
 
   if (aFormat in [


@@ -1861,8 +1915,8 @@ begin
 
         //16 bpp
         tfLuminance16, tfLuminance8Alpha8,
 
         //16 bpp
         tfLuminance16, tfLuminance8Alpha8,

-        tfRGB5, tfRGB5A1, tfRGBA4,
-        tfBGR5, tfBGR5A1, tfBGRA4,
+        tfRGB5X1, tfX1RGB5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
+        tfBGR5X1, tfX1BGR5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4,

 
         //24 bpp
         tfRGB8, tfBGR8,
 
         //24 bpp
         tfRGB8, tfBGR8,


@@ -1874,12 +1928,12 @@ begin
   if (aFormat in [
         //8 bpp
         tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2,
   if (aFormat in [
         //8 bpp
         tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2,

-        tfR3G3B2, tfRGBA2, tfBGRA2,
+        tfR3G3B2,

 
         //16 bpp
         tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4,
 
         //16 bpp
         tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4,

-        tfRGB4, tfR5G6B5, tfRGB5, tfRGBA4, tfRGB5A1,
-        tfBGR4, tfB5G6R5, tfBGR5, tfBGRA4, tfBGR5A1,
+        tfRGBX4, tfXRGB4, tfR5G6B5, tfRGB5X1, tfX1RGB5, tfRGBA4, tfARGB4, tfRGB5A1, tfA1RGB5,
+        tfBGRX4, tfXBGR4, tfB5G6R5, tfBGR5X1, tfX1BGR5, tfBGRA4, tfABGR4, tfBGR5A1, tfA1BGR5,

 
         //24 bpp
         tfRGB8, tfBGR8,
 
         //24 bpp
         tfRGB8, tfBGR8,


@@ -2374,6 +2428,36 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+function TFormatDescriptor.GetRGBInverted: TglBitmapFormat;
+begin
+  result := fRGBInverted;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetWithAlpha: TglBitmapFormat;
+begin
+  result := fWithAlpha;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetWithoutAlpha: TglBitmapFormat;
+begin
+  result := fWithoutAlpha;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetOpenGLFormat: TglBitmapFormat;
+begin
+  result := fOpenGLFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetUncompressed: TglBitmapFormat;
+begin
+  result := fUncompressed;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 function TFormatDescriptor.GetglFormat: GLenum;
 begin
   result := fglFormat;
 function TFormatDescriptor.GetglFormat: GLenum;
 begin
   result := fglFormat;


@@ -2476,8 +2560,10 @@ begin
   fFormat       := tfEmpty;
   fWithAlpha    := tfEmpty;
   fWithoutAlpha := tfEmpty;
   fFormat       := tfEmpty;
   fWithAlpha    := tfEmpty;
   fWithoutAlpha := tfEmpty;

+  fOpenGLFormat := tfEmpty;

   fRGBInverted  := tfEmpty;
   fUncompressed := tfEmpty;
   fRGBInverted  := tfEmpty;
   fUncompressed := tfEmpty;

+

   fPixelSize    := 0.0;
   fIsCompressed := false;
 
   fPixelSize    := 0.0;
   fIsCompressed := false;
 


@@ -2507,15 +2593,6 @@ begin
   inc(aData);
 end;
 
   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////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2534,17 +2611,6 @@ begin
   inc(aData);
 end;
 
   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////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2568,12 +2634,6 @@ begin
   inc(aData);
 end;
 
   inc(aData);
 end;
 

-constructor TfdUniversal_UB1.Create;
-begin
-  inherited Create;
-  fPixelSize := 1.0;
-end;
-

 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2591,145 +2651,54 @@ begin
   inc(aData);
 end;
 
   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);
 begin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdRGB_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdRGB_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin

-  aData^ := aPixel.Data.r;
+  aData^ := aPixel.Data.b;

   inc(aData);
   aData^ := aPixel.Data.g;
   inc(aData);
   inc(aData);
   aData^ := aPixel.Data.g;
   inc(aData);

-  aData^ := aPixel.Data.b;
+  aData^ := aPixel.Data.r;

   inc(aData);
 end;
 
 procedure TfdRGB_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
   inc(aData);
 end;
 
 procedure TfdRGB_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin

-  aPixel.Data.r := aData^;
+  aPixel.Data.b := aData^;

   inc(aData);
   aPixel.Data.g := aData^;
   inc(aData);
   inc(aData);
   aPixel.Data.g := aData^;
   inc(aData);

-  aPixel.Data.b := aData^;
+  aPixel.Data.r := aData^;

   inc(aData);
   aPixel.Data.a := 0;
 end;
 
   inc(aData);
   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);
 begin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdBGR_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdBGR_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin

-  aData^ := aPixel.Data.b;
+  aData^ := aPixel.Data.r;

   inc(aData);
   aData^ := aPixel.Data.g;
   inc(aData);
   inc(aData);
   aData^ := aPixel.Data.g;
   inc(aData);

-  aData^ := aPixel.Data.r;
+  aData^ := aPixel.Data.b;

   inc(aData);
 end;
 
 procedure TfdBGR_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
   inc(aData);
 end;
 
 procedure TfdBGR_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin

-  aPixel.Data.b := aData^;
+  aPixel.Data.r := aData^;

   inc(aData);
   aPixel.Data.g := aData^;
   inc(aData);
   inc(aData);
   aPixel.Data.g := aData^;
   inc(aData);

-  aPixel.Data.r := aData^;
+  aPixel.Data.b := aData^;

   inc(aData);
   aPixel.Data.a := 0;
 end;
 
   inc(aData);
   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/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBA_UB4.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);
-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/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRA_UB4.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);
-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////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdAlpha_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2748,15 +2717,6 @@ begin
   inc(aData, 2);
 end;
 
   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////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2775,17 +2735,6 @@ begin
   inc(aData, 2);
 end;
 
   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////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2809,12 +2758,6 @@ begin
   inc(aData, 2);
 end;
 
   inc(aData, 2);
 end;
 

-constructor TfdUniversal_US1.Create;
-begin
-  inherited Create;
-  fPixelSize := 2.0;
-end;
-

 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2829,21 +2772,10 @@ begin
   aPixel.Data.r := PWord(aData)^;
   aPixel.Data.g := PWord(aData)^;
   aPixel.Data.b := PWord(aData)^;
   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;
 
   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///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2861,117 +2793,86 @@ begin
   inc(aData, 2);
 end;
 
   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);
 begin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdRGB_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdRGB_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin

-  PWord(aData)^ := aPixel.Data.r;
+  PWord(aData)^ := aPixel.Data.b;

   inc(aData, 2);
   PWord(aData)^ := aPixel.Data.g;
   inc(aData, 2);
   inc(aData, 2);
   PWord(aData)^ := aPixel.Data.g;
   inc(aData, 2);

-  PWord(aData)^ := aPixel.Data.b;
+  PWord(aData)^ := aPixel.Data.r;

   inc(aData, 2);
 end;
 
 procedure TfdRGB_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
   inc(aData, 2);
 end;
 
 procedure TfdRGB_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin

-  aPixel.Data.r := PWord(aData)^;
+  aPixel.Data.b := PWord(aData)^;

   inc(aData, 2);
   aPixel.Data.g := PWord(aData)^;
   inc(aData, 2);
   inc(aData, 2);
   aPixel.Data.g := PWord(aData)^;
   inc(aData, 2);

-  aPixel.Data.b := PWord(aData)^;
+  aPixel.Data.r := PWord(aData)^;

   inc(aData, 2);
   aPixel.Data.a := 0;
 end;
 
   inc(aData, 2);
   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);
 begin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdBGR_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdBGR_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin

-  PWord(aData)^ := aPixel.Data.b;
+  PWord(aData)^ := aPixel.Data.r;

   inc(aData, 2);
   PWord(aData)^ := aPixel.Data.g;
   inc(aData, 2);
   inc(aData, 2);
   PWord(aData)^ := aPixel.Data.g;
   inc(aData, 2);

-  PWord(aData)^ := aPixel.Data.r;
+  PWord(aData)^ := aPixel.Data.b;

   inc(aData, 2);
 end;
 
 procedure TfdBGR_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
   inc(aData, 2);
 end;
 
 procedure TfdBGR_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin

-  aPixel.Data.b := PWord(aData)^;
+  aPixel.Data.r := PWord(aData)^;

   inc(aData, 2);
   aPixel.Data.g := PWord(aData)^;
   inc(aData, 2);
   inc(aData, 2);
   aPixel.Data.g := PWord(aData)^;
   inc(aData, 2);

-  aPixel.Data.r := PWord(aData)^;
+  aPixel.Data.b := PWord(aData)^;

   inc(aData, 2);
   aPixel.Data.a := 0;
 end;
 
   inc(aData, 2);
   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);
 begin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdRGBA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin

-  inherited Map(aPixel, aData, aMapData);

   PWord(aData)^ := aPixel.Data.a;
   inc(aData, 2);
   PWord(aData)^ := aPixel.Data.a;
   inc(aData, 2);

+  inherited Map(aPixel, aData, aMapData);

 end;
 
 procedure TfdRGBA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
 end;
 
 procedure TfdRGBA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin

-  inherited Unmap(aData, aPixel, aMapData);

   aPixel.Data.a := PWord(aData)^;
   inc(aData, 2);
   aPixel.Data.a := PWord(aData)^;
   inc(aData, 2);

+  inherited Unmap(aData, aPixel, aMapData);

 end;
 
 end;
 

-constructor TfdRGBA_US4.Create;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdARGB_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdARGB_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);

 begin
 begin

-  inherited Create;
-  fPixelSize        :=   8.0;
-  fRange.a          := $FFFF;
-  fShift.a          :=    48;
-  fglFormat         := GL_RGBA;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
+  inherited Map(aPixel, aData, aMapData);
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+end;
+
+procedure TfdARGB_US4.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;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -2979,26 +2880,33 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdBGRA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TfdBGRA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin

-  inherited Map(aPixel, aData, aMapData);

   PWord(aData)^ := aPixel.Data.a;
   inc(aData, 2);
   PWord(aData)^ := aPixel.Data.a;
   inc(aData, 2);

+  inherited Map(aPixel, aData, aMapData);

 end;
 
 procedure TfdBGRA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
 end;
 
 procedure TfdBGRA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin

-  inherited Unmap(aData, aPixel, aMapData);

   aPixel.Data.a := PWord(aData)^;
   inc(aData, 2);
   aPixel.Data.a := PWord(aData)^;
   inc(aData, 2);

+  inherited Unmap(aData, aPixel, aMapData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdABGR_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdABGR_US4.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;
 
 end;
 

-constructor TfdBGRA_US4.Create;
+procedure TfdABGR_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);

 begin
 begin

-  inherited Create;
-  fPixelSize        :=   8.0;
-  fRange.a          := $FFFF;
-  fShift.a          :=    48;
-  fglFormat         := GL_BGRA;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);

 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -3024,12 +2932,6 @@ begin
   inc(aData, 2);
 end;
 
   inc(aData, 2);
 end;
 

-constructor TfdUniversal_UI1.Create;
-begin
-  inherited Create;
-  fPixelSize := 4.0;
-end;
-

 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -3048,287 +2950,482 @@ begin
   inc(aData, 4);
 end;
 
   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;
 begin
   inherited Create;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdAlpha4.Create;
 begin
   inherited Create;

+  fPixelSize        := 1.0;

   fFormat           := tfAlpha4;
   fWithAlpha        := tfAlpha4;
   fFormat           := tfAlpha4;
   fWithAlpha        := tfAlpha4;

+  fOpenGLFormat     := tfAlpha4;
+  fRange.a          := $FF;
+  fglFormat         := GL_ALPHA;

   fglInternalFormat := GL_ALPHA4;
   fglInternalFormat := GL_ALPHA4;

+  fglDataFormat     := GL_UNSIGNED_BYTE;

 end;
 
 constructor TfdAlpha8.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdAlpha8.Create;
 begin
   inherited Create;

+  fPixelSize        := 1.0;

   fFormat           := tfAlpha8;
   fWithAlpha        := tfAlpha8;
   fFormat           := tfAlpha8;
   fWithAlpha        := tfAlpha8;

+  fOpenGLFormat     := tfAlpha8;
+  fRange.a          := $FF;
+  fglFormat         := GL_ALPHA;

   fglInternalFormat := GL_ALPHA8;
   fglInternalFormat := GL_ALPHA8;

-end;
-
-constructor TfdAlpha12.Create;
-begin
-  inherited Create;
-  fFormat           := tfAlpha12;
-  fWithAlpha        := tfAlpha12;
-  fglInternalFormat := GL_ALPHA12;
+  fglDataFormat     := GL_UNSIGNED_BYTE;

 end;
 
 constructor TfdAlpha16.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdAlpha16.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfAlpha16;
   fWithAlpha        := tfAlpha16;
   fFormat           := tfAlpha16;
   fWithAlpha        := tfAlpha16;

+  fOpenGLFormat     := tfAlpha16;
+  fRange.a          := $FFFF;
+  fglFormat         := GL_ALPHA;

   fglInternalFormat := GL_ALPHA16;
   fglInternalFormat := GL_ALPHA16;

+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 constructor TfdLuminance4.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance4.Create;
 begin
   inherited Create;

+  fPixelSize        := 1.0;

   fFormat           := tfLuminance4;
   fWithAlpha        := tfLuminance4Alpha4;
   fWithoutAlpha     := tfLuminance4;
   fFormat           := tfLuminance4;
   fWithAlpha        := tfLuminance4Alpha4;
   fWithoutAlpha     := tfLuminance4;

+  fOpenGLFormat     := tfLuminance4;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fglFormat         := GL_LUMINANCE;

   fglInternalFormat := GL_LUMINANCE4;
   fglInternalFormat := GL_LUMINANCE4;

+  fglDataFormat     := GL_UNSIGNED_BYTE;

 end;
 
 constructor TfdLuminance8.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance8.Create;
 begin
   inherited Create;

+  fPixelSize        := 1.0;

   fFormat           := tfLuminance8;
   fWithAlpha        := tfLuminance8Alpha8;
   fWithoutAlpha     := tfLuminance8;
   fFormat           := tfLuminance8;
   fWithAlpha        := tfLuminance8Alpha8;
   fWithoutAlpha     := tfLuminance8;

+  fOpenGLFormat     := tfLuminance8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fglFormat         := GL_LUMINANCE;

   fglInternalFormat := GL_LUMINANCE8;
   fglInternalFormat := GL_LUMINANCE8;

-end;
-
-constructor TfdLuminance12.Create;
-begin
-  inherited Create;
-  fFormat           := tfLuminance12;
-  fWithAlpha        := tfLuminance12Alpha12;
-  fWithoutAlpha     := tfLuminance12;
-  fglInternalFormat := GL_LUMINANCE12;
+  fglDataFormat     := GL_UNSIGNED_BYTE;

 end;
 
 constructor TfdLuminance16.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance16.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfLuminance16;
   fWithAlpha        := tfLuminance16Alpha16;
   fWithoutAlpha     := tfLuminance16;
   fFormat           := tfLuminance16;
   fWithAlpha        := tfLuminance16Alpha16;
   fWithoutAlpha     := tfLuminance16;

+  fOpenGLFormat     := tfLuminance16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fglFormat         := GL_LUMINANCE;

   fglInternalFormat := GL_LUMINANCE16;
   fglInternalFormat := GL_LUMINANCE16;

+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 constructor TfdLuminance4Alpha4.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance4Alpha4.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfLuminance4Alpha4;
   fWithAlpha        := tfLuminance4Alpha4;
   fWithoutAlpha     := tfLuminance4;
   fFormat           := tfLuminance4Alpha4;
   fWithAlpha        := tfLuminance4Alpha4;
   fWithoutAlpha     := tfLuminance4;

+  fOpenGLFormat     := tfLuminance4Alpha4;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 8;
+  fglFormat         := GL_LUMINANCE_ALPHA;

   fglInternalFormat := GL_LUMINANCE4_ALPHA4;
   fglInternalFormat := GL_LUMINANCE4_ALPHA4;

+  fglDataFormat     := GL_UNSIGNED_BYTE;

 end;
 
 constructor TfdLuminance6Alpha2.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance6Alpha2.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfLuminance6Alpha2;
   fWithAlpha        := tfLuminance6Alpha2;
   fWithoutAlpha     := tfLuminance8;
   fFormat           := tfLuminance6Alpha2;
   fWithAlpha        := tfLuminance6Alpha2;
   fWithoutAlpha     := tfLuminance8;

+  fOpenGLFormat     := tfLuminance6Alpha2;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 8;
+  fglFormat         := GL_LUMINANCE_ALPHA;

   fglInternalFormat := GL_LUMINANCE6_ALPHA2;
   fglInternalFormat := GL_LUMINANCE6_ALPHA2;

+  fglDataFormat     := GL_UNSIGNED_BYTE;

 end;
 
 constructor TfdLuminance8Alpha8.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance8Alpha8.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfLuminance8Alpha8;
   fWithAlpha        := tfLuminance8Alpha8;
   fWithoutAlpha     := tfLuminance8;
   fFormat           := tfLuminance8Alpha8;
   fWithAlpha        := tfLuminance8Alpha8;
   fWithoutAlpha     := tfLuminance8;

+  fOpenGLFormat     := tfLuminance8Alpha8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 8;
+  fglFormat         := GL_LUMINANCE_ALPHA;

   fglInternalFormat := GL_LUMINANCE8_ALPHA8;
   fglInternalFormat := GL_LUMINANCE8_ALPHA8;

+  fglDataFormat     := GL_UNSIGNED_BYTE;

 end;
 
 constructor TfdLuminance12Alpha4.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance12Alpha4.Create;
 begin
   inherited Create;

+  fPixelSize        := 4.0;

   fFormat           := tfLuminance12Alpha4;
   fWithAlpha        := tfLuminance12Alpha4;
   fFormat           := tfLuminance12Alpha4;
   fWithAlpha        := tfLuminance12Alpha4;

-  fWithoutAlpha     := tfLuminance12;
+  fWithoutAlpha     := tfLuminance16;
+  fOpenGLFormat     := tfLuminance12Alpha4;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 16;
+  fglFormat         := GL_LUMINANCE_ALPHA;

   fglInternalFormat := GL_LUMINANCE12_ALPHA4;
   fglInternalFormat := GL_LUMINANCE12_ALPHA4;

-end;
-
-constructor TfdLuminance12Alpha12.Create;
-begin
-  inherited Create;
-  fFormat           := tfLuminance12Alpha12;
-  fWithAlpha        := tfLuminance12Alpha12;
-  fWithoutAlpha     := tfLuminance12;
-  fglInternalFormat := GL_LUMINANCE12_ALPHA12;
+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 constructor TfdLuminance16Alpha16.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdLuminance16Alpha16.Create;
 begin
   inherited Create;

+  fPixelSize        := 4.0;

   fFormat           := tfLuminance16Alpha16;
   fWithAlpha        := tfLuminance16Alpha16;
   fWithoutAlpha     := tfLuminance16;
   fFormat           := tfLuminance16Alpha16;
   fWithAlpha        := tfLuminance16Alpha16;
   fWithoutAlpha     := tfLuminance16;

+  fOpenGLFormat     := tfLuminance16Alpha16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 16;
+  fglFormat         := GL_LUMINANCE_ALPHA;

   fglInternalFormat := GL_LUMINANCE16_ALPHA16;
   fglInternalFormat := GL_LUMINANCE16_ALPHA16;

+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 constructor TfdR3G3B2.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdR3G3B2.Create;
 begin
   inherited Create;

+  fPixelSize        := 1.0;

   fFormat           := tfR3G3B2;
   fFormat           := tfR3G3B2;

-  fWithAlpha        := tfRGBA2;
+  fWithAlpha        := tfRGBA4;

   fWithoutAlpha     := tfR3G3B2;
   fWithoutAlpha     := tfR3G3B2;

-  fRange.r          := $7;
-  fRange.g          := $7;
-  fRange.b          := $3;
-  fShift.r          :=  0;
-  fShift.g          :=  3;
-  fShift.b          :=  6;
+  fOpenGLFormat     := tfR3G3B2;
+  fRGBInverted      := tfEmpty;
+  fRange.r          := $07;
+  fRange.g          := $07;
+  fRange.b          := $04;
+  fShift.r          := 5;
+  fShift.g          := 2;
+  fShift.b          := 0;

   fglFormat         := GL_RGB;
   fglInternalFormat := GL_R3_G3_B2;
   fglFormat         := GL_RGB;
   fglInternalFormat := GL_R3_G3_B2;

-  fglDataFormat     := GL_UNSIGNED_BYTE_2_3_3_REV;
+  fglDataFormat     := GL_UNSIGNED_BYTE_3_3_2;

 end;
 
 end;
 

-constructor TfdRGB4.Create;
+constructor TfdRGBX4.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfRGB4;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGBX4;

   fWithAlpha        := tfRGBA4;
   fWithAlpha        := tfRGBA4;

-  fWithoutAlpha     := tfRGB4;
-  fRGBInverted      := tfBGR4;
-  fRange.r          := $F;
-  fRange.g          := $F;
-  fRange.b          := $F;
-  fShift.r          :=  0;
-  fShift.g          :=  4;
-  fShift.b          :=  8;
+  fWithoutAlpha     := tfRGBX4;
+  fOpenGLFormat     := tfRGBX4;
+  fRGBInverted      := tfBGRX4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $00;
+  fShift.r          := 12;
+  fShift.g          :=  8;
+  fShift.b          :=  4;

   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
   fglInternalFormat := GL_RGB4;
   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;
+
+constructor TfdXRGB4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfXRGB4;
+  fWithAlpha        := tfARGB4;
+  fWithoutAlpha     := tfXRGB4;
+  fOpenGLFormat     := tfXRGB4;
+  fRGBInverted      := tfXBGR4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fShift.r          := 8;
+  fShift.g          := 4;
+  fShift.b          := 0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB4;

   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
 
 constructor TfdR5G6B5.Create;
 begin
   inherited Create;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
 
 constructor TfdR5G6B5.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfR5G6B5;
   fFormat           := tfR5G6B5;

-  fWithAlpha        := tfRGBA4;
+  fWithAlpha        := tfRGB5A1;

   fWithoutAlpha     := tfR5G6B5;
   fWithoutAlpha     := tfR5G6B5;

+  fOpenGLFormat     := tfR5G6B5;

   fRGBInverted      := tfB5G6R5;
   fRange.r          := $1F;
   fRange.g          := $3F;
   fRange.b          := $1F;
   fRGBInverted      := tfB5G6R5;
   fRange.r          := $1F;
   fRange.g          := $3F;
   fRange.b          := $1F;

-  fShift.r          :=   0;
-  fShift.g          :=   5;
-  fShift.b          :=  11;
+  fShift.r          := 11;
+  fShift.g          := 5;
+  fShift.b          := 0;

   fglFormat         := GL_RGB;
   fglInternalFormat := GL_RGB565;
   fglFormat         := GL_RGB;
   fglInternalFormat := GL_RGB565;

-  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5_REV;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5;

 end;
 
 end;
 

-constructor TfdRGB5.Create;
+constructor TfdRGB5X1.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfRGB5;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGB5X1;

   fWithAlpha        := tfRGB5A1;
   fWithAlpha        := tfRGB5A1;

-  fWithoutAlpha     := tfRGB5;
-  fRGBInverted      := tfBGR5;
+  fWithoutAlpha     := tfRGB5X1;
+  fOpenGLFormat     := tfRGB5X1;
+  fRGBInverted      := tfBGR5X1;

   fRange.r          := $1F;
   fRange.g          := $1F;
   fRange.b          := $1F;
   fRange.r          := $1F;
   fRange.g          := $1F;
   fRange.b          := $1F;

-  fShift.r          :=   0;
-  fShift.g          :=   5;
-  fShift.b          :=  10;
+  fShift.r          := 11;
+  fShift.g          :=  6;
+  fShift.b          :=  1;

   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
   fglInternalFormat := GL_RGB5;
   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;
+
+constructor TfdX1RGB5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfX1RGB5;
+  fWithAlpha        := tfA1RGB5;
+  fWithoutAlpha     := tfX1RGB5;
+  fOpenGLFormat     := tfX1RGB5;
+  fRGBInverted      := tfX1BGR5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fShift.r          := 10;
+  fShift.g          :=  5;
+  fShift.b          :=  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;
 begin
   inherited Create;
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
 constructor TfdRGB8.Create;
 begin
   inherited Create;

+  fPixelSize        := 3.0;

   fFormat           := tfRGB8;
   fWithAlpha        := tfRGBA8;
   fWithoutAlpha     := tfRGB8;
   fFormat           := tfRGB8;
   fWithAlpha        := tfRGBA8;
   fWithoutAlpha     := tfRGB8;

+  fOpenGLFormat     := tfRGB8;

   fRGBInverted      := tfBGR8;
   fRGBInverted      := tfBGR8;

+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          := 16;
+  fShift.g          :=  8;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGR;    // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB8;   // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdRGBX8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfRGBX8;
+  fWithAlpha        := tfRGBA8;
+  fWithoutAlpha     := tfRGBX8;
+  fOpenGLFormat     := tfRGB8;
+  fRGBInverted      := tfBGRX8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          := 24;
+  fShift.g          := 16;
+  fShift.b          := 8;
+  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;
+
+constructor TfdXRGB8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfXRGB8;
+  fWithAlpha        := tfXRGB8;
+  fWithoutAlpha     := tfXRGB8;
+  fOpenGLFormat     := tfRGB8;
+  fRGBInverted      := tfXBGR8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          := 16;
+  fShift.g          :=  8;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA

   fglInternalFormat := GL_RGB8;
   fglInternalFormat := GL_RGB8;

+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;

 end;
 
 end;
 

-constructor TfdRGB10.Create;
+constructor TfdRGB10X2.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfRGB10;
+  fPixelSize        := 3.0;
+  fFormat           := tfRGB10X2;

   fWithAlpha        := tfRGB10A2;
   fWithAlpha        := tfRGB10A2;

-  fWithoutAlpha     := tfRGB10;
-  fRGBInverted      := tfBGR10;
-  fRange.r          := $3FF;
-  fRange.g          := $3FF;
-  fRange.b          := $3FF;
-  fShift.r          :=    0;
-  fShift.g          :=   10;
-  fShift.b          :=   20;
+  fWithoutAlpha     := tfRGB10X2;
+  fOpenGLFormat     := tfRGB10X2;
+  fRGBInverted      := tfBGR10X2;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          := 22;
+  fShift.g          := 12;
+  fShift.b          :=  2;

   fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
   fglInternalFormat := GL_RGB10;
   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;
 
 end;
 

-constructor TfdRGB12.Create;
+constructor TfdX2RGB10.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfRGB12;
-  fWithAlpha        := tfRGBA12;
-  fWithoutAlpha     := tfRGB12;
-  fRGBInverted      := tfBGR12;
-  fglInternalFormat := GL_RGB12;
+  fPixelSize        := 3.0;
+  fFormat           := tfX2RGB10;
+  fWithAlpha        := tfA2RGB10;
+  fWithoutAlpha     := tfX2RGB10;
+  fOpenGLFormat     := tfX2RGB10;
+  fRGBInverted      := tfX2BGR10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          := 20;
+  fShift.g          := 10;
+  fShift.b          :=  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;
 begin
   inherited Create;
 end;
 
 constructor TfdRGB16.Create;
 begin
   inherited Create;

+  fPixelSize        := 6.0;

   fFormat           := tfRGB16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;
   fFormat           := tfRGB16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;

+  fOpenGLFormat     := tfRGB16;

   fRGBInverted      := tfBGR16;
   fRGBInverted      := tfBGR16;

-  fglInternalFormat := GL_RGB16;
-end;
-
-constructor TfdRGBA2.Create;
-begin
-  inherited Create;
-  fFormat           := tfRGBA2;
-  fWithAlpha        := tfRGBA2;
-  fWithoutAlpha     := tfR3G3B2;
-  fRGBInverted      := tfBGRA2;
-  fglInternalFormat := GL_RGBA2;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fShift.r          := 32;
+  fShift.g          := 16;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGR;     // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB16;   // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 constructor TfdRGBA4.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdRGBA4.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfRGBA4;
   fWithAlpha        := tfRGBA4;
   fFormat           := tfRGBA4;
   fWithAlpha        := tfRGBA4;

-  fWithoutAlpha     := tfRGB4;
+  fWithoutAlpha     := tfRGBX4;
+  fOpenGLFormat     := tfRGBA4;

   fRGBInverted      := tfBGRA4;
   fRGBInverted      := tfBGRA4;

-  fRange.r          := $F;
-  fRange.g          := $F;
-  fRange.b          := $F;
-  fRange.a          := $F;
-  fShift.r          :=  0;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          := 12;
+  fShift.g          :=  8;
+  fShift.b          :=  4;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGBA4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
+end;
+
+constructor TfdARGB4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfARGB4;
+  fWithAlpha        := tfARGB4;
+  fWithoutAlpha     := tfXRGB4;
+  fOpenGLFormat     := tfARGB4;
+  fRGBInverted      := tfABGR4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          :=  8;

   fShift.g          :=  4;
   fShift.g          :=  4;

-  fShift.b          :=  8;
+  fShift.b          :=  0;

   fShift.a          := 12;
   fShift.a          := 12;

-  fglFormat         := GL_RGBA;
+  fglFormat         := GL_BGRA;

   fglInternalFormat := GL_RGBA4;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
   fglInternalFormat := GL_RGBA4;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;


@@ -3336,132 +3433,257 @@ end;
 constructor TfdRGB5A1.Create;
 begin
   inherited Create;
 constructor TfdRGB5A1.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfRGB5A1;
   fWithAlpha        := tfRGB5A1;
   fFormat           := tfRGB5A1;
   fWithAlpha        := tfRGB5A1;

-  fWithoutAlpha     := tfRGB5;
+  fWithoutAlpha     := tfRGB5X1;
+  fOpenGLFormat     := tfRGB5A1;

   fRGBInverted      := tfBGR5A1;
   fRange.r          := $1F;
   fRange.g          := $1F;
   fRange.b          := $1F;
   fRange.a          := $01;
   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;
+  fShift.r          := 11;
+  fShift.g          :=  6;
+  fShift.b          :=  1;
+  fShift.a          :=  0;

   fglFormat         := GL_RGBA;
   fglInternalFormat := GL_RGB5_A1;
   fglFormat         := GL_RGBA;
   fglInternalFormat := GL_RGB5_A1;

+  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+constructor TfdA1RGB5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfA1RGB5;
+  fWithAlpha        := tfA1RGB5;
+  fWithoutAlpha     := tfX1RGB5;
+  fOpenGLFormat     := tfA1RGB5;
+  fRGBInverted      := tfA1BGR5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fRange.a          := $01;
+  fShift.r          := 10;
+  fShift.g          :=  5;
+  fShift.b          :=  0;
+  fShift.a          := 15;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB5_A1;

   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
 constructor TfdRGBA8.Create;
 begin
   inherited Create;
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
 constructor TfdRGBA8.Create;
 begin
   inherited Create;

+  fPixelSize        := 4.0;

   fFormat           := tfRGBA8;
   fWithAlpha        := tfRGBA8;
   fWithoutAlpha     := tfRGB8;
   fFormat           := tfRGBA8;
   fWithAlpha        := tfRGBA8;
   fWithoutAlpha     := tfRGB8;

+  fOpenGLFormat     := tfRGBA8;

   fRGBInverted      := tfBGRA8;
   fRGBInverted      := tfBGRA8;

+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 24;
+  fShift.g          := 16;
+  fShift.b          :=  8;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGBA8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
+end;
+
+constructor TfdARGB8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfARGB8;
+  fWithAlpha        := tfARGB8;
+  fWithoutAlpha     := tfRGB8;
+  fOpenGLFormat     := tfARGB8;
+  fRGBInverted      := tfABGR8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 16;
+  fShift.g          :=  8;
+  fShift.b          :=  0;
+  fShift.a          := 24;
+  fglFormat         := GL_BGRA;

   fglInternalFormat := GL_RGBA8;
   fglInternalFormat := GL_RGBA8;

+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;

 end;
 
 constructor TfdRGB10A2.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdRGB10A2.Create;
 begin
   inherited Create;

+  fPixelSize        := 3.0;

   fFormat           := tfRGB10A2;
   fWithAlpha        := tfRGB10A2;
   fFormat           := tfRGB10A2;
   fWithAlpha        := tfRGB10A2;

-  fWithoutAlpha     := tfRGB10;
+  fWithoutAlpha     := tfRGB10X2;
+  fOpenGLFormat     := tfRGB10A2;

   fRGBInverted      := tfBGR10A2;
   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;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          := 22;
+  fShift.g          := 12;
+  fShift.b          :=  2;
+  fShift.a          :=  0;

   fglFormat         := GL_RGBA;
   fglInternalFormat := GL_RGB10_A2;
   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;
 
 end;
 

-constructor TfdRGBA12.Create;
+constructor TfdA2RGB10.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfRGBA12;
-  fWithAlpha        := tfRGBA12;
-  fWithoutAlpha     := tfRGB12;
-  fRGBInverted      := tfBGRA12;
-  fglInternalFormat := GL_RGBA12;
+  fPixelSize        := 3.0;
+  fFormat           := tfA2RGB10;
+  fWithAlpha        := tfA2RGB10;
+  fWithoutAlpha     := tfX2RGB10;
+  fOpenGLFormat     := tfA2RGB10;
+  fRGBInverted      := tfA2BGR10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          := 20;
+  fShift.g          := 10;
+  fShift.b          :=  0;
+  fShift.a          := 30;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB10_A2;
+  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;

 end;
 
 constructor TfdRGBA16.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdRGBA16.Create;
 begin
   inherited Create;

+  fPixelSize        := 8.0;

   fFormat           := tfRGBA16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;
   fFormat           := tfRGBA16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;

+  fOpenGLFormat     := tfRGBA16;

   fRGBInverted      := tfBGRA16;
   fRGBInverted      := tfBGRA16;

-  fglInternalFormat := GL_RGBA16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 48;
+  fShift.g          := 32;
+  fShift.b          := 16;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;     // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGBA16;   // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 end;
 

-constructor TfdBGR4.Create;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TfdBGRX4.Create;

 begin
   inherited Create;
   fPixelSize        := 2.0;
 begin
   inherited Create;
   fPixelSize        := 2.0;

-  fFormat           := tfBGR4;
+  fFormat           := tfBGRX4;

   fWithAlpha        := tfBGRA4;
   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
+  fWithoutAlpha     := tfBGRX4;
+  fOpenGLFormat     := tfBGRX4;
+  fRGBInverted      := tfRGBX4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fShift.r          :=  4;
+  fShift.g          :=  8;
+  fShift.b          := 12;
+  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;
+
+constructor TfdXBGR4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfXBGR4;
+  fWithAlpha        := tfABGR4;
+  fWithoutAlpha     := tfXBGR4;
+  fOpenGLFormat     := tfXBGR4;
+  fRGBInverted      := tfXRGB4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          := 0;
+  fShift.g          := 4;
+  fShift.b          := 8;
+  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;
 
   fglInternalFormat := GL_RGB4;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
 

-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 constructor TfdB5G6R5.Create;
 begin
   inherited Create;
 constructor TfdB5G6R5.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfB5G6R5;
   fFormat           := tfB5G6R5;

-  fWithAlpha        := tfBGRA4;
+  fWithAlpha        := tfBGR5A1;

   fWithoutAlpha     := tfB5G6R5;
   fWithoutAlpha     := tfB5G6R5;

+  fOpenGLFormat     := tfB5G6R5;

   fRGBInverted      := tfR5G6B5;
   fRange.r          := $1F;
   fRange.g          := $3F;
   fRange.b          := $1F;
   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
-  fglInternalFormat := GL_RGB8;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5;
+  fShift.r          :=  0;
+  fShift.g          :=  5;
+  fShift.b          := 11;
+  fglFormat         := GL_RGB;
+  fglInternalFormat := GL_RGB565;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5_REV;

 end;
 
 end;
 

-constructor TfdBGR5.Create;
+constructor TfdBGR5X1.Create;

 begin
   inherited Create;
   fPixelSize        := 2.0;
 begin
   inherited Create;
   fPixelSize        := 2.0;

-  fFormat           := tfBGR5;
+  fFormat           := tfBGR5X1;

   fWithAlpha        := tfBGR5A1;
   fWithAlpha        := tfBGR5A1;

-  fWithoutAlpha     := tfBGR5;
-  fRGBInverted      := tfRGB5;
+  fWithoutAlpha     := tfBGR5X1;
+  fOpenGLFormat     := tfBGR5X1;
+  fRGBInverted      := tfRGB5X1;

   fRange.r          := $1F;
   fRange.g          := $1F;
   fRange.b          := $1F;
   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
+  fShift.r          :=  1;
+  fShift.g          :=  6;
+  fShift.b          := 11;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB5;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+constructor TfdX1BGR5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfX1BGR5;
+  fWithAlpha        := tfA1BGR5;
+  fWithoutAlpha     := tfX1BGR5;
+  fOpenGLFormat     := tfX1BGR5;
+  fRGBInverted      := tfX1RGB5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fShift.r          :=  0;
+  fShift.g          :=  5;
+  fShift.b          := 10;
+  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;
   fglInternalFormat := GL_RGB5;
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;


@@ -3469,79 +3691,163 @@ end;
 constructor TfdBGR8.Create;
 begin
   inherited Create;
 constructor TfdBGR8.Create;
 begin
   inherited Create;

+  fPixelSize        := 3.0;

   fFormat           := tfBGR8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;
   fFormat           := tfBGR8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;

+  fOpenGLFormat     := tfBGR8;

   fRGBInverted      := tfRGB8;
   fRGBInverted      := tfRGB8;

+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          :=  0;
+  fShift.g          :=  8;
+  fShift.b          := 16;
+  fglFormat         := GL_RGB;      // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB8;     // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdBGRX8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfBGRX8;
+  fWithAlpha        := tfBGRA8;
+  fWithoutAlpha     := tfBGRX8;
+  fOpenGLFormat     := tfBGRX8;
+  fRGBInverted      := tfRGBX8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          :=  8;
+  fShift.g          := 16;
+  fShift.b          := 24;
+  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 TfdXBGR8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfXBGR8;
+  fWithAlpha        := tfABGR8;
+  fWithoutAlpha     := tfXBGR8;
+  fOpenGLFormat     := tfXBGR8;
+  fRGBInverted      := tfXRGB8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          :=  0;
+  fShift.g          :=  8;
+  fShift.b          := 16;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA

   fglInternalFormat := GL_RGB8;
   fglInternalFormat := GL_RGB8;

+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;

 end;
 
 end;
 

-constructor TfdBGR10.Create;
+constructor TfdBGR10X2.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfBGR10;
+  fPixelSize        := 3.0;
+  fFormat           := tfBGR10X2;

   fWithAlpha        := tfBGR10A2;
   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;
+  fWithoutAlpha     := tfBGR10X2;
+  fOpenGLFormat     := tfBGR10X2;
+  fRGBInverted      := tfRGB10X2;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          :=  2;
+  fShift.g          := 12;
+  fShift.b          := 22;

   fglFormat         := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
   fglInternalFormat := GL_RGB10;
   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;
 
 end;
 

-constructor TfdBGR12.Create;
+constructor TfdX2BGR10.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfBGR12;
-  fWithAlpha        := tfBGRA12;
-  fWithoutAlpha     := tfBGR12;
-  fRGBInverted      := tfRGB12;
-  fglInternalFormat := GL_RGB12;
+  fPixelSize        := 3.0;
+  fFormat           := tfX2BGR10;
+  fWithAlpha        := tfA2BGR10;
+  fWithoutAlpha     := tfX2BGR10;
+  fOpenGLFormat     := tfX2BGR10;
+  fRGBInverted      := tfX2RGB10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          :=  0;
+  fShift.g          := 10;
+  fShift.b          := 20;
+  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;
 begin
   inherited Create;
 end;
 
 constructor TfdBGR16.Create;
 begin
   inherited Create;

+  fPixelSize        := 6.0;

   fFormat           := tfBGR16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;
   fFormat           := tfBGR16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;

+  fOpenGLFormat     := tfBGR16;

   fRGBInverted      := tfRGB16;
   fRGBInverted      := tfRGB16;

-  fglInternalFormat := GL_RGB16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fShift.r          :=  0;
+  fShift.g          := 16;
+  fShift.b          := 32;
+  fglFormat         := GL_RGB;      // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB16;    // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 end;
 

-constructor TfdBGRA2.Create;
+constructor TfdBGRA4.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfBGRA2;
+  fPixelSize        := 2.0;
+  fFormat           := tfBGRA4;

   fWithAlpha        := tfBGRA4;
   fWithAlpha        := tfBGRA4;

-  fWithoutAlpha     := tfBGR4;
-  fRGBInverted      := tfRGBA2;
-  fglInternalFormat := GL_RGBA2;
+  fWithoutAlpha     := tfBGRX4;
+  fOpenGLFormat     := tfBGRA4;
+  fRGBInverted      := tfRGBA4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          :=  4;
+  fShift.g          :=  8;
+  fShift.b          := 12;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGBA4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;

 end;
 
 end;
 

-constructor TfdBGRA4.Create;
+constructor TfdABGR4.Create;

 begin
   inherited Create;
 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;
+  fPixelSize        := 2.0;
+  fFormat           := tfABGR4;
+  fWithAlpha        := tfABGR4;
+  fWithoutAlpha     := tfXBGR4;
+  fOpenGLFormat     := tfABGR4;
+  fRGBInverted      := tfARGB4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          :=  0;

   fShift.g          :=  4;
   fShift.g          :=  4;

-  fShift.b          :=  0;
+  fShift.b          :=  8;

   fShift.a          := 12;
   fShift.a          := 12;

-  fglFormat         := GL_BGRA;
+  fglFormat         := GL_RGBA;

   fglInternalFormat := GL_RGBA4;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
   fglInternalFormat := GL_RGBA4;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;


@@ -3549,98 +3855,203 @@ end;
 constructor TfdBGR5A1.Create;
 begin
   inherited Create;
 constructor TfdBGR5A1.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfBGR5A1;
   fWithAlpha        := tfBGR5A1;
   fFormat           := tfBGR5A1;
   fWithAlpha        := tfBGR5A1;

-  fWithoutAlpha     := tfBGR5;
+  fWithoutAlpha     := tfBGR5X1;
+  fOpenGLFormat     := tfBGR5A1;

   fRGBInverted      := tfRGB5A1;
   fRange.r          := $1F;
   fRange.g          := $1F;
   fRange.b          := $1F;
   fRange.a          := $01;
   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;
+  fShift.r          :=  1;
+  fShift.g          :=  6;
+  fShift.b          := 11;
+  fShift.a          :=  0;

   fglFormat         := GL_BGRA;
   fglInternalFormat := GL_RGB5_A1;
   fglFormat         := GL_BGRA;
   fglInternalFormat := GL_RGB5_A1;

+  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+constructor TfdA1BGR5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfA1BGR5;
+  fWithAlpha        := tfA1BGR5;
+  fWithoutAlpha     := tfX1BGR5;
+  fOpenGLFormat     := tfA1BGR5;
+  fRGBInverted      := tfA1RGB5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fRange.a          := $01;
+  fShift.r          :=  0;
+  fShift.g          :=  5;
+  fShift.b          := 10;
+  fShift.a          := 15;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGB5_A1;

   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
 constructor TfdBGRA8.Create;
 begin
   inherited Create;
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
 constructor TfdBGRA8.Create;
 begin
   inherited Create;

+  fPixelSize        := 4.0;

   fFormat           := tfBGRA8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;
   fFormat           := tfBGRA8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;

+  fOpenGLFormat     := tfBGRA8;

   fRGBInverted      := tfRGBA8;
   fRGBInverted      := tfRGBA8;

+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          :=  8;
+  fShift.g          := 16;
+  fShift.b          := 24;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGBA8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
+end;
+
+constructor TfdABGR8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfABGR8;
+  fWithAlpha        := tfABGR8;
+  fWithoutAlpha     := tfBGR8;
+  fOpenGLFormat     := tfABGR8;
+  fRGBInverted      := tfARGB8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          :=  0;
+  fShift.g          :=  8;
+  fShift.b          := 16;
+  fShift.a          := 24;
+  fglFormat         := GL_RGBA;

   fglInternalFormat := GL_RGBA8;
   fglInternalFormat := GL_RGBA8;

+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;

 end;
 
 constructor TfdBGR10A2.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdBGR10A2.Create;
 begin
   inherited Create;

+  fPixelSize        := 3.0;

   fFormat           := tfBGR10A2;
   fWithAlpha        := tfBGR10A2;
   fFormat           := tfBGR10A2;
   fWithAlpha        := tfBGR10A2;

-  fWithoutAlpha     := tfBGR10;
+  fWithoutAlpha     := tfBGR10X2;
+  fOpenGLFormat     := tfBGR10A2;

   fRGBInverted      := tfRGB10A2;
   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;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          :=  2;
+  fShift.g          := 12;
+  fShift.b          := 22;
+  fShift.a          :=  0;

   fglFormat         := GL_BGRA;
   fglInternalFormat := GL_RGB10_A2;
   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;
 
 end;
 

-constructor TfdBGRA12.Create;
+constructor TfdA2BGR10.Create;

 begin
   inherited Create;
 begin
   inherited Create;

-  fFormat           := tfBGRA12;
-  fWithAlpha        := tfBGRA12;
-  fWithoutAlpha     := tfBGR12;
-  fRGBInverted      := tfRGBA12;
-  fglInternalFormat := GL_RGBA12;
+  fPixelSize        := 3.0;
+  fFormat           := tfA2BGR10;
+  fWithAlpha        := tfA2BGR10;
+  fWithoutAlpha     := tfX2BGR10;
+  fOpenGLFormat     := tfA2BGR10;
+  fRGBInverted      := tfA2RGB10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          :=  0;
+  fShift.g          := 10;
+  fShift.b          := 20;
+  fShift.a          := 30;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGB10_A2;
+  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;

 end;
 
 constructor TfdBGRA16.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdBGRA16.Create;
 begin
   inherited Create;

+  fPixelSize        := 8.0;

   fFormat           := tfBGRA16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;
   fFormat           := tfBGRA16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;

+  fOpenGLFormat     := tfBGRA16;

   fRGBInverted      := tfRGBA16;
   fRGBInverted      := tfRGBA16;

-  fglInternalFormat := GL_RGBA16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 16;
+  fShift.g          := 32;
+  fShift.b          := 48;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;      // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGBA16;    // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 constructor TfdDepth16.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdDepth16.Create;
 begin
   inherited Create;

+  fPixelSize        := 2.0;

   fFormat           := tfDepth16;
   fFormat           := tfDepth16;

-  fWithAlpha        := tfEmpty;

   fWithoutAlpha     := tfDepth16;
   fWithoutAlpha     := tfDepth16;

+  fOpenGLFormat     := tfDepth16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;

   fglInternalFormat := GL_DEPTH_COMPONENT16;
   fglInternalFormat := GL_DEPTH_COMPONENT16;

+  fglDataFormat     := GL_UNSIGNED_SHORT;

 end;
 
 constructor TfdDepth24.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdDepth24.Create;
 begin
   inherited Create;

+  fPixelSize        := 3.0;

   fFormat           := tfDepth24;
   fFormat           := tfDepth24;

-  fWithAlpha        := tfEmpty;

   fWithoutAlpha     := tfDepth24;
   fWithoutAlpha     := tfDepth24;

+  fOpenGLFormat     := tfDepth24;
+  fRange.r          := $FFFFFF;
+  fRange.g          := $FFFFFF;
+  fRange.b          := $FFFFFF;
+  fRange.a          := $FFFFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;

   fglInternalFormat := GL_DEPTH_COMPONENT24;
   fglInternalFormat := GL_DEPTH_COMPONENT24;

+  fglDataFormat     := GL_UNSIGNED_INT;

 end;
 
 constructor TfdDepth32.Create;
 begin
   inherited Create;
 end;
 
 constructor TfdDepth32.Create;
 begin
   inherited Create;

+  fPixelSize        := 4.0;

   fFormat           := tfDepth32;
   fFormat           := tfDepth32;

-  fWithAlpha        := tfEmpty;

   fWithoutAlpha     := tfDepth32;
   fWithoutAlpha     := tfDepth32;

+  fOpenGLFormat     := tfDepth32;
+  fRange.r          := $FFFFFFFF;
+  fRange.g          := $FFFFFFFF;
+  fRange.b          := $FFFFFFFF;
+  fRange.a          := $FFFFFFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;

   fglInternalFormat := GL_DEPTH_COMPONENT32;
   fglInternalFormat := GL_DEPTH_COMPONENT32;

+  fglDataFormat     := GL_UNSIGNED_INT;

 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -3661,6 +4072,7 @@ begin
   inherited Create;
   fFormat           := tfS3tcDtx1RGBA;
   fWithAlpha        := tfS3tcDtx1RGBA;
   inherited Create;
   fFormat           := tfS3tcDtx1RGBA;
   fWithAlpha        := tfS3tcDtx1RGBA;

+  fOpenGLFormat     := tfS3tcDtx1RGBA;

   fUncompressed     := tfRGB5A1;
   fPixelSize        := 0.5;
   fIsCompressed     := true;
   fUncompressed     := tfRGB5A1;
   fPixelSize        := 0.5;
   fIsCompressed     := true;


@@ -3687,6 +4099,7 @@ begin
   inherited Create;
   fFormat           := tfS3tcDtx3RGBA;
   fWithAlpha        := tfS3tcDtx3RGBA;
   inherited Create;
   fFormat           := tfS3tcDtx3RGBA;
   fWithAlpha        := tfS3tcDtx3RGBA;

+  fOpenGLFormat     := tfS3tcDtx3RGBA;

   fUncompressed     := tfRGBA8;
   fPixelSize        := 1.0;
   fIsCompressed     := true;
   fUncompressed     := tfRGBA8;
   fPixelSize        := 1.0;
   fIsCompressed     := true;


@@ -3713,6 +4126,7 @@ begin
   inherited Create;
   fFormat           := tfS3tcDtx3RGBA;
   fWithAlpha        := tfS3tcDtx3RGBA;
   inherited Create;
   fFormat           := tfS3tcDtx3RGBA;
   fWithAlpha        := tfS3tcDtx3RGBA;

+  fOpenGLFormat     := tfS3tcDtx3RGBA;

   fUncompressed     := tfRGBA8;
   fPixelSize        := 1.0;
   fIsCompressed     := true;
   fUncompressed     := tfRGBA8;
   fPixelSize        := 1.0;
   fIsCompressed     := true;


@@ -3761,7 +4175,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-class function TFormatDescriptor.GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
+class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;

 begin
   result := Get(Get(aFormat).WithAlpha);
 end;
 begin
   result := Get(Get(aFormat).WithAlpha);
 end;


@@ -4013,7 +4427,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
       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;
     end;
   end;
 end;


@@ -4970,9 +5384,9 @@ begin
 
   FillChar(rid{%H-}, SizeOf(rid), 0);
   if (Format in [
 
   FillChar(rid{%H-}, SizeOf(rid), 0);
   if (Format in [

-       tfAlpha4, tfAlpha8, tfAlpha12, tfAlpha16,
-       tfLuminance4, tfLuminance8, tfLuminance12, tfLuminance16,
-       tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance12Alpha12, tfLuminance16Alpha16]) then
+       tfAlpha4, tfAlpha8, tfAlpha16,
+       tfLuminance4, tfLuminance8, tfLuminance16,
+       tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance16Alpha16]) then

     rid.Format := ricfGray
   else
     rid.Format := ricfRGBA;
     rid.Format := ricfGray
   else
     rid.Format := ricfRGBA;


@@ -5323,7 +5737,7 @@ function TglBitmap.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal
 var
   PixelData: TglBitmapPixelData;
 begin
 var
   PixelData: TglBitmapPixelData;
 begin

-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);

   result := AddAlphaFromColorKeyFloat(
     aRed   / PixelData.Range.r,
     aGreen / PixelData.Range.g,
   result := AddAlphaFromColorKeyFloat(
     aRed   / PixelData.Range.r,
     aGreen / PixelData.Range.g,


@@ -5339,7 +5753,7 @@ var
   i: Integer;
   PixelData: TglBitmapPixelData;
 begin
   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;
   with PixelData do begin
     values[0] := aRed;
     values[1] := aGreen;


@@ -5367,7 +5781,7 @@ function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
 var
   PixelData: TglBitmapPixelData;
 begin
 var
   PixelData: TglBitmapPixelData;
 begin

-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);

   result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a);
 end;
 
   result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a);
 end;
 


@@ -5376,7 +5790,7 @@ function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
 var
   PixelData: TglBitmapPixelData;
 begin
 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);
   with PixelData do
     Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha)));
   result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a);


@@ -5456,6 +5870,15 @@ var
   SourcePD, DestPD: TglBitmapPixelData;
   ShiftData: TShiftData;
 
   SourcePD, DestPD: TglBitmapPixelData;
   ShiftData: TShiftData;
 

+  function DataIsIdentical: Boolean;
+  begin
+    result :=
+      (SourceFD.RedMask   = DestFD.RedMask)   and
+      (SourceFD.GreenMask = DestFD.GreenMask) and
+      (SourceFD.BlueMask  = DestFD.BlueMask)  and
+      (SourceFD.AlphaMask = DestFD.AlphaMask);
+  end;
+

   function CanCopyDirect: Boolean;
   begin
     result :=
   function CanCopyDirect: Boolean;
   begin
     result :=


@@ -5488,6 +5911,12 @@ begin
     SourceFD := TFormatDescriptor.Get(Format);
     DestFD   := TFormatDescriptor.Get(aFormat);
 
     SourceFD := TFormatDescriptor.Get(Format);
     DestFD   := TFormatDescriptor.Get(aFormat);
 

+    if DataIsIdentical then begin
+      result := true;
+      Format := aFormat;
+      exit;
+    end;
+

     SourceFD.PreparePixel(SourcePD);
     DestFD.PreparePixel  (DestPD);
 
     SourceFD.PreparePixel(SourcePD);
     DestFD.PreparePixel  (DestPD);
 


@@ -5548,7 +5977,7 @@ procedure TglBitmap.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; cons
 var
   PixelData: TglBitmapPixelData;
 begin
 var
   PixelData: TglBitmapPixelData;
 begin

-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);

   FillWithColorFloat(
     aRed   / PixelData.Range.r,
     aGreen / PixelData.Range.g,
   FillWithColorFloat(
     aRed   / PixelData.Range.r,
     aGreen / PixelData.Range.g,


@@ -6823,9 +7252,9 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
     //get suitable format
     case aInfo.biBitCount of
        8: result := tfLuminance8;
     //get suitable format
     case aInfo.biBitCount of
        8: result := tfLuminance8;

-      16: result := tfBGR5;
-      24: result := tfBGR8;
-      32: result := tfBGRA8;
+      16: result := tfX1RGB5;
+      24: result := tfRGB8;
+      32: result := tfXRGB8;

     end;
   end;
 
     end;
   end;
 


@@ -7073,8 +7502,8 @@ begin
         end;
       end;
 
         end;
       end;
 

-      tfRGB4, tfRGB5, tfR5G6B5, tfRGB5A1, tfRGBA4,
-      tfBGR4, tfBGR5, tfB5G6R5, tfBGR5A1, tfBGRA4: begin
+      tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
+      tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4: begin

         Info.biBitCount    := 16;
         Info.biCompression := BMP_COMP_BITFIELDS;
       end;
         Info.biBitCount    := 16;
         Info.biCompression := BMP_COMP_BITFIELDS;
       end;


@@ -7085,8 +7514,8 @@ begin
           Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values
       end;
 
           Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values
       end;
 

-      tfRGB10, tfRGB10A2, tfRGBA8,
-      tfBGR10, tfBGR10A2, tfBGRA8: begin
+      tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8,
+      tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8: begin

         Info.biBitCount    := 32;
         Info.biCompression := BMP_COMP_BITFIELDS;
       end;
         Info.biBitCount    := 32;
         Info.biCompression := BMP_COMP_BITFIELDS;
       end;


@@ -7414,18 +7843,18 @@ begin
                0: tgaFormat := tfLuminance16;
                8: tgaFormat := tfLuminance8Alpha8;
             end else case (Header.ImageDesc and $F) of
                0: tgaFormat := tfLuminance16;
                8: tgaFormat := tfLuminance8Alpha8;
             end else case (Header.ImageDesc and $F) of

-               0: tgaFormat := tfBGR5;
-               1: tgaFormat := tfBGR5A1;
-               4: tgaFormat := tfBGRA4;
+               0: tgaFormat := tfX1RGB5;
+               1: tgaFormat := tfA1RGB5;
+               4: tgaFormat := tfARGB4;

             end;
 
         24: if not IsGrayFormat then case (Header.ImageDesc and $F) of
             end;
 
         24: if not IsGrayFormat then case (Header.ImageDesc and $F) of

-               0: tgaFormat := tfBGR8;
+               0: tgaFormat := tfRGB8;

             end;
 
         32: if not IsGrayFormat then case (Header.ImageDesc and $F) of
             end;
 
         32: if not IsGrayFormat then case (Header.ImageDesc and $F) of

-               2: tgaFormat := tfBGR10A2;
-               8: tgaFormat := tfBGRA8;
+               2: tgaFormat := tfA2RGB10;
+               8: tgaFormat := tfARGB8;

             end;
       end;
 
             end;
       end;
 


@@ -7510,7 +7939,7 @@ begin
   if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8]) then
     Header.Bpp := 8
   else if (Format in [tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8,
   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
+                      tfRGB5X1, tfBGR5X1, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then

     Header.Bpp := 16
   else if (Format in [tfBGR8, tfRGB8]) then
     Header.Bpp := 24
     Header.Bpp := 16
   else if (Format in [tfBGR8, tfRGB8]) then
     Header.Bpp := 24


@@ -7538,7 +7967,7 @@ begin
   Converter  := nil;
   FormatDesc := TFormatDescriptor.Get(Format);
   Size       := FormatDesc.GetSize(Dimension);
   Converter  := nil;
   FormatDesc := TFormatDescriptor.Get(Format);
   Size       := FormatDesc.GetSize(Dimension);

-  if Format in [tfRGB5, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin
+  if Format in [tfRGB5X1, 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 (FormatDesc.RGBInverted = tfEmpty) then
       raise EglBitmap.Create('inverted RGB format is empty');
     Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted);


@@ -7655,21 +8084,28 @@ var
           D3DFMT_DXT3: result := tfS3tcDtx3RGBA;
           D3DFMT_DXT5: result := tfS3tcDtx5RGBA;
         end;
           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)) > 0) then begin
+        // prepare masks
+        if ((dwFlags and DDPF_LUMINANCE) = 0) then begin
+          Range.r := dwRBitMask;
+          Range.g := dwGBitMask;
+          Range.b := dwBBitMask;
+        end else begin
+          Range.r := dwRBitMask;
+          Range.g := dwRBitMask;
+          Range.b := dwRBitMask;
+        end;
+        Range.a := dwABitMask;

 
         //find matching format
         for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
           fd := TFormatDescriptor.Get(result);
 
         //find matching format
         for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
           fd := TFormatDescriptor.Get(result);

-          if fd.MaskMatch(dwRBitMask, dwGBitMask, dwBBitMask, dwABitMask) and
+          if fd.MaskMatch(Range.r, Range.g, Range.b, Range.a) and

              (8 * fd.PixelSize = dwRGBBitCount) then
             exit;
         end;
 
         //find format with same Range
              (8 * fd.PixelSize = dwRGBBitCount) then
             exit;
         end;
 
         //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;
         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;


@@ -7689,9 +8125,9 @@ var
         //no format with same range found -> use default
         if (result = tfEmpty) then begin
           if (dwABitMask > 0) then
         //no format with same range found -> use default
         if (result = tfEmpty) then begin
           if (dwABitMask > 0) then

-            result := tfBGRA8
+            result := tfRGBA8

           else
           else

-            result := tfBGR8;
+            result := tfRGB8;

         end;
 
         Converter := TbmpBitfieldFormat.Create;
         end;
 
         Converter := TbmpBitfieldFormat.Create;