OpenGL Bitmap für Texttur schnell im Speicher erzeugen

[luisk]

Hallo,
wie kann ich mit OpenGL schnell ein Bitmap im Speicher beschreiben ?

[nuclearping]

Zitat von luisk:

WallTex.LoadImage('wall.jpg')

Wenn du das Bild ständig (zyklisch?) von der Platte nachlädst, wird wohl da der Flaschenhals sein.

[luisk]

gibt es irgendwo einen Quellcode, der zeigt, wie man ein TBitmap in eine OpenGL Textur umwandeln kann?

[Jens01]

glBitmap
älteres Tutorial
die Version von Bergmann angucken!

[luisk]

so geht's,
allerdings ist die Zeile
 texdata[((yHeight)-ly)*xwidth +lx ] := RGBQuad( bmp.canvas.pixels[lx,ly]); viel zu langsam.
Habe es auch mit TBmp.Scanline[y] probiert.
Ist aber noch langsamer, obwohl man überall liest, scanline sei schneller.

Steh wohl grad auf dem Schlauch

Delphi-Quellcode:

   inc(z);
   bmp.canvas.Textout(20,20,inttostr(z));

   xwidth := bmp.Width-1;
   yHeight := bmp.Height-1;
   for lx:= 0 to xwidth do  begin
     for ly := 0 to yHeight do  begin
         texdata[((yHeight)-ly)*xwidth +lx ] := RGBQuad( bmp.canvas.pixels[lx,ly]);
      end;
   end;

   if TextureID > 0 then   glDeleteTextures(1, @TextureID);
   glGenTextures(1, @ textureid);
   glBindTexture(GL_TEXTURE_2D, cardinal(textureid) );
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_linear);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_linear);
   glTexImage2D(GL_TEXTURE_2D, 0, 3, xwidth, yHeight, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, @texdata);

hier die Version mit Scanline[y] - noch langsamer.
Was kann man tun ? API-Version ?

Delphi-Quellcode:

 
   inc(z);
   bmp.canvas.Textout(20,20,inttostr(z));
   xwidth := bmp.Width;
   yHeight := bmp.Height;
   for y := 0 to yHeight-1 do begin
       l_ptr:=bmp.ScanLine[y];
       for x := 0 to xwidth-1 do begin
          l_r:=  l_ptr.rgbBlue;
          l_ptr.rgbBlue:=l_ptr.rgbRed;
          l_ptr.rgbRed:=l_r;
          texdata[((yHeight-1)-y)*xwidth+x] := l_ptr^;
          inc(l_ptr);
       end;
    end;
    if TextureID > 0 then   glDeleteTextures(1, @TextureID);
    glGenTextures(1, @ textureid);
    glBindTexture(GL_TEXTURE_2D, cardinal(textureid) );
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_linear);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_linear);
    glTexImage2D(GL_TEXTURE_2D, 0, 3, xwidth, yHeight);

[Sir Rufo]

So wie du mit Scanline arbeitest, erzwingst du das gleiche Verfahren wie mit Pixels.

Dreh deine for Schleifen um

Delphi-Quellcode:

for y := ...
  for x := ...

dann arbeitest du dich auch Zeile für Zeile durch

[Aphton]

Zitat:

Delphi (Borland) hat an dieser Stelle versagt. (habe Delphi6 Professional)

Ich wollte dir helfen aber nur bis ich das da oben gelesen habe...
Wenn du dich sowieo nicht auskennst, lass dein Frust bitte nicht an der Software bzw. am "Werkzeug" ab.

[luisk]

steh wohl grad auf dem Schlauch.
Wunder mich schon ne Weile, überall steht Scanline ist schneller
Hier ist es doch auch so. Oder.
http://stackoverflow.com/questions/1...24-bit-bitmaps

Delphi-Quellcode:

type
  PRGBTripleArray = ^TRGBTripleArray;
  TRGBTripleArray = array[0..4095] of TRGBTriple;

procedure GrayscaleBitmap(ABitmap: TBitmap);
var
  X: Integer;
  Y: Integer;
  Gray: Byte;
  Pixels: PRGBTripleArray;
begin
  // iterate bitmap from top to bottom to get access to each row's raw data
  for Y := 0 to ABitmap.Height - 1 do
  begin
    // get pointer to the currently iterated row's raw data
    Pixels := ABitmap.ScanLine[Y];
    // iterate the row's pixels from left to right in the whole bitmap width
    for X := 0 to ABitmap.Width - 1 do
    begin
      // calculate luminance for the current pixel by the mentioned formula
      Gray := Round((0.299 * Pixels[X].rgbtRed) +
        (0.587 * Pixels[X].rgbtGreen) + (0.114 * Pixels[X].rgbtBlue));
      // and assign the luminance to each color component of the current pixel
      Pixels[X].rgbtRed := Gray;
      Pixels[X].rgbtGreen := Gray;
      Pixels[X].rgbtBlue := Gray;
    end;
  end;
end;

[luisk]

Zitat von Sir Rufo:

So wie du mit Scanline arbeitest, erzwingst du das gleiche Verfahren wie mit Pixels.

Dreh deine for Schleifen um

Delphi-Quellcode:

for y := ...
  for x := ...

dann arbeitest du dich auch Zeile für Zeile durch

wo liegt jetzt mein Fehler ?
Hier wird doch Zeile für Zeile gelesen - ist dennoch langsamer als über Pixel[].
Sollte aber nicht sein, nachdem, was man überall findet.

Delphi-Quellcode:

 for y := 0 to yHeight-1 do begin
    l_ptr:=bmp.ScanLine[y];
    for x := 0 to xwidth-1 do begin
       l_r:= l_ptr.rgbBlue;
       l_ptr.rgbBlue:=l_ptr.rgbRed;
       l_ptr.rgbRed:=l_r;
       texdata[((yHeight-1)-y)*xwidth+x] := l_ptr^;
       inc(l_ptr);
    end;
end;

[Aphton]

Lies post #2 nochmal genauer durch.

Wenn du 100 Bilder hast und jedes mal diese neu von der HD laden musst, dann kann das nicht performant sein (vlt bei SSDs, aber selbst da ist das subperformant).
Entweder du baust dir ne Liste wo du jedes Bitmap zuvor schon reinlädst und generierst und im weiteren Verlauf (zyklische Logik?) auf die Liste zugreifst und kein erneuertes Laden durchführen musst.

Nochmal - der Flaschenhals liegt nicht beim Uploaden auf den VRAM (graka, opengl texture generierung), sondern eben daran!