[OpenGL] Transparenz

[Flips]

Hi!!

Ich habe vor langer Zeit eine kleine Partikel-Engine für OpenGL geschrieben.
Jetzt hab ich sie wieder laufen gelassen, doch mir ist aufgefallen, dass die Texturen nicht richtig dargestellt werden.

Code:

Delphi-Quellcode:

   
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,Texture);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glColor4f(1,1,1,0);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
//rendern...
//glVertex3f.....
//rendern...
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);

Da ist sicher viel falsch, ich hab solange kein OpenGL mehr gesehn, ich weiß beispielsweise gar nicht mehr was das GL_ALPHA_TEST ist. Es könnte auch sein, dass es mit den Texturen zusammenhängt, ich hab keine Ahnung. :pale:

Im Anhang (RAR-Archiv) ist einmal ein Bild mit der Textur(als PNG, ich habe es als TGA (ohne RLE, Ursprung unten links, mit alpha-kanal)) und ein Bild mit dem Ergebnis.

Könnt ihr mir auf die Sprünge helfen, wie ich diese quadratischen "Partikel" da wegbekomme? Ich denke ihr wisst, wie es aussehen sollte :wink:

THX

[TheReaper]

Hi.
Sovel falsch ist da gar nicht. du hast nur eine funktion vergessen.
ich bin auch nich grad der profi in OGL aber bei mir funktioniert das:

Delphi-Quellcode:

glBindTexture(GL_TEXTURE_2D, Texture); 
glEnable(GL_TEXTURE_2D); 
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.1); //<-- Das ist wichtig um OGL zu sagen, wann der Alphakanal genutzt werden soll

//Rendern

glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);

ich würd dir noch empfehlen die tutorials von DelphiGL dir anzusehen.

[Flips]

Hi, danke für die schnelle Antwort. Hab das mal übernommen, leider funktioniert es nicht :-(
Im Anhang ist ein Bild, wies aussieht.

Die delphigl-Tutorials hab ich schon alle gelesen,aber da finde ich auch nichts :lol: Ist ja schon lang her^^

[turboPASCAL]

Häng dien Projekt doch mal an, dann kann man mal gucken...

[TheReaper]

Was genau willst du denn machen?

Bei mir funktioniert es so. Hast du den neusten OGL-Header? da hat sich in letzter zeit einiges getan.

[Flips]

OK ich habs beim Überprüfen hinbekommen.:thumb:
Ich nutze die GLBMP und habe mit Hilfe von AddAlpha wohl den passenden Kanal erzeugt, obwohl ich dachte das hätte GIMP schon für mich gemacht... :gruebel:

Danke an alle
:dp:

[Lossy eX]

Nicht jedes Format ist in der Lage einen Alphakanal zu speichern. Evtl hast du dort einfach nur ein falsches Format gewählt wodurch der Kanal wieder entfernt wurde. So etwas wie JPEG oder BMP.

[Flips]

Nein, ich speichere Texturen grundsätzlich in TGA, das hat alles was man braucht.
Auch einen Alpha-Kanal.

[Lossy eX]

Okay. TGA hat zu mindest meist einen. Wobei es mich dennoch etwas wundert, dass du erst noch manuell AddAlpha aufrufen musst.

Aber ich persönlich mag die glbmp sowieso nicht. Als Alternive würde ich die glBitmap empfehlen. *hust* Damit geht das auf jeden Fall direkt sofern das TGA auch richtig ist. Wovon ich aber mal ausgehe. ;)

[turboPASCAL]

*Einmisch*

Uwaäh, glBmp und glBitmaps.... nehmt die Textures.pas. :mrgreen: Die hat das PNG-Format,
dieses ist eigentlich alles was man braucht.

Hier die kleinste Version:

Delphi-Quellcode:

//----------------------------------------------------------------------------
//
// Autor       : MatthiasG. (turboPASCAL)
// Website     : [url]http://www.mgsdh.de.vu[/url]
// Version     : 2.00 lite
// Date        : Jun 2006
// Changes     : * Ver 1.9 -> Ver 2.0 Debugzeugs eingebaut
//               * Ver 1.8 -> Unterstützung von RGB-Dateien
//
// Hint        : * in der Datei "pngimage.pas" den Compilerschalter 
//                 {$DEFINE UseDelphi} durch {.$DEFINE UseDelphi} ersetzen 
//               * nicht 100% Optimiert für nonVCL
//----------------------------------------------------------------------------

unit PNGLoader;

{$WARNINGS OFF}

// For Debug only: --------------------
{.$DEFINE ViewLoadedFilesOnConsole}
// ------------------------------------

interface

uses
  Windows,
  OpenGL,
  pngimage,
  sysutils; // für Uppercase und solch einen Käse...

  function LoadTexture(const Filename: String; var Texture: GLuint;
    const LoadFromRes: Boolean = FALSE): Boolean;

  function gluBuild2DMipmaps(Target: GLenum; Components, Width, Height: GLint;
    Format, atype: GLenum; Data: Pointer): GLint; stdcall; external 'glu32.dll';
  procedure glGenTextures(n: GLsizei; var textures: GLuint); stdcall; external OpenGL32;
  procedure glBindTexture(target: GLenum; texture: GLuint); stdcall; external OpenGL32;
  procedure glDeleteTextures(n: Integer; textures: PGLuint); stdcall; external OpenGL32;


