* fixed some format issues
authorBergmann89 <info@bergmann89.de>
Sat, 6 Dec 2014 21:46:34 +0000 (22:46 +0100)
committerBergmann89 <info@bergmann89.de>
Sat, 6 Dec 2014 21:46:34 +0000 (22:46 +0100)
* added new formats e.g. RGBX8, XRGB8, RGBA8. ARGB8, ...
* removed old, non usefull formats e.g. Alpha12, Luminance12, RGBA2

glBitmap.pas

index 1be10f8..4ee797b 100644 (file)
@@ -778,52 +778,61 @@ type
 
     tfAlpha4,
     tfAlpha8,
-    tfAlpha12,
     tfAlpha16,
 
     tfLuminance4,
     tfLuminance8,
-    tfLuminance12,
     tfLuminance16,
 
     tfLuminance4Alpha4,
     tfLuminance6Alpha2,
     tfLuminance8Alpha8,
     tfLuminance12Alpha4,
-    tfLuminance12Alpha12,
     tfLuminance16Alpha16,
 
     tfR3G3B2,
-    tfRGB4,
+    tfRGBX4,
+    tfXRGB4,
     tfR5G6B5,
-    tfRGB5,
+    tfRGB5X1,
+    tfX1RGB5,
     tfRGB8,
-    tfRGB10,
-    tfRGB12,
+    tfRGBX8,
+    tfXRGB8,
+    tfRGB10X2,
+    tfX2RGB10,
     tfRGB16,
 
-    tfRGBA2,
     tfRGBA4,
+    tfARGB4,
     tfRGB5A1,
+    tfA1RGB5,
     tfRGBA8,
+    tfARGB8,
     tfRGB10A2,
-    tfRGBA12,
+    tfA2RGB10,
     tfRGBA16,
 
-    tfBGR4,
+    tfBGRX4,
+    tfXBGR4,
     tfB5G6R5,
-    tfBGR5,
+    tfBGR5X1,
+    tfX1BGR5,
     tfBGR8,
-    tfBGR10,
-    tfBGR12,
+    tfBGRX8,
+    tfXBGR8,
+    tfBGR10X2,
+    tfX2BGR10,
     tfBGR16,
 
-    tfBGRA2,
     tfBGRA4,
+    tfABGR4,
     tfBGR5A1,
+    tfA1BGR5,
     tfBGRA8,
+    tfABGR8,
     tfBGR10A2,
-    tfBGRA12,
+    tfA2BGR10,
     tfBGRA16,
 
     tfDepth16,
@@ -894,6 +903,12 @@ type
     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;
@@ -904,6 +919,12 @@ type
     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;
@@ -1266,8 +1287,10 @@ type
     fFormat: TglBitmapFormat;
     fWithAlpha: TglBitmapFormat;
     fWithoutAlpha: TglBitmapFormat;
+    fOpenGLFormat: TglBitmapFormat;
     fRGBInverted: TglBitmapFormat;
     fUncompressed: TglBitmapFormat;
+
     fPixelSize: Single;
     fIsCompressed: Boolean;
 
@@ -1284,6 +1307,12 @@ type
     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;
@@ -1291,9 +1320,6 @@ type
     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;
 
@@ -1323,7 +1349,7 @@ type
   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;
@@ -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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    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;
-    constructor Create; override;
   end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1457,10 +1464,6 @@ type
     constructor Create; override;
   end;
 
-  TfdAlpha12 = class(TfdAlpha_US1)
-    constructor Create; override;
-  end;
-
   TfdAlpha16 = class(TfdAlpha_US1)
     constructor Create; override;
   end;
@@ -1473,10 +1476,6 @@ type
     constructor Create; override;
   end;
 
-  TfdLuminance12 = class(TfdLuminance_US1)
-    constructor Create; override;
-  end;
-
   TfdLuminance16 = class(TfdLuminance_US1)
     constructor Create; override;
   end;
