DGL • Thema anzeigen - Texturen werden nicht geladen/angezeigt

Texturen werden nicht geladen/angezeigt

Moderator: DGL-Team

Seite 1 von 1

[ 6 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

h720640

Betreff des Beitrags: Texturen werden nicht geladen/angezeigt

Verfasst: Fr Apr 20, 2012 03:07

DGL Member

Registriert: Do Apr 19, 2012 19:06
Beiträge: 4
Programmiersprache: Delphi 2010

Wenn ich versuche ein Textur mit "glTexImage2D" zu laden bekomme ich nur eine weiße Fläche und mit "gluBuild2DMipmaps" wird auch nur eine einfarbige Fläche (nicht weiß) gezeichnet nicht aber meine Textur.
Auch mit "LoadTexture" aus "Textures.pas" bekomme ich nur eine einfarbige Fläche wie bei "gluBuild2DMipmaps".

Code:

 
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, MyGameEngineClock, dglOpenGL, GR32, Textures;
 
type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private declarations }
 
    var
      FClock: TMyGameEngineClock;
      DC    : HDC;
      RC    : HGLRC;
      TEX   : glUint; // a texture
 
    procedure SetupOpenGL;
    procedure ErrorHandlerGL;
    procedure Render(Sender: TObject; var Done: Boolean);
 
  public
    { Public declarations }
 
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
 
function CreateOpenGLTextureFromBitmap32(const b32: TBitmap32): glUint; inline;
begin
  glGenTextures(1, @result);
  glBindTexture(GL_TEXTURE_2D, result);
 
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP   , GL_FALSE );
 
  glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA, b32.Width, b32.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, b32.ScanLine[0]);
  //gluBuild2DMipmaps(GL_TEXTURE_2D, 4, b32.Width, b32.Height, GL_BGRA, GL_UNSIGNED_BYTE, b32.ScanLine[0]);
end;
 
 
 
procedure TForm1.FormCreate(Sender: TObject);
var b32: TBitmap32;
begin
  FClock:= TMyGameEngineClock.Create;
 
  SetupOpenGL;
 
  Application.OnIdle:= Render;
 
  b32:= TBitmap32.Create;
  b32.LoadFromFile('gradient.bmp');
  TEX:= CreateOpenGLTextureFromBitmap32(b32);
  b32.Free;
 
  //LoadTexture('gradient.bmp', TEX, false);
  //LoadTexture('gradient.jpg', TEX, false);
 
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  FClock.Free;
end;
 
procedure TForm1.SetupOpenGL;
begin
  DC:= GetDC(Handle);
  if not InitOpenGL then Application.Terminate;
  RC:= CreateRenderingContext( DC,
                               [opDoubleBuffered],
                               32,
                               24,
                               0,0,0,
                               0);
  ActivateRenderingContext(DC, RC);
 
  //setup
  //glEnable(GL_DEPTH_TEST);          //tiefentest on
  //glDepthFunc(GL_LESS);
  glDisable(GL_DEPTH_TEST);
 
  glEnable(GL_CULL_FACE);           //backface culling on
  glCullFace(GL_FRONT);
 
  glClearColor(0.3, 0.4, 0.7, 0.0); //BG color: light blue
 
  glViewPort(0,0,ClientWidth,ClientHeight);
  //glOrtho(0,1920,0,1080,0,1024); // needs glCullFace(GL_BACK);
  glOrtho(0, 1920, 1080, 0, 0, 1024); // needs glCullFace(GL_FRONT);
end;
 
procedure TForm1.ErrorHandlerGL;
begin
  if glGetError <> GL_NO_ERROR then
    Caption:= gluErrorString(glGetError);
 
end;
 
