* implemented TglBitmap1D

* fixed some memory issues

diff --git a/glBitmap.pas b/glBitmap.pas
index 38ddefd..0b4d037 100644 (file)
--- a/glBitmap.pas
+++ b/glBitmap.pas
@@ -4,7 +4,6 @@ http://www.opengl24.de/index.php?cat=header&file=glbitmap
 
 modified by Delphi OpenGL Community (http://delphigl.com/)
 
 
 modified by Delphi OpenGL Community (http://delphigl.com/)
 

-

 ------------------------------------------------------------
 The contents of this file are used with permission, subject to
 the Mozilla Public License Version 1.1 (the "License"); you may
 ------------------------------------------------------------
 The contents of this file are used with permission, subject to
 the Mozilla Public License Version 1.1 (the "License"); you may


@@ -241,7 +240,8 @@ unit glBitmap;
 {.$DEFINE GLB_DELPHI}
 
 // activate to enable the support for TLazIntfImage from Lazarus
 {.$DEFINE GLB_DELPHI}
 
 // activate to enable the support for TLazIntfImage from Lazarus

-{.$DEFINE GLB_LAZARUS}
+{$DEFINE GLB_LAZARUS}
+

 
 
 // activate to enable the support of SDL_image to load files. (READ ONLY)
 
 
 // activate to enable the support of SDL_image to load files. (READ ONLY)


@@ -846,8 +846,8 @@ type
 
     procedure CreateID;
     procedure SetupParameters(out aBuildWithGlu: Boolean);
 
     procedure CreateID;
     procedure SetupParameters(out aBuildWithGlu: Boolean);

-    procedure SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat;
-      const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;
+    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+      const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;  //be careful, aData could be freed by this method

     procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;
 
     function FlipHorz: Boolean; virtual;
     procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;
 
     function FlipHorz: Boolean; virtual;


@@ -993,15 +993,28 @@ type
   end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+  TglBitmap1D = class(TglBitmap)
+  protected
+    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+      const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
+    procedure UploadData(const aBuildWithGlu: Boolean);
+  public
+    property Width;
+    procedure AfterConstruction; override;
+    function FlipHorz: Boolean; override;
+    procedure GenTexture(const aTestTextureSize: Boolean = true); override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   TglBitmap2D = class(TglBitmap)
   protected
     // Bildeinstellungen
     fLines: array of PByte;
 
     function GetScanline(const aIndex: Integer): Pointer;
   TglBitmap2D = class(TglBitmap)
   protected
     // Bildeinstellungen
     fLines: array of PByte;
 
     function GetScanline(const aIndex: Integer): Pointer;

-    procedure SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat;
+    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;

       const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
       const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;

-    procedure UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean);
+    procedure UploadData(const aBuildWithGlu: Boolean);

   public
     property Width;
     property Height;
   public
     property Width;
     property Height;


@@ -1045,24 +1058,7 @@ type
   end;
 
 
   end;
 
 

-  TglBitmap1D = class(TglBitmap)
-  protected
-    procedure GetPixel1DUnmap(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData);
-
-    procedure SetDataPointer(Data: pByte; Format: TglBitmapInternalFormat; Width: Integer = -1; Height: Integer = -1); override;
-    procedure UploadData (Target, Format, InternalFormat, Typ: Cardinal; BuildWithGlu: Boolean);
-  public
-    // propertys
-    property Width;
-
-    procedure AfterConstruction; override;
-
-    // Other
-    function FlipHorz: Boolean; override;

 
 

-    // Generation
-    procedure GenTexture(TestTextureSize: Boolean = true); override;
-  end;

 *)
 
 const
 *)
 
 const


@@ -2054,42 +2050,6 @@ begin
 end;
 {$ENDIF}
 
 end;
 {$ENDIF}
 

