* implemented CubeMaps

glBitmap.pas

@@ -1008,13 +1008,11 @@ type
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   TglBitmap2D = class(TglBitmap)
   protected
-    // Bildeinstellungen
     fLines: array of PByte;
-
     function GetScanline(const aIndex: Integer): Pointer;
     procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
       const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
-    procedure UploadData(const aBuildWithGlu: Boolean);
+    procedure UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean);
   public
     property Width;
     property Height;
@@ -1033,34 +1031,25 @@ type
       const aScale: Single = 2; const aUseAlpha: Boolean = false);
   end;
 
-(* TODO
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   TglBitmapCubeMap = class(TglBitmap2D)
   protected
     fGenMode: Integer;
-
-    // Hide GenTexture
-    procedure GenTexture(TestTextureSize: Boolean = true); reintroduce;
+    procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce;
   public
     procedure AfterConstruction; override;
-
-    procedure GenerateCubeMap(CubeTarget: Cardinal; TestTextureSize: Boolean = true);
-
-    procedure Unbind(DisableTexCoordsGen: Boolean = true; DisableTextureUnit: Boolean = true); reintroduce; virtual;
-    procedure Bind(EnableTexCoordsGen: Boolean = true; EnableTextureUnit: Boolean = true); reintroduce; virtual;
+    procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true);
+    procedure Bind(const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true); reintroduce; virtual;
+    procedure Unbind(const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true); reintroduce; virtual;
   end;
 
-
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   TglBitmapNormalMap = class(TglBitmapCubeMap)
   public
     procedure AfterConstruction; override;
-
-    procedure GenerateNormalMap(Size: Integer = 32; TestTextureSize: Boolean = true);
+    procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true);
   end;
 
-
-
-*)
-
 const
   NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0);
 
@@ -7575,7 +7564,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.UploadData(const aBuildWithGlu: Boolean);
+procedure TglBitmap2D.UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean);
 var
   FormatDesc: TFormatDescriptor;
 begin
@@ -7583,12 +7572,12 @@ begin
 
   FormatDesc := TFormatDescriptor.Get(Format);
   if FormatDesc.IsCompressed then begin
-    glCompressedTexImage2D(Target, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data)
+    glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data)
   end else if aBuildWithGlu then begin
-    gluBuild2DMipmaps(Target, FormatDesc.Components, Width, Height,
+    gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height,
       FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
   end else begin
-    glTexImage2D(Target, 0, FormatDesc.glInternalFormat, Width, Height, 0,
+    glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0,
       FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
   end;
 
@@ -7694,7 +7683,7 @@ begin
 
     CreateId;
     SetupParameters(BuildWithGlu);
-    UploadData(BuildWithGlu);
+    UploadData(Target, BuildWithGlu);
     glAreTexturesResident(1, @fID, @fIsResident);
   end;
 end;
@@ -7983,20 +7972,15 @@ begin
   end;
 end;
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapCubeMap////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean);
+begin
+  Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.');
+end;
 
-
-
-
-
-
-
-
-(*
-
-
-
-{ TglBitmapCubeMap }
-
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmapCubeMap.AfterConstruction;
 begin
   inherited;
@@ -8004,80 +7988,64 @@ begin
   if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then
     raise EglBitmapException.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
 
-  SetWrap; // set all to GL_CLAMP_TO_EDGE
-  Target := GL_TEXTURE_CUBE_MAP;
+  SetWrap;
+  Target   := GL_TEXTURE_CUBE_MAP;
   fGenMode := GL_REFLECTION_MAP;
 end;
 
-
-procedure TglBitmapCubeMap.Bind(EnableTexCoordsGen, EnableTextureUnit: Boolean);
-begin
-  inherited Bind (EnableTextureUnit);
-
-  if EnableTexCoordsGen then begin
-    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode);
-    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode);
-    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode);
-    glEnable(GL_TEXTURE_GEN_S);
-    glEnable(GL_TEXTURE_GEN_T);
-    glEnable(GL_TEXTURE_GEN_R);
-  end;
-end;
-
-
-procedure TglBitmapCubeMap.GenerateCubeMap(CubeTarget: Cardinal; TestTextureSize: Boolean);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean);
 var