procedure TForm1.Render(Sender: TObject; var Done: Boolean);
 
  procedure DrawQuad(const XPos, YPos, ZPos, Width, Height: single); inline;
  begin
    glBegin(GL_QUADS);
      glVertex3f(XPos, YPos, -ZPos);
      glVertex3f(XPos+Width, YPos, -ZPos);
      glVertex3f(XPos+Width, YPos+Height, -ZPos);
      glVertex3f(XPos, YPos+Height, -ZPos);
    glEnd;
  end;
 
  procedure DrawQuad_CustomColor( const XPos, YPos, ZPos, Width, Height: single;
                                  const corner: integer;
                                  const red, green, blue: single;
                                  const alpha: single = 1.0
                                ); inline;
  begin
    ///  0..1
    ///  3..2
    case corner of
      0: begin glColor4f(red, green, blue, alpha); glVertex3f(XPos      , YPos       , -ZPos); end;
      1: begin glColor4f(red, green, blue, alpha); glVertex3f(XPos+Width, YPos       , -ZPos); end;
      2: begin glColor4f(red, green, blue, alpha); glVertex3f(XPos+Width, YPos+Height, -ZPos); end;
      3: begin glColor4f(red, green, blue, alpha); glVertex3f(XPos      , YPos+Height, -ZPos); end;
    end;
  end;
 
var timeTaken, averageFps: double;
begin
  Done             := false;
  timeTaken        := FClock.GetTick(30);
  averageFps       := FClock.GetAverageFps;
  Application.Title:= FormatFloat('0.00', averageFps) + ' fps - ' + FormatFloat('0.0000', timeTaken) + 's per frame';
  /// ----
 
  /// render
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
 
  {
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
  glViewPort(0, 0, ClientWidth, ClientHeight);
  glOrtho(0, 1920, 1080, 0, 0, 1024);
 
 
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;
  }
  // do something
 
  //glEnable(GL_ALPHA_TEST);
  //glAlphaFunc(GL_GREATER, 0.1);
 
  //glEnable(GL_BLEND);
  //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // normal
  //glBlendFunc(GL_ONE, GL_ONE); // add
  //glBlendFunc(GL_SRC_ALPHA, GL_ONE); // add with alpha
  //glBlendFunc(GL_DST_COLOR, GL_ZERO); // mul
  //glBlendFunc(GL_ONE, GL_ZERO); // none
 
 
 
  glDisable(GL_TEXTURE_2D);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // normal
  glBegin(GL_QUADS);
      DrawQuad_CustomColor(0, 0, 0, 1024, 1024, 0, 1, 0, 0);
      DrawQuad_CustomColor(0, 0, 0, 1024, 1024, 1, 0, 0, 0);
      DrawQuad_CustomColor(0, 0, 0, 1024, 1024, 2, 0, 0, 1);
      DrawQuad_CustomColor(0, 0, 0, 1024, 1024, 3, 1, 1, 1);
  glEnd;
 
  glEnable(GL_TEXTURE_2D);
  glDisable(GL_BLEND);
  glBindTexture(GL_TEXTURE_2D, TEX);
  DrawQuad(1024, 0, 0, 1024, 1024);
 
  glDisable(GL_TEXTURE_2D);
  glEnable(GL_BLEND);
  glBlendFunc(GL_DST_COLOR, GL_ZERO);
  glBegin(GL_QUADS);
      DrawQuad_CustomColor(640, 128, 0, 768, 768, 0, 1, 0, 1);
      DrawQuad_CustomColor(640, 128, 0, 768, 768, 1, 0, 1, 1);
      DrawQuad_CustomColor(640, 128, 0, 768, 768, 2, 0, 0, 0, 0.2);
      DrawQuad_CustomColor(640, 128, 0, 768, 768, 3, 0, 0, 0, 0.2);
  glEnd;
 
 
 
 
 
  SwapBuffers(DC);
 
  ErrorHandlerGL;
end;
 
end.
 

Nach oben

Ida

Betreff des Beitrags: Re: Texturen werden nicht geladen/angezeigt

Verfasst: Fr Apr 20, 2012 08:14

DGL Member

Registriert: Mi Apr 13, 2011 22:05
Beiträge: 218
Programmiersprache: Lazarus/FPC

ich weiß nicht genau was Bitmap32 für ein exaktes Format ist, das was du da in deinem Code benutzt, aber jedenfals musst du grundsätzlich dem glTexImage2D ein Array aus Zahlen übergeben (Pixeldaten) das du zuvor aus der Bitmap erstellst..
Ich zeig dir mal einen einfachen Code, (teils aus der Textures.pas) wie es auf jedenfal klappen sollte. Zumindest verwende ich teils diese Variante zum Texturen-laden.