@@ -1497,19 +1496,20 @@ type
     constructor Create; override;
   end;
 
-  TfdLuminance12Alpha12 = class(TfdLuminanceAlpha_US2)
+  TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2)
     constructor Create; override;
   end;
 
-  TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2)
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdR3G3B2 = class(TfdUniversal_UB1)
     constructor Create; override;
   end;
 
-  TfdR3G3B2 = class(TfdUniversal_UB1)
+  TfdRGBX4 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 
-  TfdRGB4 = class(TfdUniversal_US1)
+  TfdXRGB4 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 
@@ -1517,7 +1517,11 @@ type
     constructor Create; override;
   end;
 
-  TfdRGB5 = class(TfdUniversal_US1)
+  TfdRGB5X1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdX1RGB5 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 
@@ -1525,19 +1529,23 @@ type
     constructor Create; override;
   end;
 
-  TfdRGB10 = class(TfdUniversal_UI1)
+  TfdRGBX8 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdRGB12 = class(TfdRGB_US3)
+  TfdXRGB8 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdRGB16 = class(TfdRGB_US3)
+  TfdRGB10X2 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdRGBA2 = class(TfdRGBA_UB4)
+  TfdX2RGB10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGB16 = class(TfdRGB_US3)
     constructor Create; override;
   end;
 
@@ -1545,11 +1553,23 @@ type
     constructor Create; override;
   end;
 
+  TfdARGB4 = 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;
 
@@ -1557,15 +1577,20 @@ type
     constructor Create; override;
   end;
 
-  TfdRGBA12 = class(TfdRGBA_US4)
+  TfdA2RGB10 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdRGBA16 = class(TfdRGBA_US4)
+  TfdRGBA16 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdBGR4 = class(TfdUniversal_US1)
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdBGRX4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdXBGR4 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 
@@ -1573,7 +1598,11 @@ type
     constructor Create; override;
   end;
 
-  TfdBGR5 = class(TfdUniversal_US1)
+  TfdBGR5X1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdX1BGR5 = class(TfdUniversal_US1)
     constructor Create; override;
   end;
 
@@ -1581,19 +1610,23 @@ type
     constructor Create; override;
   end;
 
-  TfdBGR10 = class(TfdUniversal_UI1)
+  TfdBGRX8 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdBGR12 = class(TfdBGR_US3)
+  TfdXBGR8 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdBGR16 = class(TfdBGR_US3)
+  TfdBGR10X2 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
-  TfdBGRA2 = class(TfdBGRA_UB4)
+  TfdX2BGR10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGR16 = class(TfdBGR_US3)
     constructor Create; override;
   end;
 
@@ -1601,11 +1634,23 @@ type
     constructor Create; override;
   end;
 
+  TfdABGR4 = 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;
 
@@ -1613,7 +1658,7 @@ type
     constructor Create; override;
   end;
 
-  TfdBGRA12 = class(TfdBGRA_US4)
+  TfdA2BGR10 = class(TfdUniversal_UI1)
     constructor Create; override;
   end;
 
@@ -1714,52 +1759,61 @@ const
 
     TfdAlpha4,
     TfdAlpha8,
-    TfdAlpha12,
     TfdAlpha16,
 
     TfdLuminance4,
     TfdLuminance8,
-    TfdLuminance12,
     TfdLuminance16,
 
     TfdLuminance4Alpha4,
     TfdLuminance6Alpha2,
     TfdLuminance8Alpha8,
     TfdLuminance12Alpha4,
-    TfdLuminance12Alpha12,
     TfdLuminance16Alpha16,
 
     TfdR3G3B2,
-    TfdRGB4,
+    TfdRGBX4,
+    TfdXRGB4,
     TfdR5G6B5,
-    TfdRGB5,
+    TfdRGB5X1,
+    TfdX1RGB5,
     TfdRGB8,