-  glFormat, glInternalFormat, glType: Cardinal;
   BuildWithGlu: Boolean;
   TexSize: Integer;
 begin
-  // Check Texture Size
-  if (TestTextureSize) then begin
+  if (aTestTextureSize) then begin
     glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize);
 
-    if ((Height > TexSize) or (Width > TexSize)) then
+    if (Height > TexSize) or (Width > TexSize) then
       raise EglBitmapSizeToLargeException.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
 
-    if not ((IsPowerOfTwo (Height) and IsPowerOfTwo (Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
+    if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
       raise EglBitmapNonPowerOfTwoException.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.');
   end;
 
-  // create Texture
-  if ID = 0 then begin
+  if (ID = 0) then
     CreateID;
-    SetupParameters(BuildWithGlu);
-  end;
-
-  SelectFormat(InternalFormat, glFormat, glInternalFormat, glType);
-
-  UploadData (CubeTarget, glFormat, glInternalFormat, glType, BuildWithGlu);
+  SetupParameters(BuildWithGlu);
+  UploadData(aCubeTarget, BuildWithGlu);
 end;
 
-
-procedure TglBitmapCubeMap.GenTexture(TestTextureSize: Boolean);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.Bind(const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean);
 begin
-  Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.');
+  inherited Bind (aEnableTextureUnit);
+  if aEnableTexCoordsGen then begin
+    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode);
+    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode);
+    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode);
+    glEnable(GL_TEXTURE_GEN_S);
+    glEnable(GL_TEXTURE_GEN_T);
+    glEnable(GL_TEXTURE_GEN_R);
+  end;
 end;
 
-
-procedure TglBitmapCubeMap.Unbind(DisableTexCoordsGen,
-  DisableTextureUnit: Boolean);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.Unbind(const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean);
 begin
-  inherited Unbind (DisableTextureUnit);
-
-  if DisableTexCoordsGen then begin
+  inherited Unbind(aDisableTextureUnit);
+  if aDisableTexCoordsGen then begin
     glDisable(GL_TEXTURE_GEN_S);
     glDisable(GL_TEXTURE_GEN_T);
     glDisable(GL_TEXTURE_GEN_R);
   end;
 end;
 
-
-{ TglBitmapNormalMap }
-
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapNormalMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type
   TVec = Array[0..2] of Single;