implementation

{------------------------------------------------------------------}
{  Create the Texture                                              }
{------------------------------------------------------------------}
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);  {Texture blends with object background}
//  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);  {Texture does NOT blend with object background}

  { Select a filtering type. BiLinear filtering produces very good results with little performance impact
    GL_NEAREST               - Basic texture (grainy looking texture)
    GL_LINEAR                - BiLinear filtering
    GL_LINEAR_MIPMAP_NEAREST - Basic mipmapped texture
    GL_LINEAR_MIPMAP_LINEAR  - BiLinear Mipmapped texture
  }  

  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); { only first two can be used }
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); { all of the above can be used }

  if Format = GL_RGBA then
    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, pData)
  else
    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, Width, Height, GL_RGB, GL_UNSIGNED_BYTE, pData);
//  glTexImage2D(GL_TEXTURE_2D, 0, 3, Width, Height, 0, GL_RGB, GL_UNSIGNED_BYTE, pData);  // Use when not wanting mipmaps to be built by openGL

  {$IFDEF ViewLoadedFilesOnConsole}
    if Format = GL_RGBA
      then Write(' -> CreateTexture (RGBA): ')
      else Write(' -> CreateTexture (RGB): ');
    WriteLn(Width, 'x', Height);
  {$ENDIF ViewLoadedFilesOnConsole}

  result := Texture;
end;

{------------------------------------------------------------------}
{  Load PNG textures                                               }
{------------------------------------------------------------------}
function LoadPNGTexture(Filename: String; var Texture: GLuint; LoadFromResource: Boolean): Boolean;
var
  Data : Array of DWORD;
  W, Width : Integer;
  H, Height : Integer;
  AlphaPtr: PByte;
  PNG : TPngObject;
begin
  {$IFDEF ViewLoadedFilesOnConsole}
    Writeln('LoadTexture "Type PNG": ', Filename);
  {$ENDIF ViewLoadedFilesOnConsole}

  PNG := TPngObject.Create;

  if LoadFromResource then // Load from resource
  begin
    PNG.LoadFromResourceName(hInstance, copy(Filename, 1, Pos('.', Filename)-1));
    // to do: on Error exit
    // Result := FALSE;
  end else
  begin
    PNG.LoadFromFile(Filename);
    // to do: on Error exit
    // Result := FALSE;
  end;

  //
  // Nö, Palettenzeugs will ich nicht.
  /////////////////////////////////////////////////////////////////////////
  if PNG.Header.ColorType = COLOR_PALETTE then
  begin
    MessageBox(0,
      PChar('Dieser PNG-Typ in der Datei:'#13#10'"' + Filename +
            '"'#13#10'wird nicht unterstützt.'),
      PChar('Information:' + IntToStr(PNG.Header.ColorType)),
      MB_APPLMODAL or MB_SYSTEMMODAL or MB_ICONINFORMATION or MB_OK);
    Result := FALSE;
    exit;
  end;

  Width := PNG.Width;
  Height := PNG.Height;
  SetLength(Data, Width * Height);

  if (PNG.Header.ColorType = COLOR_RGB) or
     (PNG.Header.ColorType = COLOR_GRAYSCALE) then
  begin
    For H := 0 to Height - 1 do
      For W := 0 to Width - 1 do
        Data[W + (H * Width)] := $FF000000 or PNG.Pixels[W, (Height-1)-H];
  end else
  if (PNG.Header.ColorType = COLOR_RGBALPHA) or
     (PNG.Header.ColorType = COLOR_GRAYSCALEALPHA) then
  begin
    for H := 0 to Height - 1 do
    begin
      AlphaPtr := PByte(PNG.AlphaScanline[(Height-1)-H]);
      for W := 0 to Width - 1 do
      begin
        Data[W + (H * Width)] := (($FF000000 and (AlphaPtr^ shl 24)) or PNG.Pixels[W, (Height-1)-H]);
        Inc(AlphaPtr);
      end;
    end;
  end;

  PNG.free;

  Texture := CreateTexture(Width, Height, GL_RGBA, @Data[0]);

  Result := TRUE;
end;

{------------------------------------------------------------------}
{  Determines file type and sends to correct function              }
{------------------------------------------------------------------}
function LoadTexture(const Filename: String; var Texture: GLuint; const LoadFromRes: Boolean = FALSE): Boolean;
begin
  result := False;
  if copy(Uppercase(filename), length(filename)-3, 4) = '.PNG' then
    LoadPNGTexture(Filename, Texture, LoadFromRes);
end;

{$IFDEF ViewLoadedFilesOnConsole}
initialization
  AllocConsole;
  SetConsoleTitle('Unit PNGLoader:');

finalization
  FreeConsole;
{$ENDIF ViewLoadedFilesOnConsole}

end.

[Sidorion]

Ein Texturloader sollte mbMn mehr können, als Texturen zu laden und zwar mehr als ein Format. Bei Lossys glBitmap kann man Alphakanäle zufügen, die Farbkanäle tauschen, die Textur invertieren, über Funktionen Filter anwenden, Texturen Prozedural erzeugen, ... (Hab ich was vergessen?). Überdies kann man hier objektorientiert arbeiten, was a) die Arbeit mit der Textur und b) die Verwaltung dieser extrem erleichtert.

