procedure CopySwapPixel(const Source, Destination : Pointer);
 asm
   push ebx
   mov bl,[eax+0]
   mov bh,[eax+1]
   mov [edx+2],bl
   mov [edx+1],bh
   mov bl,[eax+2]
   mov bh,[eax+3]
   mov [edx+0],bl
   mov [edx+3],bh
   pop ebx
 end;

{------------------------------------------------------------------}
{  Loads 24 and 32bpp (alpha channel) TGA textures                 }
{------------------------------------------------------------------}
function LoadTGATexture( Filename: String; var Texture: GLuint ): Boolean;
var
 TGAHeader : packed record   // Header type for TGA images
   FileType     : Byte;
   ColorMapType : Byte;
   ImageType    : Byte;
   ColorMapSpec : Array[0..4] of Byte;
   OrigX  : Array [0..1] of Byte;
   OrigY  : Array [0..1] of Byte;
   Width  : Array [0..1] of Byte;
   Height : Array [0..1] of Byte;
   BPP    : Byte;
   ImageInfo : Byte;
 end;
 TGAFile   : File;
 bytesRead : Integer;
 image     : Pointer;    {or PRGBTRIPLE}
 CompImage : Pointer;
 Width, Height : Integer;
 ColorDepth    : Integer;
 ImageSize     : Integer;
 BufferIndex : Integer;
 currentByte : Integer;
 CurrentPixel : Integer;
 I : Integer;
 Front: ^Byte;
 Back: ^Byte;
 Temp: Byte;

 // Copy a pixel from source to dest and Swap the RGB color values
 procedure CopySwapPixel(const Source, Destination : Pointer);
 asm
   push ebx
   mov bl,[eax+0]
   mov bh,[eax+1]
   mov [edx+2],bl
   mov [edx+1],bh
   mov bl,[eax+2]
   mov bh,[eax+3]
   mov [edx+0],bl
   mov [edx+3],bh
   pop ebx
 end;

begin
 result :=FALSE;
 GetMem(Image, 0);

 AssignFile(TGAFile, Filename);
 Reset(TGAFile, 1);

 // Read in the bitmap file header
 BlockRead(TGAFile, TGAHeader, SizeOf(TGAHeader));
 result :=TRUE;

 if Result = TRUE then
 begin
   Result :=FALSE;

   // Only support 24, 32 bit images
   if (TGAHeader.ImageType <> 2) AND    { TGA_RGB }
      (TGAHeader.ImageType <> 10) then  { Compressed RGB }
   begin
     Result := False;
     CloseFile(tgaFile);
     MessageBox(0, PChar('Couldn''t load \"'+ Filename +'\". Only 24 and 32bit TGA supported.'), PChar('TGA File Error'), MB_OK);
     Exit;
   end;

   // Don't support colormapped files
   if TGAHeader.ColorMapType <> 0 then
   begin
     Result := False;
     CloseFile(TGAFile);
     MessageBox(0, PChar('Couldn''t load "'+ Filename +'". Colormapped TGA files not supported.'), PChar('TGA File Error'), MB_OK);
     Exit;
   end;

   // Get the width, height, and color depth
   Width  := TGAHeader.Width[0]  + TGAHeader.Width[1]  * 256;
   Height := TGAHeader.Height[0] + TGAHeader.Height[1] * 256;
   ColorDepth := TGAHeader.BPP;
   ImageSize  := Width*Height*(ColorDepth div 8);

   if ColorDepth < 24 then
   begin
     Result := False;
     CloseFile(TGAFile);
     MessageBox(0, PChar('Couldn''t load "'+ Filename +'". Only 24 and 32 bit TGA files supported.'), PChar('TGA File Error'), MB_OK);
     Exit;
   end;

   GetMem(Image, ImageSize);

   if TGAHeader.ImageType = 2 then   // Standard 24, 32 bit TGA file
   begin
     BlockRead(TGAFile, image^, ImageSize, bytesRead);
     if bytesRead <> ImageSize then
     begin
       Result := False;
       CloseFile(TGAFile);
       MessageBox(0, PChar('Couldn''t read file "'+ Filename +'".'), PChar('TGA File Error'), MB_OK);
       Exit;
     end;

     // TGAs are stored BGR and not RGB, so swap the R and B bytes.
     // 32 bit TGA files have alpha channel and gets loaded differently
     if TGAHeader.BPP = 24 then
     begin
       for I :=0 to Width * Height - 1 do
       begin
         Front := Pointer(Integer(Image) + I*3);
         Back := Pointer(Integer(Image) + I*3 + 2);
         Temp := Front^;
         Front^ := Back^;
         Back^ := Temp;
       end;
       Texture :=CreateTexture(Width, Height, GL_RGB, Image);
     end
     else
     begin
       for I :=0 to Width * Height - 1 do
       begin
         Front := Pointer(Integer(Image) + I*4);
         Back := Pointer(Integer(Image) + I*4 + 2);
         Temp := Front^;
         Front^ := Back^;
         Back^ := Temp;
       end;
       Texture :=CreateTexture(Width, Height, GL_RGBA, Image);
     end;
   end;

   // Compressed 24, 32 bit TGA files
   if TGAHeader.ImageType = 10 then
   begin
     ColorDepth :=ColorDepth DIV 8;
     CurrentByte :=0;
     CurrentPixel :=0;
     BufferIndex :=0;

     GetMem(CompImage, FileSize(TGAFile)-sizeOf(TGAHeader));
     BlockRead(TGAFile, CompImage^, FileSize(TGAFile)-sizeOf(TGAHeader), BytesRead);   // load compressed data into memory
     if bytesRead <> FileSize(TGAFile)-sizeOf(TGAHeader) then
     begin
       Result := False;
       CloseFile(TGAFile);
       MessageBox(0, PChar('Couldn''t read file "'+ Filename +'".'), PChar('TGA File Error'), MB_OK);
       Exit;
     end;

     // Extract pixel information from compressed data
     repeat
       Front := Pointer(Integer(CompImage) + BufferIndex);
       Inc(BufferIndex);
       if Front^ < 128 then
       begin
         For I := 0 to Front^ do
         begin
           CopySwapPixel(Pointer(Integer(CompImage)+BufferIndex+I*ColorDepth), Pointer(Integer(image)+CurrentByte));
           CurrentByte := CurrentByte + ColorDepth;
           inc(CurrentPixel);
         end;
         BufferIndex :=BufferIndex + (Front^+1)*ColorDepth
       end
       else
       begin
         For I := 0 to Front^ -128 do
         begin
           CopySwapPixel(Pointer(Integer(CompImage)+BufferIndex), Pointer(Integer(image)+CurrentByte));
           CurrentByte := CurrentByte + ColorDepth;
           inc(CurrentPixel);
         end;
         BufferIndex :=BufferIndex + ColorDepth
       end;
     until CurrentPixel >= Width*Height;

     if ColorDepth = 3 then
       Texture :=CreateTexture(Width, Height, GL_RGB, Image)
     else
       Texture :=CreateTexture(Width, Height, GL_RGBA, Image);
   end;

   Result :=TRUE;
   FreeMem(Image);
 end;
end;