* implemented TglBitmap1D

* fixed some memory issues

glBitmap.pas

@@ -4,7 +4,6 @@ http://www.opengl24.de/index.php?cat=header&file=glbitmap
 
 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
@@ -241,7 +240,8 @@ unit glBitmap;
 {.$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)
@@ -846,8 +846,8 @@ type
 
     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;
@@ -992,6 +992,19 @@ type
     procedure SaveDDS(const aStream: TStream); virtual;
   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
@@ -999,9 +1012,9 @@ type
     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;
-    procedure UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean);
+    procedure UploadData(const aBuildWithGlu: Boolean);
   public
     property Width;
     property Height;
@@ -1045,24 +1058,7 @@ type
   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
@@ -2054,42 +2050,6 @@ begin
 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 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -4064,7 +4024,7 @@ begin
     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;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -4150,7 +4110,7 @@ begin
 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;
@@ -4218,8 +4178,11 @@ end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmap.BeforeDestruction;
+var
+  NewData: PByte;
 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;
@@ -4280,9 +4243,10 @@ begin
   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
-    FreeMem(tmpData);
+    if Assigned(tmpData) then
+      FreeMem(tmpData);
     raise;
   end;
   AddFunc(Self, aFunc, false, Format, aArgs);
@@ -4420,7 +4384,7 @@ begin
 
         // 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;
 
@@ -4430,7 +4394,7 @@ begin
         DestFD.FreeMappingData(DestMD);
       end;
     except
-      if aCreateTemp then
+      if aCreateTemp and Assigned(TmpData) then
         FreeMem(TmpData);
       raise;
     end;
@@ -4525,10 +4489,11 @@ begin
           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
-      FreeMem(pData);
+      if Assigned(pData) then
+        FreeMem(pData);
       raise;
     end;
   end;
@@ -4694,10 +4659,11 @@ begin
           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
-      FreeMem(pData);
+      if Assigned(pData) then
+        FreeMem(pData);
       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);
-    SetDataPointer(ImageData, f, aImage.Width, aImage.Height);
+    SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method
   except
-    FreeMem(ImageData);
+    if Assigned(ImageData) then
+      FreeMem(ImageData);
     raise;
   end;
 
@@ -5177,13 +5144,16 @@ begin
       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
-        FreeMem(TempPtr);
+        if Assigned(TempPtr) then
+          FreeMem(TempPtr);
         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;
@@ -5291,8 +5261,11 @@ end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TglBitmap.FreeData;
+var
+  TempPtr: PByte;
 begin
-  SetDataPointer(nil, tfEmpty);
+  TempPtr := nil;
+  SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -5450,11 +5423,11 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 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}
-  if (ClassType = TglBitmap) then
-    raise EglBitmapException.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
   inherited Create;
 end;
 
@@ -5483,9 +5456,10 @@ begin
   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
-    FreeMem(Image);
+    if Assigned(Image) then
+      FreeMem(Image);
     raise;
   end;
 end;
@@ -5639,11 +5613,12 @@ begin
         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
-        FreeMem(png_data);
+        if Assigned(png_data) then
+          FreeMem(png_data);
         raise;
       end;
     end;
@@ -5732,11 +5707,12 @@ begin
             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
-        FreeMem(NewImage);
+        if Assigned(NewImage) then
+          FreeMem(NewImage);
         raise;
       end;
     finally
@@ -6173,11 +6149,12 @@ begin
         // 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
-        FreeMem(pImage);
+        if Assigned(pImage) then
+          FreeMem(pImage);
         raise;
       end;
     end;
@@ -6570,7 +6547,7 @@ begin
               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
@@ -6580,7 +6557,8 @@ begin
           FormatDesc.FreeMappingData(DestMD);
         end;
         except
-          FreeMem(ImageData);
+          if Assigned(ImageData) then
+            FreeMem(ImageData);
           raise;
         end;
       end else
@@ -7060,10 +7038,11 @@ begin
             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
-        FreeMem(ImageData);
+        if Assigned(ImageData) then
+          FreeMem(ImageData);
         raise;
       end;
     finally
@@ -7384,10 +7363,11 @@ begin
       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
-      FreeMem(NewImage);
+      if Assigned(NewImage) then
+        FreeMem(NewImage);
       raise;
     end;
   finally
@@ -7452,6 +7432,112 @@ begin
   aStream.Write(Data^, FormatDesc.GetSize(Dimension));
 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/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -7464,7 +7550,7 @@ begin
 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;
@@ -7489,7 +7575,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.UploadData(const aTarget: Cardinal; const aBuildWithGlu: Boolean);
+procedure TglBitmap2D.UploadData(const aBuildWithGlu: Boolean);
 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
-    gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height,
+    gluBuild2DMipmaps(Target, FormatDesc.Components, Width, Height,
       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;
 
@@ -7536,10 +7622,11 @@ begin
   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
-    FreeMem(Temp);
+    if Assigned(Temp) then
+      FreeMem(Temp);
     raise;
   end;
 end;
@@ -7577,9 +7664,10 @@ begin
       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
-    FreeMem(Temp);
+    if Assigned(Temp) then
+      FreeMem(Temp);
     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);
-
       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;
@@ -7635,10 +7722,11 @@ begin
           Dec(TempDestData, fPixelSize);
         end;
       end;
-      SetDataPointer(DestData, Format);
+      SetDataPointer(DestData, Format); //be careful, Data could be freed by this method
       result := true;
     except
-      FreeMem(DestData);
+      if Assigned(DestData) then
+        FreeMem(DestData);
       raise;
     end;
   end;
@@ -7662,10 +7750,11 @@ begin
         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
-      FreeMem(DestData);
+      if Assigned(DestData) then
+        FreeMem(DestData);
       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 }