Problem mit glColorMask(true, true, true, false);

[luisk]

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

setzen der Alpha-Maske in der Schrift-Textur

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

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:

Delphi-Quellcode:

glColorMask(true, true, true, false);

dies zeigt aber keine Wirkung :cry:

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);

[Medium]

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 ;)

[luisk]

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.

[Medium]

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 ;)

[luisk]

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

[Medium]

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?

[luisk]

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

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.:(

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

[luisk]

Zitat:

Zitat von Medium (Beitrag 1267588)

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.

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.

[luisk]

Fazit:
das beste Ergebnis zum Ausblenden des Texthintergrundes erreiche ich über

Delphi-Quellcode:

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

[Medium]

Öhm, davon war ich sogar schon ausgegangen - es ging doch bisher in deinen Threads immer nur um Text und dessen "Ausstanzen" zum Rendern. Aber das passiert, wenn man seine Fragen und Problembeschreibungen immer so kurz macht ;)

[luisk]

Zitat:

Zitat von Medium (Beitrag 1267657)

Öhm, davon war ich sogar schon ausgegangen - es ging doch bisher in deinen Threads immer nur um Text und dessen "Ausstanzen" zum Rendern. Aber das passiert, wenn man seine Fragen und Problembeschreibungen immer so kurz macht ;)

damit wäre es prinzipiell auch gegangen, ohne die z-Sortierung am Ende (die ich für das übliche transparente schon hatte)

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);

allerdings mit ner ruppigen Glättung


Meiner Meinung nach sollte OpenGL mal gescheite Vektorschriften einführen.
das, was da vorhanden ist wird beim Verkleinern zu früh unscharf (z.b. sieht ein E schon zu früh aus wie ein F oder gedrehtes F usw.....)
.... und das im Jahr 2014 bei den Hightechgrafikkarten :(

[Medium]

OpenGL ist halt keine Engine, sondern wirklich nur das eigentliche Zeichnen an und für sich. Mehr will und soll es auch nicht sein. Es gibt dir aber durchaus die Freiheit, ein Vektor-Font-System nach deinen Wünschen damit zu implementieren. Das ist auch gleichzeitig einer der Vorteile (und Ziele) bei nackten 3D APIs: Dir wird an keiner Stelle zu fest vorgegeben wie zu verfahren ist, man kann alles auf zig Wegen lösen, eben so wie es einem selbst am besten passt. Ich sehe einen Font hier ganz klar nicht im Verantwortungsbereich der API, aber es gibt sicherlich fertige Klassen oder ganze Engines, die eine solche Funktion mit bringen.

Mit den nackten APIs arbeiten meistens ohnehin fast nur noch die Entwickler der Engines. Nahezu alle Anwendersoftware setzt auf diesen auf. Alleine schon um die Abstraktion hinzubekommen, ein und das selbe Programm auf OGL, D3D, Softwareemulation oder welcher API auch immer betreiben zu können. (Natürlich gibt es oft auch In-House Entwicklungen bzgl. der Engine, aber nicht selten ist deren entwickelnder Personenkreis ein anderer als der, der die eigentlichen Programme/Spiele schreibt.)

Edit: Probier bei deinen Font-Texturen doch mal eine andere Interpolation aus. Linear ist gerade beim Verkleinern glaube ich eher nicht so schön. Und im schlimmsten Fall ließe sich auch noch eine von Hand optimierte kleinere Version des Fonts als Textur vorhalten, und du switched je nach dem wie groß der Text wird. (Ganz grob ähnlich wie es TrueType auch macht.)

[luisk]

Zitat:

Zitat von Medium (Beitrag 1267745)

Und im schlimmsten Fall ließe sich auch noch eine von Hand optimierte kleinere Version des Fonts als Textur vorhalten, und du switched je nach dem wie groß der Text wird. (Ganz grob ähnlich wie es TrueType auch macht.)

genau das werde ich tun. Schau mal auf #12

Delphi-Quellcode:

glListBase(p_Textur_Schriftart.gl_List_base_gross);

dazu gibt es dann noch:

Delphi-Quellcode:

glListBase(p_Textur_Schriftart.gl_List_base_klein);

:thumb: