* refactored FormatDescriptors (again)
authorBergmann89 <bergmann89@muo-game.de>
Sat, 2 Nov 2013 18:03:49 +0000 (19:03 +0100)
committerBergmann89 <bergmann89@muo-game.de>
Sat, 2 Nov 2013 18:03:49 +0000 (19:03 +0100)
glBitmap.pas

index b2a1476..74b9233 100644 (file)
@@ -593,21 +593,21 @@ type
   TglBitmapFormat = (
     tfEmpty = 0,
 
-    //tfAlpha4,
+    tfAlpha4,
     tfAlpha8,
-    //tfAlpha12,
+    tfAlpha12,
     tfAlpha16,
 
-    //tfLuminance4,
+    tfLuminance4,
     tfLuminance8,
-    //tfLuminance12,
+    tfLuminance12,
     tfLuminance16,
 
     tfLuminance4Alpha4,
     tfLuminance6Alpha2,
     tfLuminance8Alpha8,
     tfLuminance12Alpha4,
-    //tfLuminance12Alpha12,
+    tfLuminance12Alpha12,
     tfLuminance16Alpha16,
 
     tfR3G3B2,
@@ -616,7 +616,7 @@ type
     tfRGB5,
     tfRGB8,
     tfRGB10,
-    //tfRGB12,
+    tfRGB12,
     tfRGB16,
 
     tfRGBA2,
@@ -624,7 +624,7 @@ type
     tfRGB5A1,
     tfRGBA8,
     tfRGB10A2,
-    //tfRGBA12,
+    tfRGBA12,
     tfRGBA16,
 
     tfBGR4,
@@ -632,7 +632,7 @@ type
     tfBGR5,
     tfBGR8,
     tfBGR10,
-    //tfBGR12,
+    tfBGR12,
     tfBGR16,
 
     tfBGRA2,
@@ -640,12 +640,12 @@ type
     tfBGR5A1,
     tfBGRA8,
     tfBGR10A2,
-    //tfBGRA12,
-    tfBGRA16
+    tfBGRA12,
+    tfBGRA16,
 
-    //tfDepth16,
-    //tfDepth24,
-    //tfDepth32
+    tfDepth16,
+    tfDepth24,
+    tfDepth32
   );
 
   TglBitmapFileType = (
@@ -1108,175 +1108,305 @@ type
 
   TfdEmpty = class(TFormatDescriptor);
 
-  TfdAlpha8 = class(TFormatDescriptor)
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdAlpha_UB1 = class(TFormatDescriptor) //1* unsigned byte
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdAlpha16 = class(TFormatDescriptor)
+  TfdLuminance_UB1 = class(TFormatDescriptor) //1* unsigned byte
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdLuminance8 = class(TFormatDescriptor)
+  TfdUniversal_UB1 = class(TFormatDescriptor) //1* unsigned byte
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdLuminance16 = class(TFormatDescriptor)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdLuminance4Alpha4 = class(TFormatDescriptor)
+  TfdRGB_UB3 = class(TFormatDescriptor) //3* unsigned byte
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdLuminance6Alpha2 = class(TfdLuminance4Alpha4)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdLuminance8Alpha8 = class(TFormatDescriptor)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdLuminance12Alpha4 = class(TfdLuminance8Alpha8)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdLuminance16Alpha16 = class(TFormatDescriptor)
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdAlpha_US1 = class(TFormatDescriptor) //1* unsigned short
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdR3G3B2 = class(TFormatDescriptor)
+  TfdLuminance_US1 = class(TFormatDescriptor) //1* unsigned short
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGB4 = class(TFormatDescriptor)
+  TfdUniversal_US1 = class(TFormatDescriptor) //1* unsigned short
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdR5G6B5 = class(TfdRGB4)
+  TfdDepth_US1 = class(TFormatDescriptor) //1* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGB5 = class(TfdRGB4)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGB8 = class(TFormatDescriptor)
+  TfdRGB_US3 = class(TFormatDescriptor) //3* unsigned short
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
     procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGB10 = class(TFormatDescriptor)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGB16 = class(TFormatDescriptor)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGBA2 = class(TfdR3G3B2)
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGBA4 = class(TfdRGB4)
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdUniversal_UI1 = class(TFormatDescriptor) //1* unsigned int
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGB5A1 = class(TfdRGB5)
+  TfdDepth_UI1 = class(TFormatDescriptor) //1* unsigned int
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
     constructor Create; override;
   end;
 
-  TfdRGBA8 = class(TfdRGB8)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdAlpha4 = class(TfdAlpha_UB1)
     constructor Create; override;
   end;
 
-  TfdRGB10A2 = class(TfdRGB10)
+  TfdAlpha8 = class(TfdAlpha_UB1)
     constructor Create; override;
   end;
 
-  TfdRGBA16 = class(TfdRGB16)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  TfdAlpha12 = class(TfdAlpha_US1)
     constructor Create; override;
   end;
 
-  TfdBGR4 = class(TfdRGB4)
+  TfdAlpha16 = class(TfdAlpha_US1)
     constructor Create; override;
   end;
 
-  TfdB5G6R5 = class(TfdRGB4)
+  TfdLuminance4 = class(TfdLuminance_UB1)
     constructor Create; override;
   end;
 
-  TfdBGR5 = class(TfdRGB5)
+  TfdLuminance8 = class(TfdLuminance_UB1)
     constructor Create; override;
   end;
 
-  TfdBGR8 = class(TFormatDescriptor)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  TfdLuminance12 = class(TfdLuminance_US1)
     constructor Create; override;
   end;
 
-  TfdBGR10 = class(TfdRGB10)
+  TfdLuminance16 = class(TfdLuminance_US1)
     constructor Create; override;
   end;
 
-  TfdBGR16 = class(TFormatDescriptor)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  TfdLuminance4Alpha4 = class(TfdLuminanceAlpha_UB2)
     constructor Create; override;
   end;
 
-  TfdBGRA2 = class(TfdRGBA2)
+  TfdLuminance6Alpha2 = class(TfdLuminanceAlpha_UB2)
     constructor Create; override;
   end;
 
-  TfdBGRA4 = class(TfdRGBA4)
+  TfdLuminance8Alpha8 = class(TfdLuminanceAlpha_UB2)
     constructor Create; override;
   end;
 
-  TfdBGR5A1 = class(TfdRGB5A1)
+  TfdLuminance12Alpha4 = class(TfdLuminanceAlpha_US2)
     constructor Create; override;
   end;
 
-  TfdBGRA8 = class(TfdBGR8)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  TfdLuminance12Alpha12 = class(TfdLuminanceAlpha_US2)
     constructor Create; override;
   end;
 
-  TfdBGR10A2 = class(TfdRGB10A2)
+  TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2)
     constructor Create; override;
   end;
 