Eine Bitmap wird erstellt, aus einer Datei geladen, die Daten daraus richtig in ein Longint-Array exportiert und mit diesem Array dann die Textur erstellt.

Code:

 
 var
    Data: Array of LongWord;  //beinhaltet später die Pixeldaten vom Bitmap die an OpenGL übergeben werden
    W, Width: Integer;
    H, Height: Integer;
    bmp: Tbitmap;
    C: LongWord;
    Line: ^LongWord;
  begin
    bmp := Tbitmap.Create;
    bmp.pixelformat := pf32bit;
    bmp.loadfromfile('deine datei.bmp');
    Width := bmp.Width;
    Height := bmp.Height;
    SetLength(Data, Width * Height);
    For H := 0 to Height - 1 do
    Begin
      Line := bmp.scanline[Height - H - 1];
      For W := 0 to Width - 1 do
      Begin
        C := Line^ and $FFFFFF;
        Data[W + (H * Width)] := (((C and $FF) shl 16) + (C shr 16) +
            (C and $FF00)) or $FF000000;
        inc(Line);
      End;
    End;
    bmp.Free;
    Texture := CreateTexture(Width, Height, GL_RGBA, addr(Data[0]));   //Mit der Funktion von unten werden hier die Daten in eine textur geladen. Texture ist vom Typ GluInt, deine TEX-Variable.
 

Jetzt ist eine Bitmap mal einfach in ein Longint-Array gespeichert worden.
Und jetzt machst du daraus eine Textur für OpenGL (Feineinstellungen nach Wunsch)

Code:

 
  function CreateTexture(Width, Height, Format: Word; pData: Pointer): Integer;
  var
    Texture: GLuint;
  begin
    glGenTextures(1, Texture);
    glBindTexture(GL_TEXTURE_2D, Texture);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    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, GL_RGBA, Width, Height, 0, GL_RGBA,
      GL_UNSIGNED_BYTE, pData);
    result := Texture;
  end;
 

lg
Ida

_________________
Ich teile manchmal heimlich durch Null. - Alber Einstein

Nach oben

h720640

Betreff des Beitrags: Re: Texturen werden nicht geladen/angezeigt

Verfasst: Fr Apr 20, 2012 19:29

DGL Member

Registriert: Do Apr 19, 2012 19:06
Beiträge: 4
Programmiersprache: Delphi 2010

"TBitmap32.Scanline" gibt "PColor32Array" zurück kann aber auch als "PColor32EntryArray " verwendet werden.

Code:

 
  PColor32 = ^TColor32;
  TColor32 = type Cardinal;
 
  PColor32Array = ^TColor32Array;
  TColor32Array = array [0..0] of TColor32;
  TArrayOfColor32 = array of TColor32;
 
  TColor32Component = (ccBlue, ccGreen, ccRed, ccAlpha);
  TColor32Components = set of TColor32Component;
 
  PColor32Entry = ^TColor32Entry;
  TColor32Entry = packed record
    case Integer of
      0: (B, G, R, A: Byte);
      1: (ARGB: TColor32);
      2: (Planes: array[0..3] of Byte);
      3: (Components: array[TColor32Component] of Byte);
  end;
 
  PColor32EntryArray = ^TColor32EntryArray;
  TColor32EntryArray = array [0..0] of TColor32Entry;
  TArrayOfColor32Entry = array of TColor32Entry;
 

Habe jetzt "glTexImage2D" geändert und bekomme nun auch mit "CreateOpenGLTextureFromBitmap32" keine weiße Fläche mehr aber immer noch einfarbig.

Code:

glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA, b32.Width, b32.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, b32.ScanLine[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, b32.Width, b32.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, b32.ScanLine[0]);

Auch die function "LoadTexture" aus "Textures.pas" liefert nur eine einfarbige Fläche.

