Edit: Abgetrennt auf Wunsch des „Originalthreadinhabers“ Lossy eX (siehe unten). --Horazont

Hi,

Ich bin gerade dabei ein ehemaliges (Free)Glut Projekt mittels GLFW umzusetzen. Daher benötige ich die TextSuite um das Manko von GLFW auszugleichen (kein Font-Rendering).

In meinem Programm wird momentan ein 2D-Koordinatensystem mit den Dimensionen (3, 3) erzeugt. Dazu wurde mittels glscale in einer Resize Funktion auf die enstprechenden Werte nach unten skaliert. Natürlich muss ich auch erzeugte Schriften etc. skalieren, damit sie ebenfalls korrekt in dieses Koordinatensystem eingefügt werden. Mit Freeglut habe ich das bislang relativ einfach gemacht:



Mit der TextSuite hab ich in dem Fall aber so meine Probleme. Hier muss ich ja die Größe der Schrift bei tsFontCreateCreatorA in Pixeln angeben, was aber bei der Skalierung irgendwie Probleme mit sich bringt. Stelle ich z.B. 18 ein und probiere mit verschiedenen Skalierungswerten herum (z.B. 0.025), so sieht die Schrift sehr unscharf und insgesamt sehr komisch aus. Stelle ich dagegen die Größe auf 100, so muss ich Skalierungswerte von ca. 0.0025 benutzen um in etw auf gleiche Größenverhältnisse zu kommen. Die Schrift sieht nun relativ scharf aus, aber gleichzeitig auch kantig.

Ich kenne mich mit Typografie überhaupt nicht aus und kann dieses Verhalten dadurch leider nicht nachvollziehn. Ich denke es liegt an der Einheit px bei der Schriftgröße, was mich aber jetzt auch nicht so umbedingt weiter bringt.

Für Hilfe wäre ich dankbar.

Warum skalierst du? Willst du die Skalierung zur Laufzeit ändern? Wenn nicht: Lass es einfach. Wenn ja: Wird es sehr schwierig, weil TextSuite Texturfonts verwendet. Du müsstest dann die Fonts für die jeweilige skalierung neu generieren, um ein gutes Schriftbild zu erreichen.

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Naja, ich möchte gerne in meinem OpenGL Fenster auf einem Wertebereich von -3 bis 3 auf beiden Achsen (2D) arbeiten. Das mache ich im Moment so:



Da das Fenster ja in der Größe anpassbar sein soll muss ich ja immer wieder richtig skalieren damit das auch immer gleich ausschaut. Ich frage mich allerdings ob dieser Ansatz überhaupt so richtig ist. Er funktioniert zwar (bis auf die Probleme beim Text), scheint mir aber wenig praktikabel. Kann man das auch viel einfacher lösen? Ich bin ja leider noch Neuling in Sachen OpenGL.

Auf jeden Fall muss die Schrift ja ebenfalls skaliert werden, damit die überhaupt im dargestellten Bereich auftaucht, die ist ja ansonsten viel zu groß. Aber evtl. hab ich da auch nen Denkfehler (siehe vorherigen Absatz).

EDIT: Hab jetzt die Resize-Funktion nochmal überarbeitet:



Dürfte nun eleganter sein als die vorherige Lösung. Das Problem mit der Schrift bleibt aber weiter bestehen.

Eine Bitte vorweg. Beiträge bitte nicht Tage (oder einen) später editieren. Denn so merkt man nicht, dass sich an einem Thema etwas verändert hat. Bei Antworten (selbst wenn sie nur Ergänzungen zu einem Beitrag von dir selbst sind) sieht man das direkt. Außerdem wird das Thema so auch indirekt noch ein bisschen gepuscht und für Andere ist klar, dass du immer noch daran hängst. Sollte auch in deinem eigenen Interesse sein.