-  TfdBGRA16 = class(TfdBGR16)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  TfdR3G3B2 = class(TfdUniversal_UB1)
+    constructor Create; override;
+  end;
+
+  TfdRGB4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdR5G6B5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGB5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGB8 = class(TfdRGB_UB3)
+    constructor Create; override;
+  end;
+
+  TfdRGB10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGB12 = class(TfdRGB_US3)
+    constructor Create; override;
+  end;
+
+  TfdRGB16 = class(TfdRGB_US3)
+    constructor Create; override;
+  end;
+
+  TfdRGBA2 = class(TfdRGBA_UB4)
+    constructor Create; override;
+  end;
+
+  TfdRGBA4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGB5A1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGBA8 = class(TfdRGBA_UB4)
+    constructor Create; override;
+  end;
+
+  TfdRGB10A2 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGBA12 = class(TfdRGBA_US4)
+    constructor Create; override;
+  end;
+
+  TfdRGBA16 = class(TfdRGBA_US4)
+    constructor Create; override;
+  end;
+
+  TfdBGR4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdB5G6R5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGR5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGR8 = class(TfdBGR_UB3)
+    constructor Create; override;
+  end;
+
+  TfdBGR10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGR12 = class(TfdBGR_US3)
+    constructor Create; override;
+  end;
+
+  TfdBGR16 = class(TfdBGR_US3)
+    constructor Create; override;
+  end;
+
+  TfdBGRA2 = class(TfdBGRA_UB4)
+    constructor Create; override;
+  end;
+
+  TfdBGRA4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGR5A1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGRA8 = class(TfdBGRA_UB4)
+    constructor Create; override;
+  end;
+
+  TfdBGR10A2 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGRA12 = class(TfdBGRA_US4)
+    constructor Create; override;
+  end;
+
+  TfdBGRA16 = class(TfdBGRA_US4)
+    constructor Create; override;
+  end;
+
+  TfdDepth16 = class(TfdDepth_US1)
+    constructor Create; override;
+  end;
+
+  TfdDepth24 = class(TfdDepth_UI1)
+    constructor Create; override;
+  end;
+
+  TfdDepth32 = class(TfdDepth_UI1)
     constructor Create; override;
   end;
 
@@ -1328,26 +1458,30 @@ const
   ALPHA_WEIGHT_G = 0.59;
   ALPHA_WEIGHT_B = 0.11;
 
+  DEPTH_WEIGHT_R = 0.333333333;
+  DEPTH_WEIGHT_G = 0.333333333;
+  DEPTH_WEIGHT_B = 0.333333333;
+
   UNSUPPORTED_FORMAT = 'the given format isn''t supported by this function.';
 
   FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = (
     TfdEmpty,
 
-    //TfdAlpha4,
+    TfdAlpha4,
     TfdAlpha8,
-    //TfdAlpha12,
+    TfdAlpha12,
     TfdAlpha16,
 
-    //TfdLuminance4,
+    TfdLuminance4,
     TfdLuminance8,
-    //TfdLuminance12,
+    TfdLuminance12,
     TfdLuminance16,
 
     TfdLuminance4Alpha4,
     TfdLuminance6Alpha2,
     TfdLuminance8Alpha8,
     TfdLuminance12Alpha4,
-    //TfdLuminance12Alpha12,
+    TfdLuminance12Alpha12,
     TfdLuminance16Alpha16,
 
     TfdR3G3B2,
@@ -1356,7 +1490,7 @@ const
     TfdRGB5,
     TfdRGB8,
     TfdRGB10,
-    //TfdRGB12,
+    TfdRGB12,
     TfdRGB16,
 
     TfdRGBA2,
@@ -1364,7 +1498,7 @@ const
     TfdRGB5A1,
     TfdRGBA8,
     TfdRGB10A2,
-    //TfdRGBA12,
+    TfdRGBA12,
     TfdRGBA16,
 
     TfdBGR4,
@@ -1372,7 +1506,7 @@ const
     TfdBGR5,
     TfdBGR8,
     TfdBGR10,
-    //TfdBGR12,
+    TfdBGR12,
     TfdBGR16,
 
     TfdBGRA2,
@@ -1380,12 +1514,12 @@ const
     TfdBGR5A1,
     TfdBGRA8,
     TfdBGR10A2,
-    //TfdBGRA12,
-    TfdBGRA16
+    TfdBGRA12,
+    TfdBGRA16,
 
-    //TfdDepth16,
-    //TfdDepth24,
-    //TfdDepth32
+    TfdDepth16,
+    TfdDepth24,
+    TfdDepth32
   );
 
 var