-(* TODO GLB_DELPHI
-{$IFDEF GLB_DELPHI}
-function CreateGrayPalette: HPALETTE;
-var
-  Idx: Integer;
-  Pal: PLogPalette;
-begin
-  GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256));
-
-  Pal.palVersion := $300;
-  Pal.palNumEntries := 256;
-
-  {$IFOPT R+}
-    {$DEFINE GLB_TEMPRANGECHECK}
-    {$R-}
-  {$ENDIF}
-
-  for Idx := 0 to 256 - 1 do begin
-    Pal.palPalEntry[Idx].peRed   := Idx;
-    Pal.palPalEntry[Idx].peGreen := Idx;
-    Pal.palPalEntry[Idx].peBlue  := Idx;
-    Pal.palPalEntry[Idx].peFlags := 0;
-  end;
-
-  {$IFDEF GLB_TEMPRANGECHECK}
-    {$UNDEF GLB_TEMPRANGECHECK}
-    {$R+}
-  {$ENDIF}
-
-  result := CreatePalette(Pal^);
-
-  FreeMem(Pal);
-end;
-{$ENDIF}
-*)
-

 {$IFDEF GLB_SDL_IMAGE}
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 {$IFDEF GLB_SDL_IMAGE}
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


@@ -4064,7 +4024,7 @@ begin
     exit;
   if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then
     raise EglBitmapUnsupportedFormat.Create(Format);
     exit;
   if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then
     raise EglBitmapUnsupportedFormat.Create(Format);

-  SetDataPointer(Data, aValue, Width, Height);
+  SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method

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


@@ -4150,7 +4110,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-procedure TglBitmap.SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat;
+procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;

   const aWidth: Integer; const aHeight: Integer);
 var
   s: Single;
   const aWidth: Integer; const aHeight: Integer);
 var
   s: Single;


@@ -4218,8 +4178,11 @@ end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmap.BeforeDestruction;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmap.BeforeDestruction;

+var
+  NewData: PByte;

 begin
 begin

-  SetDataPointer(nil, tfEmpty);
+  NewData := nil;
+  SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method

   if (fID > 0) and fDeleteTextureOnFree then
     glDeleteTextures(1, @fID);
   inherited BeforeDestruction;
   if (fID > 0) and fDeleteTextureOnFree then
     glDeleteTextures(1, @fID);
   inherited BeforeDestruction;


@@ -4280,9 +4243,10 @@ begin
   GetMem(tmpData, size);
   try
     FillChar(tmpData^, size, #$FF);
   GetMem(tmpData, size);
   try
     FillChar(tmpData^, size, #$FF);

-    SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y);
+    SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method

   except
   except

-    FreeMem(tmpData);
+    if Assigned(tmpData) then
+      FreeMem(tmpData);

     raise;
   end;
   AddFunc(Self, aFunc, false, Format, aArgs);
     raise;
   end;
   AddFunc(Self, aFunc, false, Format, aArgs);


@@ -4420,7 +4384,7 @@ begin
 
         // Updating Image or InternalFormat
         if aCreateTemp then
 
         // Updating Image or InternalFormat
         if aCreateTemp then

-          SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height)
+          SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) //be careful, Data could be freed by this method

         else if (aFormat <> fFormat) then
           Format := aFormat;
 
         else if (aFormat <> fFormat) then
           Format := aFormat;
 


@@ -4430,7 +4394,7 @@ begin
         DestFD.FreeMappingData(DestMD);
       end;
     except
         DestFD.FreeMappingData(DestMD);
       end;
     except

-      if aCreateTemp then
+      if aCreateTemp and Assigned(TmpData) then

         FreeMem(TmpData);
       raise;
     end;
         FreeMem(TmpData);
       raise;
     end;


@@ -4525,10 +4489,11 @@ begin
           Inc(pTempData, RowSize);
         end;
       end;
           Inc(pTempData, RowSize);
         end;
       end;

-      SetDataPointer(pData, IntFormat, TempWidth, TempHeight);
+      SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method

       result := true;
     except
       result := true;
     except

-      FreeMem(pData);
+      if Assigned(pData) then
+        FreeMem(pData);

       raise;
     end;
   end;
       raise;
     end;
   end;


@@ -4694,10 +4659,11 @@ begin
           Inc(pTempData, RowSize);
         end;
       end;
           Inc(pTempData, RowSize);
         end;
       end;

-      SetDataPointer(pData, IntFormat, TempWidth, TempHeight);
+      SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method

       result := true;
     except
       result := true;
     except

-      FreeMem(pData);
+      if Assigned(pData) then
+        FreeMem(pData);

       raise;
     end;
   end;
       raise;
     end;
   end;


@@ -4843,9 +4809,10 @@ begin
   ImageData := GetMem(ImageSize);
   try
     Move(aImage.PixelData^, ImageData^, (aImage.Width * aImage.Height * aImage.DataDescription.BitsPerPixel) shr 3);
   ImageData := GetMem(ImageSize);
   try
     Move(aImage.PixelData^, ImageData^, (aImage.Width * aImage.Height * aImage.DataDescription.BitsPerPixel) shr 3);