Wie Horanzont aber schon gesagt hat. Die TextSuite benutzt Texturen um die Fonts darzustellen. Da die Texturen aber scharfe Strukturen haben ist es wichtig, dass die Schrift pixelgenau dargestellt wird. Zu mindest erhält man dann die besten Ergebnisse. Die TextSuite ist auch auf pixelgenau Darstellung ausgelegt. Entsprechend kann ich auch nur empfehlen, dass du versuchst Pixelgenau zu arbeiten. Alles Andere wird irgendwann einfach Frickelig und wendet sich dann den Erschaffer. Vorzugsweise sollte die Ansicht auch den Koordinatenurspung oben Links haben. Denn das ist das Nächste worauf die TextSuite ausgerichtet ist. Die Größe der anzuzeigenden Schrift sollte dann auch über die Größe beim Erstellen der Fonts geregelt werden. Denn um so größer die Schrift erstellt wird um so mehr Speicher verbraucht sie im Endeffekt in denen Texturen.

Zu dem grundsätzlichen Aufbau deines Programmes. Da kann ich dir nicht sagen "So und so solltest du das tun". Denn der Aufbau der Anwendung hängt auch immer damit zusammen was deine Anwendung können soll und was später eventuell noch kommen soll. Einen Denkfehler meine ich aber erkennen zu können. Wobei Fehler da nicht das richtige Wort ist. Du setzt deine Projektion/Modelview komplett beim Verändern der Fenstergröße. Das wirkt so als gehst du beim Rendern da gar nicht mehr dran. Ja es ist gut da so wenig wie möglich ran zu gehen. Da das nun mal Zeit kostet. Aber. Es lässt sich nicht immer vermeiden.

Das ist jetzt auch nur ein Schuss ins Blaue aus den oben genannten Gründen der Unwissenheit über deine Ziele. Ich würde wohl eher so vogehen, dass ich als Projektion eine pixelgenaue Darstellung wählen würde. Also glOrtho mit der Größe den Clientbereiches des Fensters. Damit hält man sich dann für Schrift, GUI oder sonst welche Darstellungen alle Optionen offen. Und für die eigentlichen Daten würde ich wärend des Renderns dann die ModelView mit glTranslate und glScale entsprechend anpassen, dass du wieder einen Bereich von -3 bis 3 bekommst. Die Skalierung ist denkbar einfach zu errechnen. Clienthöhe/Breite durch den Wertebereich. Die muss für X und Y gleich sein. Da du sonst Verzerrungen bekommst. Entweder vorher oder Nachher den Mittelpunkt verschieben. Und fertig.
Das Ganze sollte dann eventuell noch mit Push/PopMatrix gekappselt sein, damit die Grundmatrix erhalten bleibt. Das hätte dann noch den Vorteil, dass du später die Daten auf einen kleineren Bereich des Fensters einschränken könntest ohne die Ausgabe der Schrift anfassen zu müssen.

PS: Das wäre wohl sinnvoller in einem eigenen Thema aufgehoben. Kann das ein Mod mal absplitten? Danke.

Ja, also erstmal danke für deine ausführliche Antwort und auch für die Abspaltung (@Mod).


Du hast natürlich recht. Hab ich mir gar keine Gedanken gemacht. Bin irgendwie immer drauf geeicht Doppelposts zu vermeiden .

Vielleicht erst nochmal was zu meiner Anwendung. Es geht darum, mittels OpenGL und Ansi C eine Displayanwendung zu schreiben, die im Wesentlichen Positions- und Lagedaten (+weiteren Schnickschnack) in geeigneter Weise darstellen soll. Diese ganze Überlegung bzgl. des Koordinatensystems kam eigentlich dadurch zustande, dass ich mir überlegt hatte so die Datenverarbeitung vereinfachen zu können.


Das ist mir jetzt auch bewusst geworden .


Das ist richtig. Bislang hab ich da im weiteren Programmablauf nicht mehr großartig was gemacht.


Auf diese Darstellung bin ich inzwischen auch umgeschwenkt. Ergibt für mich auch viel mehr Sinn als das was ich vorher fabriziert hab.

Das ist ja ungefähr das was ich im meinem ersten Bsp. machen wollte. An die Kapselung per Push/Pop hab ich in dem Fall aber gar nicht gedacht. Eigentlich muss ich ja dann nur noch Clientkoordinaten in für meinen Wertebereich passende umrechnen um auch den Text passend platzieren zu können, oder? Eine saubere Trennung von Text- und Objektbereich ist nicht möglich, da einige Elemente z.B. eine Beschriftung erhalten müssen.