@@ -1493,6 +1627,14 @@ begin
     LUMINANCE_WEIGHT_B * aPixel.Data.b);
 end;
 
+function DepthWeight(const aPixel: TglBitmapPixelData): Cardinal;
+begin
+  result := Trunc(
+    DEPTH_WEIGHT_R * aPixel.Data.r +
+    DEPTH_WEIGHT_G * aPixel.Data.g +
+    DEPTH_WEIGHT_B * aPixel.Data.b);
+end;
+
 //TODO check _ARB functions and constants
 
 (* GLB_NO_NATIVE_GL
@@ -2039,15 +2181,15 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdAlpha8///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdAlpha_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdAlpha8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+procedure TfdAlpha_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
   aData^ := aPixel.Data.a;
   inc(aData);
 end;
 
-procedure TfdAlpha8.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+procedure TfdAlpha_UB1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
   aPixel.Data.r := 0;
   aPixel.Data.g := 0;
@@ -2056,56 +2198,25 @@ begin
   inc(aData^);
 end;
 
-constructor TfdAlpha8.Create;
+constructor TfdAlpha_UB1.Create;
 begin
   inherited Create;
   fPixelSize        := 1.0;
-  fFormat           := tfAlpha8;
   fRange.a          := $FF;
   fglFormat         := GL_ALPHA;
-  fglInternalFormat := GL_ALPHA8;
   fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdAlpha16//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdAlpha16.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-end;
-
-procedure TfdAlpha16.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := 0;
-  aPixel.Data.g := 0;
-  aPixel.Data.b := 0;
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
-end;
-
-constructor TfdAlpha16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfAlpha16;
-  fRange.a          := $FFFF;
-  fglFormat         := GL_ALPHA;
-  fglInternalFormat := GL_ALPHA16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminance8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+procedure TfdLuminance_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
   aData^ := LuminanceWeight(aPixel);
   inc(aData);
 end;
 
-procedure TfdLuminance8.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+procedure TfdLuminance_UB1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
   aPixel.Data.r := aData^;
   aPixel.Data.g := aData^;
@@ -2114,229 +2225,659 @@ begin
   inc(aData);
 end;
 
-constructor TfdLuminance8.Create;
+constructor TfdLuminance_UB1.Create;
 begin
   inherited Create;
   fPixelSize        := 1.0;
-  fFormat           := tfLuminance8;
-  fWithAlpha        := tfLuminance8Alpha8;
-  fWithoutAlpha     := tfLuminance8;
   fRange.r          := $FF;
   fRange.g          := $FF;
   fRange.b          := $FF;
   fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE8;
   fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminance16.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+procedure TfdUniversal_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  i: Integer;
 begin
-  PWord(aData)^ := LuminanceWeight(aPixel);
-  inc(aData, 2);
+  aData^ := 0;
+  for i := 0 to 3 do
+    if (fRange.arr[i] > 0) then
+      aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
+  inc(aData);
 end;
 
-procedure TfdLuminance16.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+procedure TfdUniversal_UB1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+  i: Integer;
 begin
-  aPixel.Data.r := PWord(aData)^;
-  aPixel.Data.g := PWord(aData)^;
-  aPixel.Data.b := PWord(aData)^;
-  aPixel.Data.a := 0;
-  inc(aData, 2);
+  for i := 0 to 3 do
+    aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and fRange.arr[i];
+  inc(aData);
 end;
 
-constructor TfdLuminance16.Create;
+constructor TfdUniversal_UB1.Create;
 begin
   inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfLuminance16;
-  fWithAlpha        := tfLuminance16Alpha16;
-  fWithoutAlpha     := tfLuminance16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
+  fPixelSize := 1.0;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminance4Alpha4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+procedure TfdLuminanceAlpha_UB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
-  aData^ :=
-    ((LuminanceWeight(aPixel) and fRange.r) shl fShift.r) or
-    ((aPixel.Data.a           and fRange.a) shl fShift.a);
+  inherited Map(aPixel, aData, aMapData);
+  aData^ := aPixel.Data.a;
   inc(aData);
 end;
 
-procedure TfdLuminance4Alpha4.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
+procedure TfdLuminanceAlpha_UB2.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and fRange.arr[i];
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := aData^;
   inc(aData);
 end;
 
-constructor TfdLuminance4Alpha4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fFormat           := tfLuminance4Alpha4;
-  fWithAlpha        := tfLuminance4Alpha4;
-  fWithoutAlpha     := tfLuminance8;
-  fRange.r          := $F;
-  fRange.g          := $F;
-  fRange.b          := $F;
-  fRange.a          := $F;
-  fShift.a          :=  4;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE4_ALPHA4;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TfdLuminance6Alpha2.Create;
+constructor TfdLuminanceAlpha_UB2.Create;
 begin
   inherited Create;
-  fFormat           := tfLuminance6Alpha2;
-  fWithAlpha        := tfLuminance6Alpha2;
-  fWithoutAlpha     := tfLuminance8;
-  fRange.r          := $3F;
-  fRange.g          := $3F;
-  fRange.b          := $3F;
-  fRange.a          := $03;
-  fShift.a          :=   6;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE6_ALPHA2;
+  fPixelSize        := 2.0;
+  fRange.a          := $FF;
+  fShift.a          :=   8;
+  fglFormat         := GL_LUMINANCE_ALPHA;
   fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGB_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminance8Alpha8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+procedure TfdRGB_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 begin
-  PWord(aData)^ :=
-    ((LuminanceWeight(aPixel) and fRange.r) shl fShift.r) or
-    ((aPixel.Data.a           and fRange.a) shl fShift.a);
-  inc(aData, 2);
+  aData^ := aPixel.Data.r;
+  inc(aData);
+  aData^ := aPixel.Data.g;
+  inc(aData);
+  aData^ := aPixel.Data.b;
+  inc(aData);
 end;
 
-procedure TfdLuminance8Alpha8.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
+procedure TfdRGB_UB3.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
 begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData, 2);