Dein Beispiel erzeugt auch eine einfarbige Fläche wenn es denn mal nicht gerade an einer Zugriffsverletzung stirbt.

Code:

 
  function CreateTexture(Width, Height, Format: Word; pData: Pointer): glUint;
  var
    Texture: GLuint;
  begin
    glGenTextures(1, @Texture);
    glBindTexture(GL_TEXTURE_2D, Texture);
 
    //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
    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, GL_RGBA, Width, Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, pData);
    result := Texture;
  end;
 
  function LoadBMPToTexture(const s: string): glUint;
   var
    Data: Array of LongWord;  //beinhaltet später die Pixeldaten vom Bitmap die an OpenGL übergeben werden
    W, Width: Integer;
    H, Height: Integer;
    bmp: Tbitmap;
    C: LongWord;
    Line: ^LongWord;
  begin
    bmp := Tbitmap.Create;
    bmp.pixelformat := pf32bit;
    bmp.loadfromfile(s);
    Width := bmp.Width;
    Height := bmp.Height;
    SetLength(Data, Width * Height);
    For H := 0 to Height - 1 do
    Begin
      Line := bmp.scanline[Height - H - 1];
      For W := 0 to Width - 1 do
      Begin
        C := Line^ and $FFFFFF;
        Data[W + (H * Width)] := (((C and $FF) shl 16) + (C shr 16) +
            (C and $FF00)) or $FF000000;
        inc(Line);
      End;
    End;
    bmp.Free;
    result := CreateTexture(Width, Height, GL_RGBA, addr(Data[0]));   //Mit der Funktion von unten werden hier die Daten in eine textur geladen. Texture ist vom Typ GluInt, deine TEX-Variable.
  end;
 

Die folgenden drei Methoden liefern genau die gleiche einfarbige Fläche.

Code:

 
function CreateOpenGLTextureFromBitmap32(const b32: TBitmap32): glUint; inline;
begin
  glGenTextures(1, @result);
  glBindTexture(GL_TEXTURE_2D, result);
 
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  //glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP   , GL_FALSE );
 
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, b32.Width, b32.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, b32.ScanLine[0]);
  //gluBuild2DMipmaps(GL_TEXTURE_2D, 4, b32.Width, b32.Height, GL_BGRA, GL_UNSIGNED_BYTE, b32.ScanLine[0]);
end;
 
function CreateOpenGLTextureFromBitmap32_2(const b32: TBitmap32): glUint; inline;
var data: Array of cardinal;
    x, y: integer;
    s   : PColor32Array;
begin
  SetLength(data, b32.Height * b32.Width);
 
  y:= 0;
  while y < b32.Height do
  begin
    s:= b32.ScanLine[y];
    x:= 0;
    while x < b32.Width do
    begin
      data[y * b32.Width + x]:= s[x];
      Inc(x);
    end;
    Inc(y);
  end;
 
  glGenTextures(1, @result);
  glBindTexture(GL_TEXTURE_2D, result);
 
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP   , GL_FALSE );
 
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, b32.Width, b32.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
  //gluBuild2DMipmaps(GL_TEXTURE_2D, 4, b32.Width, b32.Height, GL_BGRA, GL_UNSIGNED_BYTE, data);
end;
 
 
function CreateOpenGLTextureFromBitmap(const bmp: TBitmap): glUint;
type TCardinalArray = packed array[0..MaxInt div SizeOf(cardinal) -1] of cardinal; PCardinalArray = ^TCardinalArray;
var data: Array of cardinal;
    x, y: integer;
    s   : PCardinalArray;
begin
  SetLength(data, bmp.Height * bmp.Width);
 
  bmp.PixelFormat:= pf32bit;
 
  y:= 0;
  while y < bmp.Height do
  begin
    s:= bmp.ScanLine[y];
    x:= 0;
    while x < bmp.Width do
    begin
      data[y * bmp.Width + x]:= s[x];
      Inc(x);
    end;
    Inc(y);
  end;
 
 
 
  glGenTextures(1, @result);
  glBindTexture(GL_TEXTURE_2D, result);
 
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // GL_NEAREST, GL_LINEAR
  glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP   , GL_FALSE );
 
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bmp.Width, bmp.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, data);
  //gluBuild2DMipmaps(GL_TEXTURE_2D, 4, bmp.Width, bmp.Height, GL_BGRA, GL_UNSIGNED_BYTE, data);