-    TfdRGB10,
-    TfdRGB12,
+    TfdRGBX8,
+    TfdXRGB8,
+    TfdRGB10X2,
+    TfdX2RGB10,
     TfdRGB16,
 
-    TfdRGBA2,
     TfdRGBA4,
+    TfdARGB4,
     TfdRGB5A1,
+    TfdA1RGB5,
     TfdRGBA8,
+    TfdARGB8,
     TfdRGB10A2,
-    TfdRGBA12,
+    TfdA2RGB10,
     TfdRGBA16,
 
-    TfdBGR4,
+    TfdBGRX4,
+    TfdXBGR4,
     TfdB5G6R5,
-    TfdBGR5,
+    TfdBGR5X1,
+    TfdX1BGR5,
     TfdBGR8,
-    TfdBGR10,
-    TfdBGR12,
+    TfdBGRX8,
+    TfdXBGR8,
+    TfdBGR10X2,
+    TfdX2BGR10,
     TfdBGR16,
 
-    TfdBGRA2,
     TfdBGRA4,
+    TfdABGR4,
     TfdBGR5A1,
+    TfdA1BGR5,
     TfdBGRA8,
+    TfdABGR8,
     TfdBGR10A2,
-    TfdBGRA12,
+    TfdA2BGR10,
     TfdBGRA16,
 
     TfdDepth16,
@@ -1844,15 +1898,15 @@ begin
         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