+  aPixel.Data.r := aData^;
+  inc(aData);
+  aPixel.Data.g := aData^;
+  inc(aData);
+  aPixel.Data.b := aData^;
+  inc(aData);
+  aPixel.Data.a := 0;
 end;
 
-constructor TfdLuminance8Alpha8.Create;
+constructor TfdRGB_UB3.Create;
 begin
   inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfLuminance8Alpha8;
-  fWithAlpha        := tfLuminance8Alpha8;
-  fWithoutAlpha     := tfLuminance8;
+  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;
+  inc(aData);
+  aData^ := aPixel.Data.g;
+  inc(aData);
+  aData^ := aPixel.Data.r;
+  inc(aData);
+end;
+
+procedure TfdBGR_UB3.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.b := aData^;
+  inc(aData);
+  aPixel.Data.g := aData^;
+  inc(aData);
+  aPixel.Data.r := 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; var 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          :=   8;
+  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; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := aData^;
+  inc(aData);
+end;
+
+constructor TfdBGRA_UB4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fRange.a          := $FF;
+  fShift.a          :=  24;
+  fglFormat         := GL_BGRA;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdAlpha_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdAlpha_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+end;
+
+procedure TfdAlpha_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := 0;
+  aPixel.Data.g := 0;
+  aPixel.Data.b := 0;
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+constructor TfdAlpha_US1.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fRange.a          := $FFFF;
+  fglFormat         := GL_ALPHA;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminance_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := LuminanceWeight(aPixel);
+  inc(aData, 2);
+end;
+
+procedure TfdLuminance_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PWord(aData)^;
+  aPixel.Data.g := PWord(aData)^;
+  aPixel.Data.b := PWord(aData)^;
+  aPixel.Data.a := 0;
+  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;
-  fglInternalFormat := GL_LUMINANCE8_ALPHA8;
   fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdUniversal_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  PWord(aData)^ := 0;
+  for i := 0 to 3 do
+    if (fRange.arr[i] > 0) then
+      PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
+  inc(aData, 2);
+end;
+
+procedure TfdUniversal_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  for i := 0 to 3 do
+    aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and fRange.arr[i];
+  inc(aData, 2);
+end;
+
+constructor TfdUniversal_US1.Create;
+begin
+  inherited Create;
+  fPixelSize := 2.0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdDepth_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := DepthWeight(aPixel);
+  inc(aData, 2);
+end;
+
+procedure TfdDepth_US1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PWord(aData)^;
+  aPixel.Data.g := PWord(aData)^;
+  aPixel.Data.b := PWord(aData)^;
+  aPixel.Data.a := 0;
+  inc(aData, 2);
+end;
+
+constructor TfdDepth_US1.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminanceAlpha_US2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  inherited Map(aPixel, aData, aMapData);
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+end;
+
+procedure TfdLuminanceAlpha_US2.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+constructor TfdLuminanceAlpha_US2.Create;
+begin
+  inherited Create;
+  fPixelSize        :=   4.0;
+  fRange.a          := $FFFF;
+  fShift.a          :=    16;
+  fglFormat         := GL_LUMINANCE_ALPHA;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGB_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGB_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := aPixel.Data.r;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.g;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.b;
+  inc(aData, 2);
+end;
+
+procedure TfdRGB_US3.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.g := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.b := 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;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.g;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.r;
+  inc(aData, 2);
+end;
+
+procedure TfdBGR_US3.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.b := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.g := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.r := 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);
+end;
+
+procedure TfdRGBA_US4.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+constructor TfdRGBA_US4.Create;
+begin
+  inherited Create;
+  fPixelSize        :=   8.0;
+  fRange.a          := $FFFF;
+  fShift.a          :=    48;
+  fglFormat         := GL_RGBA;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGRA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TfdLuminance12Alpha4.Create;
+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);
+end;
+
+procedure TfdBGRA_US4.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+constructor TfdBGRA_US4.Create;
 begin
   inherited Create;
