Wie am besten für versch. Auflösungen programmieren?

[Wanginator]

Eine Frage, die mich schon öfters beschäftigt, da ich oft an dieses Problem gestoßen bin: Was ist der beste Ansatz um Programme für versch. Auflösungen zu schreiben bzw. zu optimieren?

Dabei sind normale Desktopprogramme gemeint, dessen Fenster man beliebig groß skalieren kann dazu führen soll, dass sich die Steuerelement dementsprechend anordnen, Fontgröße einstellt usw. Oder aber auch für Spiele in z.B. OpenGL wofür es eine feste Anzahl an Auflösungen gibt. Das bishererige positionieren von Elementen an Pixel (100, 100) zum Beispiel funktioniert ja dann nicht mehr.

Meine naiven Ansätze wären:
- für kleine Auflösung entwickeln, dann für vom Benutzer ausgewählte Auflösung hochskalieren (-> Grafiken werden matschig)
- für hohe Auflösung entwicklen, dann für vom Benutzer ausgewählte Auflösung runterskalieren (-> Texte werden unleserlich)
- Breite und Höhe als Fließkommazahlen zwischen 0 und 1 auffassen

Sehr schön ist ja WPF und C#. Da alles vektororientiert ist, kann man für eine Größe entwicklen und das Skalieren (inkl. Anti-Aliasing) wird vom Framework übernommen. Aber was wenn man in C, C++, Java,... programmiert?

[Monger]

Wenn du eine frei skalierbare Fenster Anwendung hast (so wie man es auch von Office her kennt), ist ein automatisches skalieren der Font-Größe ziemlich problematisch.

Glaub mir, das geht dem Benutzer zuwider. Wenn du ein Fenster größer ziehst, erwartest du ja gerade, dass du jetzt mehr Platz hast. Du kannst durchaus irgendwo ne Option für die Fontgröße reinpacken, so dass der Benutzer es bei Bedarf selber auf eine angenehme Größe anpassen kann, aber automatisch würde ich da nix machen.

Für das Layout an sich sind in Java z.B. sogenannte "LayoutManager" zuständig. Die heftest du an bestimmte Komponenten ran, und gibst ihnen dann Eigenschaften, wie sie ihren Inhalt skalieren sollen, z.B. strecken, ziehen, an der linken oberen Ecke festheften etc.
Das funktioniert in C# und C++ wohl grundsätzlich mal genauso, nur verbirgt eine gute IDE das nach Möglichkeit vor einem. In Visual Studio läuft das halt alles im Hintergrund ab.

3D Anwendungen sind nochmal ein völlig anderes Feld, weil du da ja üblicherweise in Full Screen arbeitest. Da wirst du dann Texte u.a. direkt in den Viewport reinrendern, und die werden dann eben genauso wie alles andere auch entsprechend der Auflösung skaliert.

[rotalever]

3D Anwendungen sind nochmal ein völlig anderes Feld, weil du da ja üblicherweise in Full Screen arbeitest. Da wirst du dann Texte u.a. direkt in den Viewport reinrendern, und die werden dann eben genauso wie alles andere auch entsprechend der Auflösung skaliert.
Ja da muss man aber auch darauf achten wie man das mit der GUI macht. Einfach den Text/die 2D-Graphiken skalieren ist halt nicht so gut. Besser man nimmt Vektorgraphiken und rendert den Text für höhere Auflösungen auch in anderer Größe und überlässt es dem Nutzer dann selber noch mal zu skalieren. Das Positionieren der Elemente unterscheidet sich von einem normalen GUI noch in sofern, dass man ja nicht ein einzelnes Fenster hat, wo man die Widgets positioniert, sonder diese Müssen über den ganzen Bildschirm verteilt sein. Da empfielt sich möglicherweise eine relative Positionierung, also wenn man vorher gesagt hat, dass die Statusbar bei (40px,400px) anfängt und die Lebensanzeige bei (380,20px) dann sagt man besser die Statusleiste ist relativ zum unteren Bildschirmrand 80px entfernt und zentriert und die Lebensanzeige ist 100px vom rechten rand entfernt und hat einen Abstand von 20px nach oben. Das ermöglich halt meiner Meinung nach die bessere Skalierung.

