[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.