-  fFormat           := tfLuminance12Alpha4;
-  fWithAlpha        := tfLuminance12Alpha4;
-  fWithoutAlpha     := tfLuminance16;
-  fRange.r          := $FFF;
-  fRange.g          := $FFF;
-  fRange.b          := $FFF;
-  fRange.a          := $00F;
-  fShift.a          :=   12;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE12_ALPHA4;
+  fPixelSize        :=   8.0;
+  fRange.a          := $FFFF;
+  fShift.a          :=    48;
+  fglFormat         := GL_BGRA;
   fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminance16Alpha16.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+procedure TfdUniversal_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  i: Integer;
 begin
-  PCardinal(aData)^ :=
-    ((LuminanceWeight(aPixel) and fRange.r) shl fShift.r) or
-    ((aPixel.Data.a           and fRange.a) shl fShift.a);
+  PCardinal(aData)^ := 0;
+  for i := 0 to 3 do
+    if (fRange.arr[i] > 0) then
+      PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
   inc(aData, 4);
 end;
 
-procedure TfdLuminance16Alpha16.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+procedure TfdUniversal_UI1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
 var
   i: Integer;
 begin
   for i := 0 to 3 do
     aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and fRange.arr[i];
+  inc(aData, 2);
+end;
+
+constructor TfdUniversal_UI1.Create;
+begin
+  inherited Create;
+  fPixelSize := 4.0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdDepth_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PCardinal(aData)^ := DepthWeight(aPixel);
   inc(aData, 4);
 end;
 
-constructor TfdLuminance16Alpha16.Create;
+procedure TfdDepth_UI1.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PCardinal(aData)^;
+  aPixel.Data.g := PCardinal(aData)^;
+  aPixel.Data.b := PCardinal(aData)^;
+  aPixel.Data.a := 0;
+  inc(aData, 4);
+end;
+
+constructor TfdDepth_UI1.Create;
 begin
   inherited Create;
-  fFormat           := tfLuminance16Alpha16;
-  fWithAlpha        := tfLuminance16Alpha16;
-  fWithoutAlpha     := tfLuminance16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fShift.a          :=    16;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE16_ALPHA16;
+  fPixelSize        := 4.0;
+  fRange.r          := $FFFFFFFF;
+  fRange.g          := $FFFFFFFF;
+  fRange.b          := $FFFFFFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
   fglDataFormat     := GL_UNSIGNED_INT;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdR3G3B2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  i: Integer;
+constructor TfdAlpha4.Create;
 begin
-  aData^ := 0;
-  for i := 0 to 3 do
-    if (fRange.arr[i] > 0) then
-      aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
-  inc(aData);
+  inherited Create;
+  fFormat           := tfAlpha4;
+  fWithAlpha        := tfAlpha4;
+  fglInternalFormat := GL_ALPHA4;
 end;
 
-procedure TfdR3G3B2.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
+constructor TfdAlpha8.Create;
 begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData);
+  inherited Create;
+  fFormat           := tfAlpha8;
+  fWithAlpha        := tfAlpha8;
+  fglInternalFormat := GL_ALPHA8;
+end;
+
+constructor TfdAlpha12.Create;
+begin
+  inherited Create;
+  fFormat           := tfAlpha12;
+  fWithAlpha        := tfAlpha12;
+  fglInternalFormat := GL_ALPHA12;
+end;
+
+constructor TfdAlpha16.Create;
+begin
+  inherited Create;
+  fFormat           := tfAlpha16;
+  fWithAlpha        := tfAlpha16;
+  fglInternalFormat := GL_ALPHA16;
+end;
+
+constructor TfdLuminance4.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance4;
+  fWithAlpha        := tfLuminance4Alpha4;
+  fWithoutAlpha     := tfLuminance4;
+  fglInternalFormat := GL_LUMINANCE4;
+end;
+
+constructor TfdLuminance8.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance8;
+  fWithAlpha        := tfLuminance8Alpha8;
+  fWithoutAlpha     := tfLuminance8;
+  fglInternalFormat := GL_LUMINANCE8;
+end;
+
+constructor TfdLuminance12.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance12;
+  fWithAlpha        := tfLuminance12Alpha12;
+  fWithoutAlpha     := tfLuminance12;
+  fglInternalFormat := GL_LUMINANCE12;
+end;
+
+constructor TfdLuminance16.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance16;
+  fWithAlpha        := tfLuminance16Alpha16;
+  fWithoutAlpha     := tfLuminance16;
+  fglInternalFormat := GL_LUMINANCE16;
+end;
+
+constructor TfdLuminance4Alpha4.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance4Alpha4;
+  fWithAlpha        := tfLuminance4Alpha4;
+  fWithoutAlpha     := tfLuminance4;
+  fglInternalFormat := GL_LUMINANCE4_ALPHA4;
+end;
+
+constructor TfdLuminance6Alpha2.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance6Alpha2;
+  fWithAlpha        := tfLuminance6Alpha2;
+  fWithoutAlpha     := tfLuminance8;
+  fglInternalFormat := GL_LUMINANCE6_ALPHA2;
+end;
+
+constructor TfdLuminance8Alpha8.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance8Alpha8;
+  fWithAlpha        := tfLuminance8Alpha8;
+  fWithoutAlpha     := tfLuminance8;
+  fglInternalFormat := GL_LUMINANCE8_ALPHA8;
+end;
+
+constructor TfdLuminance12Alpha4.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance12Alpha4;
+  fWithAlpha        := tfLuminance12Alpha4;
+  fWithoutAlpha     := tfLuminance12;
+  fglInternalFormat := GL_LUMINANCE12_ALPHA4;
+end;
+
+constructor TfdLuminance12Alpha12.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance12Alpha12;
+  fWithAlpha        := tfLuminance12Alpha12;
+  fWithoutAlpha     := tfLuminance12;
+  fglInternalFormat := GL_LUMINANCE12_ALPHA12;
+end;
+
+constructor TfdLuminance16Alpha16.Create;
+begin
+  inherited Create;
+  fFormat           := tfLuminance16Alpha16;
+  fWithAlpha        := tfLuminance16Alpha16;
+  fWithoutAlpha     := tfLuminance16;
+  fglInternalFormat := GL_LUMINANCE16_ALPHA16;
 end;
 
 constructor TfdR3G3B2.Create;
 begin
   inherited Create;