-    SetDataPointer(ImageData, f, aImage.Width, aImage.Height);
+    SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method

   except
   except

-    FreeMem(ImageData);
+    if Assigned(ImageData) then
+      FreeMem(ImageData);

     raise;
   end;
 
     raise;
   end;
 


@@ -5177,13 +5144,16 @@ begin
       GetMem(TempPtr, Size);
       try
         Move(Data^, TempPtr^, Size);
       GetMem(TempPtr, Size);
       try
         Move(Data^, TempPtr^, Size);

-        Temp.SetDataPointer(TempPtr, Format, Width, Height);
+        Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method

       except
       except

-        FreeMem(TempPtr);
+        if Assigned(TempPtr) then
+          FreeMem(TempPtr);

         raise;
       end;
         raise;
       end;

-    end else
-      Temp.SetDataPointer(nil, Format, Width, Height);
+    end else begin
+      TempPtr := nil;
+      Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method
+    end;

 
        // copy properties
     Temp.fID                      := ID;
 
        // copy properties
     Temp.fID                      := ID;


@@ -5291,8 +5261,11 @@ end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmap.FreeData;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmap.FreeData;

+var
+  TempPtr: PByte;

 begin
 begin

-  SetDataPointer(nil, tfEmpty);
+  TempPtr := nil;
+  SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method

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


@@ -5450,11 +5423,11 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TglBitmap.Create;
 begin
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 constructor TglBitmap.Create;
 begin

+  if (ClassType = TglBitmap) then
+    raise EglBitmapException.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');

 {$IFDEF GLB_NATIVE_OGL}
   glbReadOpenGLExtensions;
 {$ENDIF}
 {$IFDEF GLB_NATIVE_OGL}
   glbReadOpenGLExtensions;
 {$ENDIF}

-  if (ClassType = TglBitmap) then
-    raise EglBitmapException.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');

   inherited Create;
 end;
 
   inherited Create;
 end;
 


@@ -5483,9 +5456,10 @@ begin
   GetMem(Image, ImageSize);
   try
     FillChar(Image^, ImageSize, #$FF);
   GetMem(Image, ImageSize);
   try
     FillChar(Image^, ImageSize, #$FF);

-    SetDataPointer(Image, aFormat, aSize.X, aSize.Y);
+    SetDataPointer(Image, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method

   except
   except

-    FreeMem(Image);
+    if Assigned(Image) then
+      FreeMem(Image);

     raise;
   end;
 end;
     raise;
   end;
 end;


@@ -5639,11 +5613,12 @@ begin
         SetLength(png_rows, 0);
 
         // set new data
         SetLength(png_rows, 0);
 
         // set new data

-        SetDataPointer(png_data, Format, TempWidth, TempHeight);
+        SetDataPointer(png_data, Format, TempWidth, TempHeight); //be careful, Data could be freed by this method

 
         result := true;
       except
 
         result := true;
       except

-        FreeMem(png_data);
+        if Assigned(png_data) then
+          FreeMem(png_data);

         raise;
       end;
     end;
         raise;
       end;
     end;


@@ -5732,11 +5707,12 @@ begin
             raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
         end;
 
             raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
         end;
 

-        SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height);
+        SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); //be careful, Data could be freed by this method

 
         result := true;
       except
 
         result := true;
       except

-        FreeMem(NewImage);
+        if Assigned(NewImage) then
+          FreeMem(NewImage);

         raise;
       end;
     finally
         raise;
       end;
     finally


@@ -6173,11 +6149,12 @@ begin
         // destroy decompression
         jpeg_destroy_decompress(@jpeg);
 
         // destroy decompression
         jpeg_destroy_decompress(@jpeg);
 

-        SetDataPointer(pImage, IntFormat, TempWidth, TempHeight);
+        SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method

 
         result := true;
       except
 
         result := true;
       except

-        FreeMem(pImage);
+        if Assigned(pImage) then
+          FreeMem(pImage);

         raise;
       end;
     end;
         raise;
       end;
     end;


@@ -6570,7 +6547,7 @@ begin
               inc(TmpData, wbLineSize);
             aStream.Read(PaddingBuff{%H-}, Padding);
           end;
               inc(TmpData, wbLineSize);
             aStream.Read(PaddingBuff{%H-}, Padding);
           end;

-          SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight));
+          SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); //be careful, Data could be freed by this method

           result := true;
         finally
           if Assigned(LineBuf) then
           result := true;
         finally
           if Assigned(LineBuf) then