-        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 [
@@ -1861,8 +1915,8 @@ begin
 
         //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,
@@ -1874,12 +1928,12 @@ begin
   if (aFormat in [
         //8 bpp
         tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2,
-        tfR3G3B2, tfRGBA2, tfBGRA2,
+        tfR3G3B2,
 
         //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,
@@ -2374,6 +2428,36 @@ begin
 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;
@@ -2476,8 +2560,10 @@ begin
   fFormat       := tfEmpty;
   fWithAlpha    := tfEmpty;
   fWithoutAlpha := tfEmpty;
+  fOpenGLFormat := tfEmpty;
   fRGBInverted  := tfEmpty;
   fUncompressed := tfEmpty;
+
   fPixelSize    := 0.0;
   fIsCompressed := false;
 
@@ -2507,15 +2593,6 @@ begin
   inc(aData);
 end;
 
-constructor TfdAlpha_UB1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fRange.a          := $FF;
-  fglFormat         := GL_ALPHA;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2534,17 +2611,6 @@ begin
   inc(aData);
 end;
 
-constructor TfdLuminance_UB1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fglFormat         := GL_LUMINANCE;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2568,12 +2634,6 @@ begin
   inc(aData);
 end;
 
-constructor TfdUniversal_UB1.Create;
-begin
-  inherited Create;
-  fPixelSize := 1.0;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2591,145 +2651,54 @@ begin
   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
-  aData^ := aPixel.Data.r;
+  aData^ := aPixel.Data.b;
   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
-  aPixel.Data.r := aData^;
+  aPixel.Data.b := aData^;
   inc(aData);
   aPixel.Data.g := aData^;
   inc(aData);
-  aPixel.Data.b := aData^;
+  aPixel.Data.r := aData^;
   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
-  aData^ := aPixel.Data.b;
+  aData^ := aPixel.Data.r;
   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
-  aPixel.Data.b := aData^;
+  aPixel.Data.r := aData^;
   inc(aData);
   aPixel.Data.g := aData^;
   inc(aData);
-  aPixel.Data.r := aData^;
+  aPixel.Data.b := aData^;
   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////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2748,15 +2717,6 @@ begin
   inc(aData, 2);
 end;
 
-constructor TfdAlpha_US1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fRange.a          := $FFFF;
-  fglFormat         := GL_ALPHA;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2775,17 +2735,6 @@ begin
   inc(aData, 2);
 end;
 
-constructor TfdLuminance_US1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fglFormat         := GL_LUMINANCE;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2809,12 +2758,6 @@ begin
   inc(aData, 2);
 end;
 
-constructor TfdUniversal_US1.Create;
-begin
-  inherited Create;
-  fPixelSize := 2.0;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2829,21 +2772,10 @@ begin
   aPixel.Data.r := PWord(aData)^;
   aPixel.Data.g := PWord(aData)^;
   aPixel.Data.b := PWord(aData)^;
-  aPixel.Data.a := 0;
+  aPixel.Data.a := PWord(aData)^;;
   inc(aData, 2);
 end;
 
-constructor TfdDepth_US1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fglFormat         := GL_DEPTH_COMPONENT;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2861,117 +2793,86 @@ begin
   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
-  PWord(aData)^ := aPixel.Data.r;
+  PWord(aData)^ := aPixel.Data.b;
   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
-  aPixel.Data.r := PWord(aData)^;
+  aPixel.Data.b := PWord(aData)^;
   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;
 
-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
-  PWord(aData)^ := aPixel.Data.b;
+  PWord(aData)^ := aPixel.Data.r;
   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
-  aPixel.Data.b := PWord(aData)^;
+  aPixel.Data.r := PWord(aData)^;
   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;
 
-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
-  inherited Map(aPixel, aData, aMapData);
   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
-  inherited Unmap(aData, aPixel, aMapData);
   aPixel.Data.a := PWord(aData)^;
   inc(aData, 2);
+  inherited Unmap(aData, aPixel, aMapData);
 end;
 
-constructor TfdRGBA_US4.Create;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdARGB_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdARGB_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
-  inherited Create;
-  fPixelSize        :=   8.0;
-  fRange.a          := $FFFF;
-  fShift.a          :=    48;
-  fglFormat         := GL_RGBA;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
+  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;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2979,26 +2880,33 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 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);
+  inherited Map(aPixel, aData, aMapData);
 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);
+  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;
 
-constructor TfdBGRA_US4.Create;
+procedure TfdABGR_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 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;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -3024,12 +2932,6 @@ begin
   inc(aData, 2);
 end;
 
-constructor TfdUniversal_UI1.Create;
-begin
-  inherited Create;
-  fPixelSize := 4.0;
-end;
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -3048,287 +2950,482 @@ begin
   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;
+  fPixelSize        := 1.0;
   fFormat           := tfAlpha4;
   fWithAlpha        := tfAlpha4;
+  fOpenGLFormat     := tfAlpha4;
+  fRange.a          := $FF;
+  fglFormat         := GL_ALPHA;
   fglInternalFormat := GL_ALPHA4;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 constructor TfdAlpha8.Create;
 begin
   inherited Create;
+  fPixelSize        := 1.0;
   fFormat           := tfAlpha8;
   fWithAlpha        := tfAlpha8;
+  fOpenGLFormat     := tfAlpha8;
+  fRange.a          := $FF;
+  fglFormat         := GL_ALPHA;
   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;
+  fPixelSize        := 2.0;
   fFormat           := tfAlpha16;
   fWithAlpha        := tfAlpha16;
+  fOpenGLFormat     := tfAlpha16;
+  fRange.a          := $FFFF;
+  fglFormat         := GL_ALPHA;
   fglInternalFormat := GL_ALPHA16;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
 constructor TfdLuminance4.Create;
 begin
   inherited Create;
+  fPixelSize        := 1.0;
   fFormat           := tfLuminance4;
   fWithAlpha        := tfLuminance4Alpha4;
   fWithoutAlpha     := tfLuminance4;
+  fOpenGLFormat     := tfLuminance4;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fglFormat         := GL_LUMINANCE;
   fglInternalFormat := GL_LUMINANCE4;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 constructor TfdLuminance8.Create;
 begin
   inherited Create;
+  fPixelSize        := 1.0;
   fFormat           := tfLuminance8;
   fWithAlpha        := tfLuminance8Alpha8;
   fWithoutAlpha     := tfLuminance8;
+  fOpenGLFormat     := tfLuminance8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fglFormat         := GL_LUMINANCE;
   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;
+  fPixelSize        := 2.0;
   fFormat           := tfLuminance16;
   fWithAlpha        := tfLuminance16Alpha16;
   fWithoutAlpha     := tfLuminance16;
+  fOpenGLFormat     := tfLuminance16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fglFormat         := GL_LUMINANCE;
   fglInternalFormat := GL_LUMINANCE16;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
 constructor TfdLuminance4Alpha4.Create;
 begin
   inherited Create;
+  fPixelSize        := 2.0;
   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;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 constructor TfdLuminance6Alpha2.Create;
 begin
   inherited Create;
+  fPixelSize        := 2.0;
   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;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 constructor TfdLuminance8Alpha8.Create;
 begin
   inherited Create;
+  fPixelSize        := 2.0;
   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;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 constructor TfdLuminance12Alpha4.Create;
 begin
   inherited Create;
+  fPixelSize        := 4.0;
   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;
-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;
+  fPixelSize        := 4.0;
   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;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
 constructor TfdR3G3B2.Create;
 begin
   inherited Create;
+  fPixelSize        := 1.0;
   fFormat           := tfR3G3B2;
-  fWithAlpha        := tfRGBA2;
+  fWithAlpha        := tfRGBA4;
   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;
-  fglDataFormat     := GL_UNSIGNED_BYTE_2_3_3_REV;
+  fglDataFormat     := GL_UNSIGNED_BYTE_3_3_2;
 end;
 
-constructor TfdRGB4.Create;
+constructor TfdRGBX4.Create;
 begin
   inherited Create;
-  fFormat           := tfRGB4;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGBX4;
   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;
+  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;
+  fPixelSize        := 2.0;
   fFormat           := tfR5G6B5;
-  fWithAlpha        := tfRGBA4;
+  fWithAlpha        := tfRGB5A1;
   fWithoutAlpha     := tfR5G6B5;
+  fOpenGLFormat     := tfR5G6B5;
   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;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5_REV;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5;
 end;
 
-constructor TfdRGB5.Create;
+constructor TfdRGB5X1.Create;
 begin
   inherited Create;
-  fFormat           := tfRGB5;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGB5X1;
   fWithAlpha        := tfRGB5A1;
-  fWithoutAlpha     := tfRGB5;
-  fRGBInverted      := tfBGR5;
+  fWithoutAlpha     := tfRGB5X1;
+  fOpenGLFormat     := tfRGB5X1;
+  fRGBInverted      := tfBGR5X1;
   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;
+  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;
+  fPixelSize        := 3.0;
   fFormat           := tfRGB8;
   fWithAlpha        := tfRGBA8;
   fWithoutAlpha     := tfRGB8;
+  fOpenGLFormat     := tfRGB8;
   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;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
 end;
 
-constructor TfdRGB10.Create;
+constructor TfdRGB10X2.Create;
 begin
   inherited Create;
-  fFormat           := tfRGB10;
+  fPixelSize        := 3.0;
+  fFormat           := tfRGB10X2;
   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;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
 end;
 
-constructor TfdRGB12.Create;
+constructor TfdX2RGB10.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;
+  fPixelSize        := 6.0;
   fFormat           := tfRGB16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;
+  fOpenGLFormat     := tfRGB16;
   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;
+  fPixelSize        := 2.0;
   fFormat           := tfRGBA4;
   fWithAlpha        := tfRGBA4;
-  fWithoutAlpha     := tfRGB4;
+  fWithoutAlpha     := tfRGBX4;
+  fOpenGLFormat     := tfRGBA4;
   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.b          :=  8;
+  fShift.b          :=  0;
   fShift.a          := 12;
-  fglFormat         := GL_RGBA;
+  fglFormat         := GL_BGRA;
   fglInternalFormat := GL_RGBA4;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
@@ -3336,132 +3433,257 @@ end;
 constructor TfdRGB5A1.Create;
 begin
   inherited Create;
+  fPixelSize        := 2.0;
   fFormat           := tfRGB5A1;
   fWithAlpha        := tfRGB5A1;
-  fWithoutAlpha     := tfRGB5;
+  fWithoutAlpha     := tfRGB5X1;
+  fOpenGLFormat     := tfRGB5A1;
   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;
+  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;
+  fPixelSize        := 4.0;
   fFormat           := tfRGBA8;
   fWithAlpha        := tfRGBA8;
   fWithoutAlpha     := tfRGB8;
+  fOpenGLFormat     := tfRGBA8;
   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;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
 end;
 
 constructor TfdRGB10A2.Create;
 begin
   inherited Create;
+  fPixelSize        := 3.0;
   fFormat           := tfRGB10A2;
   fWithAlpha        := tfRGB10A2;
-  fWithoutAlpha     := tfRGB10;
+  fWithoutAlpha     := tfRGB10X2;
+  fOpenGLFormat     := tfRGB10A2;
   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;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
 end;
 
-constructor TfdRGBA12.Create;
+constructor TfdA2RGB10.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;
+  fPixelSize        := 8.0;
   fFormat           := tfRGBA16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;
+  fOpenGLFormat     := tfRGBA16;
   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;
 
-constructor TfdBGR4.Create;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TfdBGRX4.Create;
 begin
   inherited Create;
   fPixelSize        := 2.0;
-  fFormat           := tfBGR4;
+  fFormat           := tfBGRX4;
   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;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdB5G6R5.Create;
 begin
   inherited Create;
+  fPixelSize        := 2.0;
   fFormat           := tfB5G6R5;
-  fWithAlpha        := tfBGRA4;
+  fWithAlpha        := tfBGR5A1;
   fWithoutAlpha     := tfB5G6R5;
+  fOpenGLFormat     := tfB5G6R5;
   fRGBInverted      := tfR5G6B5;
   fRange.r          := $1F;
   fRange.g          := $3F;
   fRange.b          := $1F;
-  fShift.r          :=  11;
-  fShift.g          :=   5;
-  fShift.b          :=   0;
-  fglFormat         := GL_RGB;  //B5G6R5 is only possible as R5G6B5 -> use reverted dataformat
-  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;
 
-constructor TfdBGR5.Create;
+constructor TfdBGR5X1.Create;
 begin
   inherited Create;
   fPixelSize        := 2.0;
-  fFormat           := tfBGR5;
+  fFormat           := tfBGR5X1;
   fWithAlpha        := tfBGR5A1;
-  fWithoutAlpha     := tfBGR5;
-  fRGBInverted      := tfRGB5;
+  fWithoutAlpha     := tfBGR5X1;
+  fOpenGLFormat     := tfBGR5X1;
+  fRGBInverted      := tfRGB5X1;
   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;
@@ -3469,79 +3691,163 @@ end;
 constructor TfdBGR8.Create;
 begin
   inherited Create;
+  fPixelSize        := 3.0;
   fFormat           := tfBGR8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;
+  fOpenGLFormat     := tfBGR8;
   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;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
 end;
 
-constructor TfdBGR10.Create;
+constructor TfdBGR10X2.Create;
 begin
   inherited Create;
-  fFormat           := tfBGR10;
+  fPixelSize        := 3.0;
+  fFormat           := tfBGR10X2;
   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;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
 end;
 
-constructor TfdBGR12.Create;
+constructor TfdX2BGR10.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;
+  fPixelSize        := 6.0;
   fFormat           := tfBGR16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;
+  fOpenGLFormat     := tfBGR16;
   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;
 
-constructor TfdBGRA2.Create;
+constructor TfdBGRA4.Create;
 begin
   inherited Create;
-  fFormat           := tfBGRA2;
+  fPixelSize        := 2.0;
+  fFormat           := 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;
 
-constructor TfdBGRA4.Create;
+constructor TfdABGR4.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.b          :=  0;
+  fShift.b          :=  8;
   fShift.a          := 12;
-  fglFormat         := GL_BGRA;
+  fglFormat         := GL_RGBA;
   fglInternalFormat := GL_RGBA4;
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
@@ -3549,98 +3855,203 @@ end;
 constructor TfdBGR5A1.Create;
 begin
   inherited Create;
+  fPixelSize        := 2.0;
   fFormat           := tfBGR5A1;
   fWithAlpha        := tfBGR5A1;
-  fWithoutAlpha     := tfBGR5;
+  fWithoutAlpha     := tfBGR5X1;
+  fOpenGLFormat     := tfBGR5A1;
   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;
+  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;
+  fPixelSize        := 4.0;
   fFormat           := tfBGRA8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;
+  fOpenGLFormat     := tfBGRA8;
   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;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
 end;
 
 constructor TfdBGR10A2.Create;
 begin
   inherited Create;
+  fPixelSize        := 3.0;
   fFormat           := tfBGR10A2;
   fWithAlpha        := tfBGR10A2;
-  fWithoutAlpha     := tfBGR10;
+  fWithoutAlpha     := tfBGR10X2;
+  fOpenGLFormat     := tfBGR10A2;
   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;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
 end;
 
-constructor TfdBGRA12.Create;
+constructor TfdA2BGR10.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;
+  fPixelSize        := 8.0;
   fFormat           := tfBGRA16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;
+  fOpenGLFormat     := tfBGRA16;
   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;
+  fPixelSize        := 2.0;
   fFormat           := tfDepth16;
-  fWithAlpha        := tfEmpty;
   fWithoutAlpha     := tfDepth16;
+  fOpenGLFormat     := tfDepth16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
   fglInternalFormat := GL_DEPTH_COMPONENT16;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
 constructor TfdDepth24.Create;
 begin
   inherited Create;
+  fPixelSize        := 3.0;
   fFormat           := tfDepth24;
-  fWithAlpha        := tfEmpty;
   fWithoutAlpha     := tfDepth24;
+  fOpenGLFormat     := tfDepth24;
+  fRange.r          := $FFFFFF;
+  fRange.g          := $FFFFFF;
+  fRange.b          := $FFFFFF;
+  fRange.a          := $FFFFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
   fglInternalFormat := GL_DEPTH_COMPONENT24;
+  fglDataFormat     := GL_UNSIGNED_INT;
 end;
 
 constructor TfdDepth32.Create;
 begin
   inherited Create;
+  fPixelSize        := 4.0;
   fFormat           := tfDepth32;
-  fWithAlpha        := tfEmpty;
   fWithoutAlpha     := tfDepth32;
+  fOpenGLFormat     := tfDepth32;
+  fRange.r          := $FFFFFFFF;
+  fRange.g          := $FFFFFFFF;
+  fRange.b          := $FFFFFFFF;
+  fRange.a          := $FFFFFFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
   fglInternalFormat := GL_DEPTH_COMPONENT32;
+  fglDataFormat     := GL_UNSIGNED_INT;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -3661,6 +4072,7 @@ begin
   inherited Create;
   fFormat           := tfS3tcDtx1RGBA;
   fWithAlpha        := tfS3tcDtx1RGBA;
+  fOpenGLFormat     := tfS3tcDtx1RGBA;
   fUncompressed     := tfRGB5A1;
   fPixelSize        := 0.5;
   fIsCompressed     := true;
@@ -3687,6 +4099,7 @@ begin
   inherited Create;
   fFormat           := tfS3tcDtx3RGBA;
   fWithAlpha        := tfS3tcDtx3RGBA;
+  fOpenGLFormat     := tfS3tcDtx3RGBA;
   fUncompressed     := tfRGBA8;
   fPixelSize        := 1.0;
   fIsCompressed     := true;
@@ -3713,6 +4126,7 @@ begin
   inherited Create;
   fFormat           := tfS3tcDtx3RGBA;
   fWithAlpha        := tfS3tcDtx3RGBA;
+  fOpenGLFormat     := tfS3tcDtx3RGBA;
   fUncompressed     := tfRGBA8;
   fPixelSize        := 1.0;
   fIsCompressed     := true;
@@ -3761,7 +4175,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TFormatDescriptor.GetWithAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
+class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
 begin
   result := Get(Get(aFormat).WithAlpha);
 end;
@@ -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
-        aPixel.Data.arr[i] := aDestFD.Range.arr[i];
+        aPixel.Data.arr[i] := 0;
     end;
   end;
 end;
@@ -4970,9 +5384,9 @@ begin
 
   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;
@@ -5323,7 +5737,7 @@ function TglBitmap.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal
 var
   PixelData: TglBitmapPixelData;
 begin
-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
   result := AddAlphaFromColorKeyFloat(
     aRed   / PixelData.Range.r,
     aGreen / PixelData.Range.g,
@@ -5339,7 +5753,7 @@ var
   i: Integer;
   PixelData: TglBitmapPixelData;
 begin
-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
   with PixelData do begin
     values[0] := aRed;
     values[1] := aGreen;
@@ -5367,7 +5781,7 @@ function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
 var
   PixelData: TglBitmapPixelData;
 begin
-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
   result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a);
 end;
 
@@ -5376,7 +5790,7 @@ function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
 var
   PixelData: TglBitmapPixelData;
 begin
-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
   with PixelData do
     Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha)));
   result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a);