-  fPixelSize        := 1.0;
   fFormat           := tfR3G3B2;
   fWithAlpha        := tfRGBA2;
   fWithoutAlpha     := tfR3G3B2;
@@ -2345,39 +2886,15 @@ begin
   fRange.b          := $3;
   fShift.r          :=  0;
   fShift.g          :=  3;
-  fShift.b          :=  5;
+  fShift.b          :=  6;
   fglFormat         := GL_RGB;
   fglInternalFormat := GL_R3_G3_B2;
   fglDataFormat     := GL_UNSIGNED_BYTE_2_3_3_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGB4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  PWord(aData)^ := 0;
-  for i := 0 to 3 do
-    if (fRange.arr[i] > 0) then
-      PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
-  inc(aData, 2);
-end;
-
-procedure TfdRGB4.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData, 2);
-end;
-
 constructor TfdRGB4.Create;
 begin
   inherited Create;
-  fPixelSize        := 2.0;
   fFormat           := tfRGB4;
   fWithAlpha        := tfRGBA4;
   fWithoutAlpha     := tfRGB4;
@@ -2392,13 +2909,9 @@ begin
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdR5G6B5.Create;
 begin
   inherited Create;
-  fPixelSize        := 2.0;
   fFormat           := tfR5G6B5;
   fWithAlpha        := tfRGBA4;
   fWithoutAlpha     := tfR5G6B5;
@@ -2409,17 +2922,13 @@ begin
   fShift.g          :=   5;
   fShift.b          :=  11;
   fglFormat         := GL_RGB;
-  fglInternalFormat := GL_RGB8;
+  fglInternalFormat := GL_RGB565;
   fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdRGB5.Create;
 begin
   inherited Create;
-  fPixelSize        := 2.0;
   fFormat           := tfRGB5;
   fWithAlpha        := tfRGB5A1;
   fWithoutAlpha     := tfRGB5;
@@ -2434,75 +2943,18 @@ begin
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGB8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  aData^ := aPixel.Data.r;
-  inc(aData);
-  aData^ := aPixel.Data.g;
-  inc(aData);
-  aData^ := aPixel.Data.b;
-  inc(aData);
-end;
-
-procedure TfdRGB8.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := aData^;
-  inc(aData);
-  aPixel.Data.g := aData^;
-  inc(aData);
-  aPixel.Data.b := aData^;
-  inc(aData);
-  aPixel.Data.a := 0;
-end;
-
 constructor TfdRGB8.Create;
 begin
   inherited Create;
-  fPixelSize        := 3.0;
   fFormat           := tfRGB8;
   fWithAlpha        := tfRGBA8;
-  fWithoutAlpha     := tfRGB8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fShift.r          :=   0;
-  fShift.g          :=   8;
-  fShift.b          :=  16;
-  fglFormat         := GL_RGB;
-  fglInternalFormat := GL_RGB8;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGB10.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  PCardinal(aData)^ := 0;
-  for i := 0 to 3 do
-    if (fRange.arr[i] > 0) then
-      PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
-  inc(aData, 4);
-end;
-
-procedure TfdRGB10.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData, 4);
+  fWithoutAlpha     := tfRGB8;
+  fglInternalFormat := GL_RGB8;
 end;
 
 constructor TfdRGB10.Create;
 begin
   inherited Create;
-  fPixelSize        := 4.0;
   fFormat           := tfRGB10;
   fWithAlpha        := tfRGB10A2;
   fWithoutAlpha     := tfRGB10;
@@ -2512,78 +2964,38 @@ begin
   fShift.r          :=    0;
   fShift.g          :=   10;
   fShift.b          :=   20;
-  fglFormat         := GL_RGB;
+  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;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGB16.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.r;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.g;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.b;
-  inc(aData, 2);
-end;
-
-procedure TfdRGB16.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+constructor TfdRGB12.Create;
 begin
-  aPixel.Data.r := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.g := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.b := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.a := 0;
+  inherited Create;
+  fFormat           := tfRGB12;
+  fWithAlpha        := tfRGBA12;
+  fWithoutAlpha     := tfRGB12;
+  fglInternalFormat := GL_RGB12;
 end;
 
 constructor TfdRGB16.Create;
 begin
   inherited Create;
-  fPixelSize        := 6.0;
   fFormat           := tfRGB16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fShift.r          :=     0;