@@ -6580,7 +6557,8 @@ begin
           FormatDesc.FreeMappingData(DestMD);
         end;
         except
           FormatDesc.FreeMappingData(DestMD);
         end;
         except

-          FreeMem(ImageData);
+          if Assigned(ImageData) then
+            FreeMem(ImageData);

           raise;
         end;
       end else
           raise;
         end;
       end else


@@ -7060,10 +7038,11 @@ begin
             ReadCompressed;
         end;
 
             ReadCompressed;
         end;
 

-        SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height);
+        SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); //be careful, Data could be freed by this method

         result := true;
       except
         result := true;
       except

-        FreeMem(ImageData);
+        if Assigned(ImageData) then
+          FreeMem(ImageData);

         raise;
       end;
     finally
         raise;
       end;
     finally


@@ -7384,10 +7363,11 @@ begin
       end else
         raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.');
 
       end else
         raise EglBitmapException.Create('LoadDDS - unsupported Pixelformat found.');
 

-      SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight);
+      SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method

       result := true;
     except
       result := true;
     except

-      FreeMem(NewImage);
+      if Assigned(NewImage) then
+        FreeMem(NewImage);

       raise;
     end;
   finally
       raise;
     end;
   finally


@@ -7453,6 +7433,112 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+//TglBitmap1D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+  const aWidth: Integer; const aHeight: Integer);
+var
+  pTemp: pByte;
+  Size: Integer;
+begin
+  if (aHeight > 1) then begin
+    Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1);
+    GetMem(pTemp, Size);
+    try
+      Move(aData^, pTemp^, Size);
+      FreeMem(aData);
+      aData := nil;
+    except
+      FreeMem(pTemp);
+      raise;
+    end;
+  end else
+    pTemp := aData;
+  inherited SetDataPointer(pTemp, aFormat, aWidth);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap1D.FlipHorz: Boolean;
+var
+  Col: Integer;
+  pTempDest, pDest, pSource: PByte;
+begin
+  result := inherited FlipHorz;
+  if Assigned(Data) and not TFormatDescriptor.Get(Format).IsCompressed then begin
+    pSource := Data;
+    GetMem(pDest, fRowSize);
+    try
+      pTempDest := pDest;
+      Inc(pTempDest, fRowSize);
+      for Col := 0 to Width-1 do begin
+        dec(pTempDest, fPixelSize); //dec before, because ptr is behind last byte of data
+        Move(pSource^, pTempDest^, fPixelSize);
+        Inc(pSource, fPixelSize);
+      end;
+      SetDataPointer(pDest, Format, Width); //be careful, Data could be freed by this method
+      result := true;
+    except
+      if Assigned(pDest) then
+        FreeMem(pDest);
+      raise;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.UploadData(const aBuildWithGlu: Boolean);
+var
+  FormatDesc: TFormatDescriptor;
+begin
+  // Upload data
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if FormatDesc.IsCompressed then
+    glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data)
+  else if aBuildWithGlu then
+    gluBuild1DMipmaps(Target, FormatDesc.glInternalFormat, Width, FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
+  else
+    glTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
+
+  // Free Data
+  if (FreeDataAfterGenTexture) then
+    FreeData;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean);
+var
+  BuildWithGlu, TexRec: Boolean;
+  TexSize: Integer;
+begin
+  if Assigned(Data) then begin
+    // Check Texture Size
+    if (aTestTextureSize) then begin
+      glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
+
+      if (Width > TexSize) then
+        raise EglBitmapSizeToLargeException.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
+
+      TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
+                (Target = GL_TEXTURE_RECTANGLE_ARB);
+      if not (IsPowerOfTwo(Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
+        raise EglBitmapNonPowerOfTwoException.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+    end;
+
+    CreateId;
+    SetupParameters(BuildWithGlu);
+    UploadData(BuildWithGlu);
+    glAreTexturesResident(1, @fID, @fIsResident);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.AfterConstruction;
+begin
+  inherited;
+  Target := GL_TEXTURE_1D;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 //TglBitmap2D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer;
 //TglBitmap2D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer;


@@ -7464,7 +7550,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-procedure TglBitmap2D.SetDataPointer(const aData: PByte; const aFormat: TglBitmapFormat;
+procedure TglBitmap2D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;

   const aWidth: Integer; const aHeight: Integer);
 var
   Idx, LineWidth: Integer;
   const aWidth: Integer; const aHeight: Integer);
 var
   Idx, LineWidth: Integer;


@@ -7489,7 +7575,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-procedure TglBitmap2D.UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean);
+procedure TglBitmap2D.UploadData(const aBuildWithGlu: Boolean);

 var
   FormatDesc: TFormatDescriptor;
 begin
 var
   FormatDesc: TFormatDescriptor;
 begin