p.s. das steht Uses OpenGL. Das ist hoffentlich nicht der Borland-Header, oder?
p.p.s.: die glBitmap ist im DGLSDK, kann man hier runterladen. Da ist auch ein aktueller OpenGL Header bei und viele Templates. Ausserdem enthalten ist die SDL.

[turboPASCAL]

Zitat:

Zitat von Sidorion

Ein Texturloader sollte mbMn mehr können

Als eine Textur zu laden ? Dann währe das aber kein "Loader". ;)

Zitat:

... als Texturen zu laden und zwar mehr als ein Format.

Äh, ja wozu den mehrere Formate ? Bitmaps, JPEG's, TGA's und alles nur für RGB(A) Werte
die man auch gepackt im PNG-Format bekommt. (Ausgenommen mal *.dds-Dateien)

Zitat:

Bei Lossys glBitmap kann man Alphakanäle zufügen, die Farbkanäle tauschen, die Textur invertieren, über Funktionen Filter anwenden, Texturen Prozedural erzeugen, ... (Hab ich was vergessen?). Überdies kann man hier objektorientiert arbeiten, was a) die Arbeit mit der Textur und b) die Verwaltung dieser extrem erleichtert.

Du hast bestimmt übersehen das in Quelltext als Komentar bei mir "Lite" steht. :stupid:

Zitat:

p.s. das steht Uses OpenGL. Das ist hoffentlich nicht der Borland-Header, oder?

Ja, natürlich ist das die von Borland. Mit ein paar Änderungen. Die von delphigl ist mir
für meine nonVCL-App's zu fett und so viel falsch oder Fehlerhaft ist da nun auch nicht.

:mrgreen:

[Gandalfus]

ich mache es so:

Delphi-Quellcode:

glDepthMask(false);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
fTexture.Bind;
   
//rendern;

fTexture.Unbind();
glDisable(GL_TEXTURE_2D);
glDepthMask(true);
glDisable(GL_BLEND);

[Lossy eX]

turboPASCAL: Um mal etwas zu spalten. Die richtige originale Textures kann keine PNGs. Höchstens die von dir angepasste Version. ;)

Aber wie du selbst ja schon gesagt hast ist dein Code für möglichst kleine Anwendungen ausgelegt. Das war in meinem Loader niemals das Ziel. Sondern kompfortables einfaches objekt orientiertes Arbeiten. Bzw war es für mich auch erklärtes Ziel nur im Notfall wirklich etwas an den Texturdaten zu verändern. Und ich habe immer versucht keine altlastigen Techniken (gluBuild2DMipmaps) zu benutzen. Bzw nur wenns nicht anders geht.

Mit Formate waren keine Dateiformate gemeint sondern die Texturformate die in den Dateien abgelegt werden können. Also so zum Beispiel. AlphaLuminance, RGB5A1, RGBA4, BGRA, S3TC etc. Die unterschiedlichen Formate werden so von den Dateien und von OpenGL unterstützt. Das muss dann natürlich auch irgendwo verwaltet werden.

Borland Header. Ja der ist Fehlerhaft und hoffnungslos veraltet. Aber es zwingt dich ja niemand und wenn der reicht. Aber in deinem Loader fehlen eigentlich nur 6-10 Konstanten und ein paar Funktionen und dann bräuchtest du den Header dort gar nicht mehr.

Sidorin. Ich denke die Aufzählung passt schon. Wobei die Objekte natürlich sehr offen sind und man eigentlich alles damit machen kann was man will.

Im Endeffekt ist es aber jedem selbst überlassen was man zu Laden benutzt. Mir persönlich gefällt Objektorientiert halt besser. ;)

[Flips]

Übrigends, ich mache es jetzt bei der neuen Engine so

Delphi-Quellcode:

//Texture wird vorher gebunden
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
//Render...
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);

Und ich nutze bei der neuen Version auch die Textures.pas (1.03), wobei ich meinem Vorredner recht geben muss. Also laut dieser Page kann die kein PNG, was auch aus dem Code hervorgeht

Delphi-Quellcode:

function LoadTexture(Filename: String; var Texture : GLuint; LoadFromRes : Boolean) : Boolean;
begin
  if copy(Uppercase(filename), length(filename)-3, 4) = '.BMP' then
    LoadBMPTexture(Filename, Texture, LoadFromRes);
  if copy(Uppercase(filename), length(filename)-3, 4) = '.JPG' then
    LoadJPGTexture(Filename, Texture, LoadFromRes);
  if copy(Uppercase(filename), length(filename)-3, 4) = '.TGA' then
    LoadTGATexture(Filename, Texture, LoadFromRes);
end;

Aber gibt ja viele Mods davon...