-  fShift.g          :=    16;
-  fShift.b          :=    32;
-  fglFormat         := GL_RGB;
   fglInternalFormat := GL_RGB16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdRGBA2.Create;
 begin
   inherited Create;
   fFormat           := tfRGBA2;
   fWithAlpha        := tfRGBA2;
   fWithoutAlpha     := tfR3G3B2;
-  fRange.r          := $3;
-  fRange.g          := $3;
-  fRange.b          := $3;
-  fRange.a          := $3;
-  fShift.r          :=  0;
-  fShift.g          :=  2;
-  fShift.b          :=  4;
-  fShift.a          :=  6;
-  fglFormat         := GL_RGBA;
   fglInternalFormat := GL_RGBA2;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdRGBA4.Create;
 begin
   inherited Create;
@@ -2603,9 +3015,6 @@ begin
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdRGB5A1.Create;
 begin
   inherited Create;
@@ -2625,46 +3034,15 @@ begin
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBA8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  aData^ := aPixel.Data.a;
-  inc(aData);
-end;
-
-procedure TfdRGBA8.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := aData^;
-  inc(aData);
-end;
-
 constructor TfdRGBA8.Create;
 begin
   inherited Create;
-  fPixelSize        := 4.0;
   fFormat           := tfRGBA8;
   fWithAlpha        := tfRGBA8;
   fWithoutAlpha     := tfRGB8;
-  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_BYTE;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdRGB10A2.Create;
 begin
   inherited Create;
@@ -2684,46 +3062,24 @@ begin
   fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBA16.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-end;
-
-procedure TfdRGBA16.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+constructor TfdRGBA12.Create;
 begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
+  inherited Create;
+  fFormat           := tfRGBA12;
+  fWithAlpha        := tfRGBA12;
+  fWithoutAlpha     := tfRGB12;
+  fglInternalFormat := GL_RGBA12;
 end;
 
 constructor TfdRGBA16.Create;
 begin
   inherited Create;
-  fPixelSize        := 8.0;
   fFormat           := tfRGBA16;
   fWithAlpha        := tfRGBA16;
   fWithoutAlpha     := tfRGB16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fShift.r          :=     0;
-  fShift.g          :=    16;
-  fShift.b          :=    32;
-  fShift.a          :=    48;
-  fglFormat         := GL_RGBA;
   fglInternalFormat := GL_RGBA16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdBGR4.Create;
 begin
   inherited Create;
@@ -2750,7 +3106,6 @@ end;
 constructor TfdB5G6R5.Create;
 begin
   inherited Create;
-  fPixelSize        := 2.0;
   fFormat           := tfB5G6R5;
   fWithAlpha        := tfBGRA4;
   fWithoutAlpha     := tfB5G6R5;
@@ -2760,7 +3115,7 @@ begin
   fShift.r          :=  11;
   fShift.g          :=   5;
   fShift.b          :=   0;
-  fglFormat         := GL_RGB;
+  fglFormat         := GL_RGB;  //B5G6R5 is only possible as R5G6B5 -> use reverted dataformat
   fglInternalFormat := GL_RGB8;
   fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5;
 end;
@@ -2788,53 +3143,15 @@ begin
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGR8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  aData^ := aPixel.Data.b;
-  inc(aData);
-  aData^ := aPixel.Data.g;
-  inc(aData);
-  aData^ := aPixel.Data.r;
-  inc(aData);
-end;
-
-procedure TfdBGR8.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.b := aData^;
-  inc(aData);
-  aPixel.Data.g := aData^;
-  inc(aData);
-  aPixel.Data.r := aData^;
-  inc(aData);
-  aPixel.Data.a := 0;
-end;
-
 constructor TfdBGR8.Create;
 begin
   inherited Create;
-  fPixelSize        := 3.0;
   fFormat           := tfBGR8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $00;
-  fShift.r          :=  16;
-  fShift.g          :=   8;
-  fShift.b          :=   0;
-  fShift.a          :=   0;
-  fglFormat         := GL_BGR;
   fglInternalFormat := GL_RGB8;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdBGR10.Create;
 begin
   inherited Create;
@@ -2849,80 +3166,38 @@ begin
   fShift.g          :=   10;
   fShift.b          :=    0;
   fShift.a          :=    0;
-  fglFormat         := GL_BGR;
+  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;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGR16.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.b;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.g;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.r;
-  inc(aData, 2);
-end;
-
-procedure TfdBGR16.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+constructor TfdBGR12.Create;
 begin
-  aPixel.Data.b := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.g := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.r := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.a := 0;
+  inherited Create;
+  fFormat           := tfBGR12;
+  fWithAlpha        := tfBGRA12;
+  fWithoutAlpha     := tfBGR12;
+  fglInternalFormat := GL_RGB12;
 end;
 
 constructor TfdBGR16.Create;
 begin
   inherited Create;
-  fPixelSize        := 6.0;
   fFormat           := tfBGR16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $0000;
-  fShift.r          :=    32;
-  fShift.g          :=    16;
-  fShift.b          :=     0;
-  fShift.a          :=     0;
-  fglFormat         := GL_BGR;
   fglInternalFormat := GL_RGB16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdBGRA2.Create;
 begin
   inherited Create;
   fFormat           := tfBGRA2;
   fWithAlpha        := tfBGRA4;
   fWithoutAlpha     := tfBGR4;