@@ -7499,10 +7585,10 @@ begin
   if FormatDesc.IsCompressed then begin
     glCompressedTexImage2D(Target, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data)
   end else if aBuildWithGlu then begin
   if FormatDesc.IsCompressed then begin
     glCompressedTexImage2D(Target, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data)
   end else if aBuildWithGlu then begin

-    gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height,
+    gluBuild2DMipmaps(Target, FormatDesc.Components, Width, Height,

       FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
   end else begin
       FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
   end else begin

-    glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0,
+    glTexImage2D(Target, 0, FormatDesc.glInternalFormat, Width, Height, 0,

       FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
   end;
 
       FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
   end;
 


@@ -7536,10 +7622,11 @@ begin
   try
     glPixelStorei(GL_PACK_ALIGNMENT, 1);
     glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
   try
     glPixelStorei(GL_PACK_ALIGNMENT, 1);
     glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);

-    SetDataPointer(Temp, Format, w, h);
+    SetDataPointer(Temp, Format, w, h); //be careful, Data could be freed by this method

     FlipVert;
   except
     FlipVert;
   except

-    FreeMem(Temp);
+    if Assigned(Temp) then
+      FreeMem(Temp);

     raise;
   end;
 end;
     raise;
   end;
 end;


@@ -7577,9 +7664,10 @@ begin
       glGetCompressedTexImage(Target, 0, Temp)
     else
      glGetTexImage(Target, 0, FormatDesc.glInternalFormat, FormatDesc.glDataFormat, Temp);
       glGetCompressedTexImage(Target, 0, Temp)
     else
      glGetTexImage(Target, 0, FormatDesc.glInternalFormat, FormatDesc.glDataFormat, Temp);

-    SetDataPointer(Temp, IntFormat, TempWidth, TempHeight);
+    SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method

   except
   except

-    FreeMem(Temp);
+    if Assigned(Temp) then
+      FreeMem(Temp);

     raise;
   end;
 end;
     raise;
   end;
 end;


@@ -7600,14 +7688,13 @@ begin
 
       PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width);
       TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);
 
       PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width);
       TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);

-

       if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
         raise EglBitmapNonPowerOfTwoException.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
     end;
 
     CreateId;
     SetupParameters(BuildWithGlu);
       if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
         raise EglBitmapNonPowerOfTwoException.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
     end;
 
     CreateId;
     SetupParameters(BuildWithGlu);

-    UploadData(Target, BuildWithGlu);
+    UploadData(BuildWithGlu);

     glAreTexturesResident(1, @fID, @fIsResident);
   end;
 end;
     glAreTexturesResident(1, @fID, @fIsResident);
   end;
 end;


@@ -7635,10 +7722,11 @@ begin
           Dec(TempDestData, fPixelSize);
         end;
       end;
           Dec(TempDestData, fPixelSize);
         end;
       end;

-      SetDataPointer(DestData, Format);
+      SetDataPointer(DestData, Format); //be careful, Data could be freed by this method

       result := true;
     except
       result := true;
     except

-      FreeMem(DestData);
+      if Assigned(DestData) then
+        FreeMem(DestData);

       raise;
     end;
   end;
       raise;
     end;
   end;


@@ -7662,10 +7750,11 @@ begin
         Dec(TempDestData, fRowSize);
         Inc(SourceData, fRowSize);
       end;
         Dec(TempDestData, fRowSize);
         Inc(SourceData, fRowSize);
       end;

-      SetDataPointer(DestData, Format);
+      SetDataPointer(DestData, Format); //be careful, Data could be freed by this method

       result := true;
     except
       result := true;
     except