Na ja. Du kannst ja auch während dem Zeichnen die Matrixen sichern und verändern. Also wenn du beim Zeichnen der Daten feststellst, dass jetzt genau hier einen Text ausgegeben werden muss, dann PushMatrix, LoadIdentity, Text Ausgeben, PopMatrix. Wenn du zu oft umschalten musst, dann würde ich aber wohl eher empfehlen, dass du die Texte + Positionen irgendwo zwischen speicherst und anschließend die Texte in einem Rutsch zeichnest. Da muss man aber auch betrachten ob es etwas zeitkritisches ist bzw. ob es zu langsam für den entsprechenden Fall wird. Spiele sind da deutlich zeitkritischer als normale Desktopanwendungen. Wenn das auch nicht möglich wäre, dann muss man den Fall im Speziellen betrachtet und sich etwas maßgeschneidertes dafür ausdenken.

Ich mache das im Moment genau so wie du es angesprochen hast. Bzgl. der Performance etc. kann ich selbst momentan gar keine Aussage treffen, aber gut zu wissen, dass ich da später evtl. drauf achten muss.

Nachdem ich jetzt auf die Pixelgenaue Darstellung umgeschwenkt bin klappt das mit der Schrift auch alles viel leicher (oh Wunder ). Leider hab ich das Problem, dass z.B. die Beschriftung eines Kreises (mit Zahlen) teilweise immer noch etwas blass und unscharf aussieht. Bestimmte Zahlen sehen dagegen jedoch nun sehr scharf aus. Wie kann so ein Unterschied zustande kommen? Liegt das daran, dass ich zwecks genauer Positionierung immer noch mit Faktoren wie "Radius*1.16" oder so arbeiten muss? In einer vorherigen Programmversion mit Freeglut ist das damals auch schon aufgetreten, in der aktuellen Version ist dieser Effekt aber irgendwie stärker. Allerdings arbeitet die Freeglut Version noch mit dieser Skalierung von glOrtho, etc.

In beiden Versionen wird sind Einstellungen wie GL_LINE_SMOOTH oder glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) zweckes Linienglättung aktiviert. Bei der Textsuite Version ist auch TS_ANTIALIASING_NORMAL aktiviert. Änderungen all dieser Einstellungen hat aber eigentlich keinen nennenswerten Effekt, daher denke ich liegts immer noch an der Art meiner Positionierung (besonders weil manche Zahlen, Buchstaben ja scharf sind).

Ich werde noch ein Bild dazu hochladen, hab das Programm aber grad nicht zur Hand.

Ich würde mal versuchen, die Positionen danach auf ganze Pixel zu rastern, also zu runden. Sonst wird dir die Texturfilterung/Antialiasing/irgendwas nen strich durch die rechnung machen.

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

@Performance: Na ja. Bei grafischen Anwendungen musst du immer auf die Performance achten. Selbst wenn es nur aus einem "Yo alles schnell genug" besteht. Da sollte man auch nicht vergessen auf welchen Systemen die Anwendung laufen wird. Wenn die deutlich kleiner sind als dein System muss man das berücksichtigen.

@Darstellung: Ja. Bilder sind da immer gut. Ansonsten TS_ANTIALIASING_* besagt nichts mit OpenGL sondern ob die Buchstaben mit einer weichen Kante in die Textur gerendert werden. Und wie Horazont gesagt hat. Bei Texturfonts wie der TextSuite musst du immer darauf achten, dass die Position (wie sie OpenGL sieht) immer ganze Zahlen sind. Also sich mit den Pixeln auf dem Bildschirm deckt. Wenn du zum Beispiel vorher ein ganz kleines Scale (1.05), Translate (0.5) oder Rotate (mit allem was kein Vielfaches von 90 ist) machst dann greift der Texturfilter und die Texturen der Buchstaben werden direkt matschig.

Das könnte tatsächlich relevant für mich sein. Wurde bisher gar nicht so thematisiert im Rahmen meiner Aufgabestellung. Muss aber zugegeben, dass ich daran bislang noch keinen Gedanken verschwendet hab, aber man lernt ja dazu .

Ok, werde mich mal dranmachen auf ganze Pixel zu runden. Mal schaun was dabei raus kommt. Ansonsten liefer ich morgen auch mal die Vergleichsbilder nach.