@@ -5456,6 +5870,15 @@ var
   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 :=
@@ -5488,6 +5911,12 @@ begin
     SourceFD := TFormatDescriptor.Get(Format);
     DestFD   := TFormatDescriptor.Get(aFormat);
 
+    if DataIsIdentical then begin
+      result := true;
+      Format := aFormat;
+      exit;
+    end;
+
     SourceFD.PreparePixel(SourcePD);
     DestFD.PreparePixel  (DestPD);
 
@@ -5548,7 +5977,7 @@ procedure TglBitmap.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; cons
 var
   PixelData: TglBitmapPixelData;
 begin
-  TFormatDescriptor.GetWithAlpha(Format).PreparePixel(PixelData);
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
   FillWithColorFloat(
     aRed   / PixelData.Range.r,
     aGreen / PixelData.Range.g,
@@ -6823,9 +7252,9 @@ function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
     //get suitable format
     case aInfo.biBitCount of
        8: result := tfLuminance8;
-      16: result := tfBGR5;
-      24: result := tfBGR8;
-      32: result := tfBGRA8;
+      16: result := tfX1RGB5;
+      24: result := tfRGB8;
+      32: result := tfXRGB8;
     end;
   end;
 
@@ -7073,8 +7502,8 @@ begin
         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;
@@ -7085,8 +7514,8 @@ begin
           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;
@@ -7414,18 +7843,18 @@ begin
                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
-               0: tgaFormat := tfBGR8;
+               0: tgaFormat := tfRGB8;
             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;
 
@@ -7510,7 +7939,7 @@ begin
   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
@@ -7538,7 +7967,7 @@ begin
   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);
@@ -7655,21 +8084,28 @@ var
           D3DFMT_DXT3: result := tfS3tcDtx3RGBA;
           D3DFMT_DXT5: result := tfS3tcDtx5RGBA;
         end;
-      end else if ((Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0) then begin
+      end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 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);
-          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
-        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;
@@ -7689,9 +8125,9 @@ var
         //no format with same range found -> use default
         if (result = tfEmpty) then begin
           if (dwABitMask > 0) then
-            result := tfBGRA8
+            result := tfRGBA8
           else
-            result := tfBGR8;
+            result := tfRGB8;
         end;
 
         Converter := TbmpBitfieldFormat.Create;