-      FreeMem(DestData);
+      if Assigned(DestData) then
+        FreeMem(DestData);

       raise;
     end;
   end;
       raise;
     end;
   end;


@@ -7903,134 +7992,7 @@ end;
 
 
 (*
 
 
 (*

-procedure TglBitmap1D.SetDataPointer(Data: pByte; Format: TglBitmapInternalFormat; Width, Height: Integer);
-var
-  pTemp: pByte;
-  Size: Integer;
-begin
-  if Height > 1 then begin
-    // extract first line of the data
-    Size := FormatGetImageSize(glBitmapPosition(Width), Format);
-    GetMem(pTemp, Size);

 
 

-    Move(Data^, pTemp^, Size);
-
-    FreeMem(Data);
-  end else
-    pTemp := Data;
-
-  // set data pointer
-  inherited SetDataPointer(pTemp, Format, Width);
-
-  if FormatIsUncompressed(Format) then begin
-    fUnmapFunc := FormatGetUnMapFunc(Format);
-    fGetPixelFunc := GetPixel1DUnmap;
-  end;
-end;
-
-
-procedure TglBitmap1D.GetPixel1DUnmap(const Pos: TglBitmapPixelPosition; var Pixel: TglBitmapPixelData);
-var
-  pTemp: pByte;
-begin
-  pTemp := Data;
-  Inc(pTemp, Pos.X * fPixelSize);
-
-  fUnmapFunc(pTemp, Pixel);
-end;
-
-
-function TglBitmap1D.FlipHorz: Boolean;
-var
-  Col: Integer;
-  pTempDest, pDest, pSource: pByte;
-begin
-  result := inherited FlipHorz;
-
-  if Assigned(Data) and FormatIsUncompressed(InternalFormat) then begin
-    pSource := Data;
-
-    GetMem(pDest, fRowSize);
-    try
-      pTempDest := pDest;
-
-      Inc(pTempDest, fRowSize);
-      for Col := 0 to Width -1 do begin
-        Move(pSource^, pTempDest^, fPixelSize);
-
-        Inc(pSource, fPixelSize);
-        Dec(pTempDest, fPixelSize);
-      end;
-
-      SetDataPointer(pDest, InternalFormat);
-
-      result := true;
-    finally
-      FreeMem(pDest);
-    end;
-  end;
-end;
-
-
-procedure TglBitmap1D.UploadData (Target, Format, InternalFormat, Typ: Cardinal; BuildWithGlu: Boolean);
-begin
-  // Upload data
-  if Self.InternalFormat in [ifDXT1, ifDXT3, ifDXT5] then
-    glCompressedTexImage1D(Target, 0, InternalFormat, Width, 0, Trunc(Width * FormatGetSize(Self.InternalFormat)), Data)
-  else
-
-  // Upload data
-  if BuildWithGlu then
-    gluBuild1DMipmaps(Target, InternalFormat, Width, Format, Typ, Data)
-  else
-    glTexImage1D(Target, 0, InternalFormat, Width, 0, Format, Typ, Data);
-
-  // Freigeben
-  if (FreeDataAfterGenTexture) then
-    FreeData;
-end;
-
-
-procedure TglBitmap1D.GenTexture(TestTextureSize: Boolean);
-var
-  BuildWithGlu, TexRec: Boolean;
-  glFormat, glInternalFormat, glType: Cardinal;
-  TexSize: Integer;
-begin
-  if Assigned(Data) then begin
-    // Check Texture Size
-    if (TestTextureSize) then begin
-      glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
-
-      if (Width > TexSize) then
-        raise EglBitmapSizeToLargeException.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
-
-      TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
-                (Target = GL_TEXTURE_RECTANGLE_ARB);
-
-      if not (IsPowerOfTwo (Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
-        raise EglBitmapNonPowerOfTwoException.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
-    end;
-
-    CreateId;
-
-    SetupParameters(BuildWithGlu);
-    SelectFormat(InternalFormat, glFormat, glInternalFormat, glType);
-
-    UploadData(Target, glFormat, glInternalFormat, glType, BuildWithGlu);
-
-    // Infos sammeln
-    glAreTexturesResident(1, @fID, @fIsResident);
-  end;
-end;
-
-
-procedure TglBitmap1D.AfterConstruction;
-begin
-  inherited;
-
-  Target := GL_TEXTURE_1D;
-end;

 
 
 { TglBitmapCubeMap }
 
 
 { TglBitmapCubeMap }