Hallo,
neues Problem:
ich will den Hintergrund von Schrifttexturen transparent zeichnen

setzen der Alpha-Maske in der Schrift-Textur

markieren

Delphi-Quellcode:

if l_Col <> Fontcolor then begin
   l_rgbQuad.alpha := 0;
end else begin
   l_rgbQuad.alpha := 255;//
end;

Die Ausgabe funktioniert auch transparent, aber die nachfolgenden Objekte werden in dem Bereich des Texturhintergrundes auch durchsichtig als ob sie ein Loch hätten

markieren

Delphi-Quellcode:

 glenable( GL_Blend );
    glEnable(GL_TEXTURE_2D);
      glCallLists (length(in_text), GL_UNSIGNED_BYTE, @in_text[1]);
    gldisable(GL_TEXTURE_2D);
 glDisable(GL_Blend);

nun wollte ich verhindern, dass der Alphakanal beschrieben wird über:
glColorMask(true, true, true, false); dies zeigt aber keine Wirkung

markieren

Delphi-Quellcode:

 glenable( GL_Blend );
    glColorMask(true, true, true, false);
    glEnable(GL_TEXTURE_2D);
      glCallLists (length(in_text), GL_UNSIGNED_BYTE, @in_text[1]);
    gldisable(GL_TEXTURE_2D);
 glDisable(GL_Blend);

Ich vermute, dass der Depth-Buffer eher das Problem ist. Transparente Bereiche beschreiben den wie jedes andere Poly, und später dahinter liegende Teile werden dann nicht mehr gerendert. Wilkommen zu einem der Probleme, die in deinem anderen Thread angesprochen wurden, wenn man transparente Teile nicht nach allem anderen zeichnet

komischerweise haben nur die Löcher, die später gezeichnet werden und hinter der transparenten Textur liegen.
Die, die später gezeichnet werden und vor der transparenten Textur liegen, haben keine Löcher,
also funktioniert der Z-Buffer.

Ich will, dass die Textur voll transparent wird (funktioniert)
und den Alpha-Kanal für die nachfolgenden nicht blockiert.

Ja, genau das habe ich doch geschrieben. Deine Transparenten Teile landen im Z-Buffer, was aber zu früh ist. Entweder du sortierst alles von vorne herein von hinten nach vorne (dann braucht man aber praktisch keinen Z-Buffer mehr, und besonders schnell ist das auch nicht), oder du zeichnest eben, wie schon gelegentlich erwähnt, alles mit Transparenzen als letztes. Das ist die mit Abstand einfachste und performanteste Lösung*. Einen anderen Tipp kann ich dir nicht geben, und andere Wege wären vermutlich ziemliches Gefrickel, ausser man macht ohnehin schon etwas ganz anderes wie Deferred Rendering z.B. - da sind andere Lösungen gefragt.

*) Sobald mehrere transparente Faces hintereinander auftauchen können, müssen diese allerdings von hinten nach vorne sortiert werden. Sonst bekommt man genau das gleiche Problem wieder. Aber zumindest muss man so nur die transparenten Faces, und nicht alles B2F sortieren, was die Performance doch deutlich drücken würde.

Edit: Ganz lustig wird es, wenn sich Faces schneiden können und daran transparenzen beteiligt sind. Manche Enginges gehen in diesen Fällen sogar so weit die Schnittgeraden zu bestimmen und die Faces dynamisch zu splitten

kann ich irgendwie erzwingen, dass die Alphawerte nicht in den Z-Buffer geschrieben werden ?
Da muss es doch einen Filter geben.

Nein, der Z-Buffer wird anhand der Geometrie erzeugt, nicht anhand der Texturen.

Du könntest natürlich vor jedem transparenten Face den Z-Buffer duplizieren, dann das Face zeichnen - zwei mal, ein Mal in die Szene, ein Mal ganz alleine in eine weitere Textur, und nachher den neuen Z-Buffer anhand der Farb-Maske in der Textur aus der Sicherung Pixel für Pixel rekonstruieren. Ginge nur für volle Transparenz, und resultiert vermutlich in einer Performance die komplett jenseits jeglicher Nutzbarkeit liegt. Oder du zeichnest die transparenten Teile sortiert zum Schluss!!!! Wo ist denn das Problem dabei, dass du dich dermaßen stur dagegen wehrst?

so geht es nun, aber die Buchstabenkanten sind aber noch zu ruppig.
Gibt es evtl. einen Glättungsfaktor ?

markieren

Delphi-Quellcode:

 
glAlphaFunc(GL_GREATER, 0.3);
glEnable(GL_ALPHA_TEST);
     glcolor3f(1,1,1);
     glEnable(GL_TEXTURE_2D);
         glListBase(p_Textur_Schriftart.gl_List_base_gross);
         glCallLists (length(in_text), GL_UNSIGNED_BYTE, @in_text[1]);
     gldisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);

ich kann nun den Fonts verschiedene Farben geben, und die
Texturen über verschiedene Hintergrundfarben legen.
Leider sind die Kanten weniger schön.

Was für einen Interpolationsmodus hast du für deine Schrift-Textur genommen? In gewissen Grenzen hilft da Bi- bzw. Trilineare Interpolation schon etwas. Wenn du mal ein Bild hättest, ließe sich einfacher sagen wo genau da am besten zu drehen wäre.

Zitat von Medium:

Was für einen Interpolationsmodus hast du für deine Schrift-Textur genommen? In gewissen Grenzen hilft da Bi- bzw. Trilineare Interpolation schon etwas. Wenn du mal ein Bild hättest, ließe sich einfacher sagen wo genau da am besten zu drehen wäre.

markieren

Delphi-Quellcode:

  glBindTexture ( GL_TEXTURE_2D, l_textur_id );
         glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR );
         glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR );

         glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGBA, lb, lh, 0,
                        GL_RGBA, GL_UNSIGNED_BYTE, @texdata );

Wenn ich die Textur mit Hintergrund nehme siehts gut aus.
Ruppig wird's erst, wenn ich nur die Schrift auf einen anderen Hintergrund blende.
Ich wollte pro Fontsfarbe eine Liste generieren und diese dann variabel über verschiedene Hintergrundfarben legen.

Fazit:
das beste Ergebnis zum Ausblenden des Texthintergrundes erreiche ich über
glenable( GL_Blend ); womit transparente Stellen ausgeblendet werden und der Z-Buffer beeinflusst wird.
Daher werde ich diese Elemente wie die anderen transparenten Elemente zum Schluss nach z sortieren und dann zeichnen.

Wenn schon transparent, dann komplett: damit kann man dann auch die Schrift an sich über die Materialeigenschaft transparent setzen