[Wanginator]

Grund für meine Frage ist, dass ich gerade eine 3D Anwendung in OpenGL schreibe. Im Hauptmenü kann man die Auflösung einstellen und da steht natürlich auch viel Text für die einzelnen Optionen.

Nun render ich den Text, sodass er auf 1024x768 gut aussieht. Bei höheren Auflösungen sieht das auch noch ok aus. Bei niedrigen, speziell 640x480 sieht alles total matchig und nicht leserlich aus. Nun ist Textrendering in OpenGL ja ne Sache für sich, aber ich weiß nicht wie ich die Schrift gut hinbekomme. Antialiasing hat auch nichts gebracht. Die Computerspielehersteller schaffen es ja auch...

[Trap]

Den Text muss man natürlich in der Größe rendern in der er auch angezeigt werden soll. Mit TTF-Schriften und entsprechender Bibliothek zum Textrendering ist das kein Problem.

[Gast]

Sehr schön ist ja WPF und C#. Da alles vektororientiert ist, kann man für eine Größe entwicklen und das Skalieren (inkl. Anti-Aliasing) wird vom Framework übernommen. Aber was wenn man in C, C++, Java,... programmiert?

Mal ne Anfängerfrage: bin mich da gerade etwas am einlesen, geht das vektororientierte schon out-of-the-box oder ist dafür das öminöse XNA zuständig?

[Monger]

Mal ne Anfängerfrage: bin mich da gerade etwas am einlesen, geht das vektororientierte schon out-of-the-box oder ist dafür das öminöse XNA zuständig?
Weder noch. Wenn du das aktuelle Visual Studio 2008 nimmst, kann man dort auch WPF Anwendungen erstellen. Die haben ganz eigene Controls, die mit den alten Windows Controls erstmal nichts zu tun haben - und eben vektororientiert arbeiten.

[RMC]

Nun render ich den Text, sodass er auf 1024x768 gut aussieht. Bei höheren Auflösungen sieht das auch noch ok aus. Bei niedrigen, speziell 640x480 sieht alles total matchig und nicht leserlich aus. Nun ist Textrendering in OpenGL ja ne Sache für sich, aber ich weiß nicht wie ich die Schrift gut hinbekomme. Antialiasing hat auch nichts gebracht. Die Computerspielehersteller schaffen es ja auch...


MipMaps ;)

[rotalever]

Nun render ich den Text, sodass er auf 1024x768 gut aussieht. Bei höheren Auflösungen sieht das auch noch ok aus. Bei niedrigen, speziell 640x480 sieht alles total matchig und nicht leserlich aus. Nun ist Textrendering in OpenGL ja ne Sache für sich, aber ich weiß nicht wie ich die Schrift gut hinbekomme. Antialiasing hat auch nichts gebracht. Die Computerspielehersteller schaffen es ja auch...
Wie renderst du denn den Text? Also ich habe mir mal ne kleine Bibliothek zusammengebastelt, die die freetype2 Library nimmt und dann Strings in gerenderten Text umwandelt, diesen Text schiebe ich dann einfach als Textur in die Graphikkarte und render den ganz normal auf den Bildschirm. Wird die Auflösung verändert, so verändere ich die Schriftgröße automatisch und rendere den TTF-Text neu und übertrage das Schriftbild wieder als Textur auf die Graka.

[rotalever]

MipMaps ;)
Man sollte offscreen gerenderten Truetype Text aber eigentlich nicht mit der Graphikkarte skalieren, sondern lieber nochmal komplett neu rendern. Das erzeugt eigentlich immer bessere Qualität. Auch wenn die Graphikkarte nur Down-Scaled. Zwar sind da mip-maps schon ganz gut, aber die richtige Bibliothek kann eben auch Hinting etc.

[Wanginator]

Ich benutze zur Zeit Slick um mit Java Text in OpenGL zu rendern. Die benutzen default AngelCodeFonts was bei Aulösungsänderung schlecht aussieht. Habe jetzt auf TrueTypeFonts umgestellt und sieht schon etwas besser aus.

slick.cokeandcode.com