-  TglBitmapNormalMapGetVectorFunc = procedure (var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer);
+  TglBitmapNormalMapGetVectorFunc = procedure (out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
 
   PglBitmapNormalMapRec = ^TglBitmapNormalMapRec;
   TglBitmapNormalMapRec = record
@@ -8085,62 +8053,63 @@ type
     Func: TglBitmapNormalMapGetVectorFunc;
   end;
 
-
-procedure glBitmapNormalMapPosX(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer);
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
 begin
-  Vec[0] := HalfSize;
-  Vec[1] := - (Position.Y + 0.5 - HalfSize);
-  Vec[2] := - (Position.X + 0.5 - HalfSize);
+  aVec[0] := aHalfSize;
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := - (aPosition.X + 0.5 - aHalfSize);
 end;
 
-
-procedure glBitmapNormalMapNegX(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
 begin
-  Vec[0] := - HalfSize;
-  Vec[1] := - (Position.Y + 0.5 - HalfSize);
-  Vec[2] := Position.X + 0.5 - HalfSize;
+  aVec[0] := - aHalfSize;
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := aPosition.X + 0.5 - aHalfSize;
 end;
 
-
-procedure glBitmapNormalMapPosY(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
 begin
-  Vec[0] := Position.X + 0.5 - HalfSize;
-  Vec[1] := HalfSize;
-  Vec[2] := Position.Y + 0.5 - HalfSize;
+  aVec[0] := aPosition.X + 0.5 - aHalfSize;
+  aVec[1] := aHalfSize;
+  aVec[2] := aPosition.Y + 0.5 - aHalfSize;
 end;
 
-
-procedure glBitmapNormalMapNegY(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
 begin
-  Vec[0] := Position.X + 0.5 - HalfSize;
-  Vec[1] := - HalfSize;
-  Vec[2] := - (Position.Y + 0.5 - HalfSize);
+  aVec[0] := aPosition.X + 0.5 - aHalfSize;
+  aVec[1] := - aHalfSize;
+  aVec[2] := - (aPosition.Y + 0.5 - aHalfSize);
 end;
 
-
-procedure glBitmapNormalMapPosZ(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
 begin
-  Vec[0] := Position.X + 0.5 - HalfSize;
-  Vec[1] := - (Position.Y + 0.5 - HalfSize);
-  Vec[2] := HalfSize;
+  aVec[0] := aPosition.X + 0.5 - aHalfSize;
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := aHalfSize;
 end;
 
-
-procedure glBitmapNormalMapNegZ(var Vec: TVec; const Position: TglBitmapPixelPosition; const HalfSize: Integer);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
 begin
-  Vec[0] := - (Position.X + 0.5 - HalfSize);
-  Vec[1] := - (Position.Y + 0.5 - HalfSize);
-  Vec[2] := - HalfSize;
+  aVec[0] := - (aPosition.X + 0.5 - aHalfSize);
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := - aHalfSize;
 end;
 
-
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure glBitmapNormalMapFunc(var FuncRec: TglBitmapFunctionRec);
 var
-  Vec : TVec;
+  i: Integer;
+  Vec: TVec;
   Len: Single;
 begin
   with FuncRec do begin
-    with PglBitmapNormalMapRec (CustomData)^ do begin
+    with PglBitmapNormalMapRec(Args)^ do begin
       Func(Vec, Position, HalfSize);
 
       // Normalize
@@ -8158,66 +8127,62 @@ begin
     end;
 
     // Set Color
-    Dest.Red   := Round(Vec[0] * 255);
-    Dest.Green := Round(Vec[1] * 255);
-    Dest.Blue  := Round(Vec[2] * 255);
+    for i := 0 to 2 do
+      Dest.Data.arr[i] := Round(Vec[i] * 255);
   end;
 end;
 
-
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmapNormalMap.AfterConstruction;
 begin
   inherited;
-
   fGenMode := GL_NORMAL_MAP;
 end;
 
-
-procedure TglBitmapNormalMap.GenerateNormalMap(Size: Integer;
-  TestTextureSize: Boolean);
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean);
 var
   Rec: TglBitmapNormalMapRec;
   SizeRec: TglBitmapPixelPosition;
 begin
-  Rec.HalfSize := Size div 2;
-
+  Rec.HalfSize := aSize div 2;
   FreeDataAfterGenTexture := false;
 
   SizeRec.Fields := [ffX, ffY];
-  SizeRec.X := Size;
-  SizeRec.Y := Size;
+  SizeRec.X := aSize;
+  SizeRec.Y := aSize;
 
   // Positive X
   Rec.Func := glBitmapNormalMapPosX;
-  LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, TestTextureSize);
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize);
 
   // Negative X
   Rec.Func := glBitmapNormalMapNegX;
-  LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, TestTextureSize);
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize);
 
   // Positive Y
   Rec.Func := glBitmapNormalMapPosY;
-  LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, TestTextureSize);
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize);
 
   // Negative Y
   Rec.Func := glBitmapNormalMapNegY;
-  LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, TestTextureSize);
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize);
 
   // Positive Z
   Rec.Func := glBitmapNormalMapPosZ;
-  LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, TestTextureSize);
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize);
 
   // Negative Z
   Rec.Func := glBitmapNormalMapNegZ;
-  LoadFromFunc (SizeRec, glBitmapNormalMapFunc, ifBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, TestTextureSize);
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize);
 end;
-*)
+
 
 initialization
   glBitmapSetDefaultFormat(tfEmpty);