PureBoard

Hallo Leute,

ich habe ein Problem mit der Umrechnung von Punkten zu Pixel.

Also man hat z.B. 2 Bilder mit verschiedenen Auflösungen:

Bild 1: x:1024 y:768
Bild 2: x:800 y:600

Beim Font-Befehl setze ich jetzt z.B eine Schriftgröße von 72.
Beim 1. Bild wird jetzt ein Text auf das Bild ausgegeben.
Beim 2. Bild wird jetzt ein Text auf das Bild ausgegeben.
Dieser Text wird ja jetzt bei Bild 1 kleiner als bei Bild 2 dargestellt.

Wie bekomme ich jetzt beide Texte an die Bildauflösung angepasst.
Man soll bei Vollbildbetrachtung beider skalierter Bilder keinen Größenunterschied der Texte sehen.

Welche Schriftgröße müsste jetzt Bild 2 haben ?

Du berechnest das Verhältnis 600 / 768 (oder eben 800 / 1024) und multiplizierst es mit der Schriftgröße. Das wären nach Adam Riese 56,25.

Kleine Anmerkung
https://de.wikipedia.org/wiki/Adam_Ries

Walter

Bekommt man den Multiplikator nicht mit 1024 / 800 (=1,28)?

Es kommt eben drauf an, welches der beiden Bilder "richtig" aussieht und welches sich anpassen soll. Ich ging jetzt davon aus, dass Bild 1 richtig aussieht.

Nachrüstlösung:

einmal am Anfang: factor.f = tatsaechlicheScreenHeight / screenHeightFuerDieDuEsBisherGemachtHast

Oder, wenn noch andere Bildschirmseitenverhältnisse dazukommen und dadurch die Breite der Textausgaben ein Problem werden könnte:
factorX.f = tatsaechlicheScreenWidth / screenWidthFuerDieDuEsBisherGemachtHast
factorY.f = tatsaechlicheScreenHeight / screenHeightFuerDieDuEsBisherGemachtHast
factor.f = der kleinere von den beiden

und ab dann dann alle Fontgrößen sowie alles andere an Pixelangaben, was skaliert werden soll, erst mit factor.f multiplizieren und dann abrunden (mit int()).

Das blöde ist eben, dass man bei "LoadFont" nur Ganzzahlen als Höhe angeben kann. Das heißt man kriegt es nie genau hin, außer die resultierende Schriftgröße aus ursprünglicher Schriftgröße mal den Faktor ist eine Ganzzahl. Um es schön zu machen, müsste man die Größe der Zeichenfläche so anpassen, dass die resultierende Schriftgröße die auf die nächste Ganzzahl aufgerundete gewünschte Schriftgröße ist und dann das Bild wieder auf die gewünschte Größe verkleinern.
Aber dann könnte man genauso gut gleich nur das große Bild erstellen und es dann verkleinern. Erst wenn das große Bild viel größer ist als das kleinere, lohnt sich das obige Prozedere.

Oder man macht bei allem GUI-Elementen ebenfalls Integer-Abstufungen (1x, 2x, 3x...). Man könnte in dem Zug auch dem Anwender anbieten, die Größe der GUI selber einzustellen. Dann fällt das
nicht auf und hat nichts zu skalieren und auch keine Fontprobleme.

Die kleinste Variante sollte dabei auf 640x480 ohne Platzprobleme nutzbar sein. Ich finde es leichter, ein Spiel nachträglich für höhere Auflösungen zu machen, als andersherum. Ich habe sogar immer mit 320x240 entwickelt und erst ganz am Schluss die Kompatiblität zu hohen Auflösungen eingebaut.

Gibt immerhin viele (meist ältere) Spiele, die das so machen (Minecraft, C&C, Anno, WoW...)

Oder man rundet eben einfach. Merkt kein Schwein, ob ein Font nun 16.333331497px oder 16px sind.

2D-Spielgrafik selbst sollte natürlich ausreichend Reserven zum Skalieren aufweisen. alle Grafikelemente sollten nur einmal am Beginn passend skaliert werden. Dementsprechend kann die Skalierung hochwertig ausfallen. Bei 3D macht die Grafikkarte das ohnehin selber.

Das mit dem Skalieren der Fonts ist imho Mist (u.a. wegen diesem ClearType-Zeugs, was dann nicht mehr richtig funktioniert). Dann wäre es nur auf der einen Auflösung wirklich scharf und es müsste in Echtzeit skalieren (immer dann, wenn sich was im skalierten Bereich ändert). Gleich die passende Größe rendern würde ein besseres Ergebnis liefern.

DarkSoul hat geschrieben:Das mit dem Skalieren der Fonts ist imho Mist (u.a. wegen diesem ClearType-Zeugs, was dann nicht mehr richtig funktioniert). Dann wäre es nur auf der einen Auflösung wirklich scharf und es müsste in Echtzeit skalieren (immer dann, wenn sich was im skalierten Bereich ändert). Gleich die passende Größe rendern würde ein besseres Ergebnis liefern.

ClearType ist ein gutes Argument. Genau wie Subpixel-Antialiasing ansich. Aber letzteres sollte bei Ausdrucken keinen Unterschied machen, da es bei Druckern keine Subpixel gibt.
Das heißt, damit es richtig funktioniert, müsste man bei 'LoadFont' Floats angeben können und keine Ganzzahlen.