-  fRange.r          := $3;
-  fRange.g          := $3;
-  fRange.b          := $3;
-  fRange.a          := $3;
-  fShift.r          :=  4;
-  fShift.g          :=  2;
-  fShift.b          :=  0;
-  fShift.a          :=  6;
-  fglFormat         := GL_BGRA;
   fglInternalFormat := GL_RGBA2;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdBGRA4.Create;
 begin
   inherited Create;
@@ -2942,9 +3217,6 @@ begin
   fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdBGR5A1.Create;
 begin
   inherited Create;
@@ -2964,46 +3236,15 @@ begin
   fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////s
-procedure TfdBGRA8.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  aData^ := aPixel.Data.a;
-  inc(aData);
-end;
-
-procedure TfdBGRA8.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := aData^;
-  inc(aData);
-end;
-
 constructor TfdBGRA8.Create;
 begin
   inherited Create;
-  fPixelSize        := 4.0;
   fFormat           := tfBGRA8;
   fWithAlpha        := tfBGRA8;
   fWithoutAlpha     := tfBGR8;
-  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_BYTE;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TfdBGR10A2.Create;
 begin
   inherited Create;
@@ -3023,41 +3264,49 @@ begin
   fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
 end;
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRA16.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-end;
-
-procedure TfdBGRA16.Unmap(var aData: PByte; var aPixel: TglBitmapPixelData; var aMapData: Pointer);
+constructor TfdBGRA12.Create;
 begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
+  inherited Create;
+  fFormat           := tfBGRA12;
+  fWithAlpha        := tfBGRA12;
+  fWithoutAlpha     := tfBGR12;
+  fglInternalFormat := GL_RGBA12;
 end;
 
 constructor TfdBGRA16.Create;
 begin
   inherited Create;
-  fPixelSize        := 8.0;
   fFormat           := tfBGRA16;
   fWithAlpha        := tfBGRA16;
   fWithoutAlpha     := tfBGR16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fShift.r          :=    32;
-  fShift.g          :=    16;
-  fShift.b          :=     0;
-  fShift.a          :=    48;
-  fglFormat         := GL_BGRA;
   fglInternalFormat := GL_RGBA16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdDepth16.Create;
+begin
+  inherited Create;
+  fFormat           := tfDepth16;
+  fWithAlpha        := tfEmpty;
+  fWithoutAlpha     := tfDepth16;
+  fglInternalFormat := GL_DEPTH_COMPONENT16;
+end;
+
+constructor TfdDepth24.Create;
+begin
+  inherited Create;
+  fFormat           := tfDepth24;
+  fWithAlpha        := tfEmpty;
+  fWithoutAlpha     := tfDepth24;
+  fglInternalFormat := GL_DEPTH_COMPONENT24;
+end;
+
+constructor TfdDepth32.Create;
+begin
+  inherited Create;
+  fFormat           := tfDepth32;
+  fWithAlpha        := tfEmpty;
+  fWithoutAlpha     := tfDepth32;
+  fglInternalFormat := GL_DEPTH_COMPONENT32;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -4482,7 +4731,7 @@ var
   end;
 
 begin
-  if aFormat <> fFormat then begin
+  if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin
     SourceFD := TFormatDescriptor.Get(Format);
     DestFD   := TFormatDescriptor.Get(aFormat);
 
@@ -5919,33 +6168,28 @@ begin
   Info.biCompression := BMP_COMP_RGB;
   Info.biSizeImage   := ImageSize;
   case Format of
-    //TODO tfAlpha8, ifLuminance8, ifDepth8:
-    tfLuminance8:
-      begin
-        Info.biBitCount :=  8;
+    tfR3G3B2, tfLuminance8: begin
+      Info.biBitCount  :=  8;
+      Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal);
+    end;
 
-        Header.bfSize := Header.bfSize + 256 * SizeOf(Cardinal);
-        Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal);
+    tfRGB5, tfRGB5A1, tfR5G6B5, tfRGB4, tfRGBA4,
+    tfBGR5, tfBGR5A1, tfB5G6R5, tfBGR4, tfBGRA4: begin
+      Info.biBitCount    := 16;
+      Info.biCompression := BMP_COMP_BITFIELDS;
+    end;
 
-        Info.biClrUsed := 256;
-        Info.biClrImportant := 256;
-      end;
-    //TODO ifLuminance8Alpha8, tfRGBA4, ifR5G6B5, tfRGB5A1:
-    tfLuminance8Alpha8, tfRGB5A1:
-      begin
-        Info.biBitCount := 16;
-        Info.biCompression := BMP_COMP_BITFIELDS;
-      end;
-    tfBGR8, tfRGB8:
+    tfBGR8, tfRGB8: begin
       Info.biBitCount := 24;
-    //TODO tfBGRA8, tfRGBA8, tfRGB10A2:
-    tfBGRA8, tfRGBA8:
-      begin
-        Info.biBitCount := 32;
-        Info.biCompression := BMP_COMP_BITFIELDS;
-      end;
-    else
-      raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
+    end;
+
+    tfRGB10, tfRGB10A2, tfRGBA8,
+    tfBGR10, tfBGR10A2, tfBGRA8: begin
+      Info.biBitCount    := 32;
+      Info.biCompression := BMP_COMP_BITFIELDS;
+    end;
+  else
+    raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
   end;
   Info.biXPelsPerMeter := 2835;
   Info.biYPelsPerMeter := 2835;