end;
 

Was mir noch aufgefallen ist dass der Code auf meinem Host anders aussieht als in meiner VM.
Das obere Bild ist aus meiner VM und das untere von meinem Host warum gibt es hier so einen großen unterschied?
Bild

Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

Nach oben

Ida

Betreff des Beitrags: Re: Texturen werden nicht geladen/angezeigt

Verfasst: Fr Apr 20, 2012 20:16

DGL Member

Registriert: Mi Apr 13, 2011 22:05
Beiträge: 218
Programmiersprache: Lazarus/FPC

Ich hab mal auf die Schnelle ein Beispielprogramm geschrieben.
Neues Projekt...und 2 Buttons hinzufügen.
und dann einfach den code hier reinkopieren:
Und natürlich den Pfad zu einer existierenden Bitmap-textur ändern^^

Funktioniert hier bei mir einwandfrei...und sollte es EIGENTLICH auch bei dir^^

_________________
Ich teile manchmal heimlich durch Null. - Alber Einstein

Nach oben

h720640

Betreff des Beitrags: Re: Texturen werden nicht geladen/angezeigt

Verfasst: Sa Apr 21, 2012 04:11

DGL Member

Registriert: Do Apr 19, 2012 19:06
Beiträge: 4
Programmiersprache: Delphi 2010

Also dein Code verursacht bei mir immer eine Zugriffsverletzung in Zeile 75 "C := Line^ and $FFFFFF;".

Ist aber auch egal dank deinem Codebeispiel habe ich den Fehler dennoch gefunden und zwar hatte ich kein "glTexCoord2f" und dadurch wurde nur eine einfarbige Fläche gezeichnet, außerdem hatte ich noch die Ecken des quads in einer anderen Reihenfolge. Danke für deine mühe.
Jetzt noch den ganzen Texturkram in eine Klasse damit alles wieder etwas übersichtlicher wird.

Nochmal zu dem unterschiedlichen shading, in meiner VirtualBox habe ich ohne 3D-Beschleunigung nur OpenGL 1.1 und damit sieht es aus wie auf dem oberen Bild wenn ich aber 3D-Beschleunigung einschalte erhalte ich OpenGL 2.1 und dann sieht es aus wie auf dem unteren Bild, kann ich dies irgendwie umstellen? Mir gefällt das Ergebnis von OpenGL 1.1 besser.

Nach oben

Coolcat

Betreff des Beitrags: Re: Texturen werden nicht geladen/angezeigt

Verfasst: Sa Apr 21, 2012 11:06

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Zitat:

Nochmal zu dem unterschiedlichen shading, in meiner VirtualBox habe ich ohne 3D-Beschleunigung nur OpenGL 1.1 und damit sieht es aus wie auf dem oberen Bild wenn ich aber 3D-Beschleunigung einschalte erhalte ich OpenGL 2.1 und dann sieht es aus wie auf dem unteren Bild, kann ich dies irgendwie umstellen? Mir gefällt das Ergebnis von OpenGL 1.1 besser.

Eine Grafikkarte kann nur Dreiecke verarbeiten. Wenn du also ein Quad renderst muss das irgendwie in zwei Dreiecke geteilt werden. Wie das passiert hängt vermutlich vom Treiber ab. Im oberen Bild verläuft die Diagonale von oben links nach unten rechts. Im unteren Bild läuft dagegen die Diagonale von oben rechts nach unten links. Diese Diagonale bestimmt wie die Farben in den Ecken interpoliert werden.
=> Nutze ein TRIANGLE_STRIP, dann hast du die Kontrolle darüber wo die Diagonale läuft, musst aber trotzdem nur vier Vertices angeben.

_________________
Yeah! :mrgreen:

Nach oben

Seite 1 von 1

[ 6 Beiträge ]

Foren-Übersicht » Programmierung » Einsteiger-Fragen

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.