Up to date

This page is up to date for Godot 4.2. If you still find outdated information, please open an issue.

Mehrere Auflösungen

Das Problem mit mehreren Auflösungen

Entwickler haben oft Probleme zu verstehen, wie sie mehrere Auflösungen in ihren Spielen am besten unterstützen können. Bei Desktop- und Konsolenspielen ist dies mehr oder weniger einfach, da die meisten Seitenverhältnisse auf dem Bildschirm 16: 9 betragen und die Auflösungen Standard sind (720p, 1080p, 1440p, 4K,…).

Für mobile Spiele war es zunächst einfach. Das iPhone und das iPad verwendeten viele Jahre lang dieselbe Auflösung. Bei der Implementierung von Retina wurde die Pixeldichte nur verdoppelt. Die meisten Entwickler mussten nun Inhalte in Standard- und doppelter Auflösung bereitstellen.

Heutzutage ist dies nicht mehr der Fall, da es viele verschiedene Bildschirmgrößen, Dichten und Seitenverhältnisse gibt. Auch unkonventionelle Größen wie Ultrawide-Displays werden immer beliebter.

Bei 3D-Spielen besteht keine große Notwendigkeit, mehrere Auflösungen zu unterstützen (aus ästhetischer Sicht). Die 3D-Geometrie füllt den Bildschirm nur basierend auf dem Sichtfeld aus, ohne das Seitenverhältnis zu berücksichtigen. Der Hauptgrund, warum man dies unterstützen würde, ist in diesem Fall die Performance (niedrigere Auflösung, um die Bilder pro Sekunde zu erhöhen).

Für 2D und Spiele-Benutzeroberflächen ist das eine andere Sache, da Grafik mit bestimmten Pixelgrößen in Software wie Photoshop, GIMP oder Krita erstellt werden muss.

Da sich Layouts, Seitenverhältnisse, Auflösungen und Pixeldichten so stark ändern können, ist es nicht mehr möglich, Benutzeroberflächen für jeden bestimmten Bildschirm zu entwerfen. Eine andere Methode muss verwendet werden.

Eine Größe für alle

Der gebräuchlichste Ansatz besteht darin, eine einzelne Basis -Auflösung zu verwenden und diese dann an alles andere anzupassen. Bei dieser Auflösung wird erwartet, dass die meisten Spieler das Spiel spielen können (sofern sie über die entsprechende Hardware verfügen). Für Handys hat Google nützliche Statistiken online, genauso bietet Steam dies auch für Desktops.

Steam zeigt beispielsweise, dass die häufigste primäre Anzeigeauflösung 1920 × 1080 ist. Daher ist es sinnvoll, ein Spiel für diese Auflösung zu entwickeln und dann die Skalierung für verschiedene Größen und Seitenverhältnisse durchzuführen.

Godot bietet verschiedene nützliche Werkzeuge, um dies einfach zu erledigen.

Siehe auch

Sie können sehen, wie Godots Unterstützung für mehrere Auflösungen in Aktion funktioniert, indem Sie das Multiple Resolutions and Aspect Ratios Demoprojekt ausprobieren.

Basisgröße

Eine Basisgröße für das Fenster kann in den Projekteinstellungen unter Anzeige → Fenster angegeben werden.

../../_images/screenres.png

Was es tut, ist jedoch nicht ganz offensichtlich; Die Engine wird nicht versuchen, den Monitor auf diese Auflösung umzuschalten. Stellen Sie sich diese Einstellung vielmehr als "Entwurfsgröße" vor, d.h. als Größe des Bereichs, mit dem Sie im Editor arbeiten. Diese Einstellung entspricht direkt der Größe des blauen Rechtecks im 2D-Editor.

Es besteht häufig die Notwendigkeit, Geräte mit Bildschirm- und Fenstergrößen zu unterstützen, die sich von dieser Basisgröße unterscheiden. Godot bietet viele Möglichkeiten wie die Größe des Ansichtsfensters geändert und auf verschiedene Bildschirmgrößen gestreckt werden kann.

Um die Basisgröße der Streckung zur Laufzeit von einem Skript aus zu konfigurieren, verwenden Sie die Property get_tree().root.content_scale_size (siehe Window.content_scale_size). Das Ändern dieses Wertes kann indirekt die Größe von 2D-Elementen verändern. Um jedoch eine für den Benutzer zugängliche Skalierungsoption bereitzustellen, wird die Verwendung von Streckungs-Skalierung empfohlen, da sie einfacher anzupassen ist.

Bemerkung

Godot verfolgt einen modernen Ansatz für mehrere Auflösungen. Die Engine wird die Auflösung des Monitors niemals von sich aus ändern. Das Ändern der Monitorauflösung ist zwar der effizienteste Ansatz, aber auch der unzuverlässigste, da der Monitor auf einer niedrigen Auflösung hängen bleiben kann, wenn das Spiel abstürzt. Dies ist besonders häufig unter macOS oder Linux der Fall, da diese Betriebssysteme mit Auflösungsänderungen nicht so gut umgehen können wie Windows.

Durch das Ändern der Bildschirmauflösung wird dem Spieleentwickler auch die Kontrolle über die Filterung und die Streckung des Seitenverhältnisses entzogen, was für die korrekte Darstellung von Pixel-Art-Spielen wichtig sein kann.

Außerdem wird durch die Änderung der Bildschirmauflösung das Ein- und Ausblenden eines Spiels durch Alt-Tabbing viel langsamer, da der Bildschirm jedes Mal die Auflösung ändern muss.

Größenänderung

Es gibt verschiedene Gerätetypen mit verschiedenen Bildschirmtypen, die wiederum unterschiedliche Pixeldichten und Auflösungen haben. Sie alle zu handhaben, kann eine Menge Arbeit sein, daher versucht Godot, das Leben des Entwicklers ein wenig einfacher zu machen. Der Viewport-Node hat mehrere Funktionen, um die Größenänderung zu handhaben, und der Root-Node des Szenenbaums ist immer ein Viewport (geladene Szenen werden als Child davon instanziiert, und es kann immer durch den Aufruf von get_tree().root oder get_node("/root") darauf zugegriffen werden).

In jedem Fall ist das Ändern der Root-Viewport-Parameter wahrscheinlich der flexibelste Weg, mit dem Problem umzugehen, aber es kann eine Menge Arbeit, Code und Rätselraten bedeuten, daher bietet Godot eine Reihe von Parametern in den Projekteinstellungen, um mehrere Auflösungen zu handhaben.

Streckungseinstellungen

Die Streckungseinstellungen befinden sich in den Projekteinstellungen und bieten verschiedene Optionen:

../../_images/stretchsettings.png

Streckungsmodus

Die Einstellung Streckungsmodus definiert, wie die Basisgröße gestreckt wird, um der Auflösung des Fensters oder Bildschirms zu entsprechen.

../../_images/stretch.png

Die folgenden Animationen verwenden eine "Basisgröße" von nur 16×9 Pixeln, um die Wirkung der verschiedenen Streckungsmodi zu demonstrieren. Ein einzelnes Sprite, ebenfalls 16×9 Pixel groß, deckt das gesamte Ansichtsfenster ab, und ein diagonales Line2D wird darüber gelegt:

../../_images/stretch_demo_scene.png
  • Streckungsmodus = Deaktiviert (Default): Es findet keine Streckung statt. Eine Einheit in der Szene entspricht einem Pixel auf dem Bildschirm. In diesem Modus hat die Einstellung Streckungsverhältnis keine Auswirkung.

    ../../_images/stretch_disabled_expand.gif
  • Streckungmodus = Canvas-Elemente: In diesem Modus wird die in den Projekteinstellungen in Breite und Höhe angegebene Basisgröße so gestreckt, dass sie den gesamten Bildschirm abdeckt (unter Berücksichtigung der Einstellung Streckungsverhältnis). Das bedeutet, dass alles direkt in Zielauflösung gerendert wird. 3D ist davon nicht betroffen, während es in 2D keine 1:1-Entsprechung zwischen Sprite-Pixeln und Bildschirm-Pixeln mehr gibt, was zu Skalierungs-Artefakten führen kann.

    ../../_images/stretch_2d_expand.gif
  • Streckungsmodus = Viewport: Viewport-Skalierung bedeutet, dass die Größe des Root-Viewport genau auf die im Abschnitt Display der Projekteinstellungen angegebene Basisgröße eingestellt wird. Die Szene wird zunächst in diesem Viewport gerendert. Schließlich wird dieser Viewport skaliert, um ihn an den Bildschirm anzupassen (unter Berücksichtigung der Einstellung Streckungsverhältnis).

    ../../_images/stretch_viewport_expand.gif

Um den Streckungsmodus zur Laufzeit von einem Skript aus zu konfigurieren, verwenden Sie die Property get_tree().root.content_scale_mode (siehe Window.content_scale_mode und das ContentScaleMode-Enum).

Streckungsverhältnis

Die zweite Einstellung ist das Seitenverhältnis der Streckung. Beachten Sie, dass dies nur wirksam wird, wenn Streckungsmodus auf etwas anderes als Deaktiviert eingestellt ist.

In den Animationen unten sehen Sie graue und schwarze Bereiche. Die schwarzen Bereiche werden von der Engine hinzugefügt und können nicht eingezeichnet werden. Die grauen Bereiche sind Teil Ihrer Szene und können eingezeichnet werden. Die grauen Bereiche entsprechen dem Bereich außerhalb des blauen Rahmens, den Sie im 2D-Editor sehen.

  • Streckungsverhältnis = Ignorieren: Ignoriert das Seitenverhältnis bei der Streckung des Bildschirms. Das bedeutet, dass die ursprüngliche Auflösung so gestreckt wird, dass sie genau den Bildschirm ausfüllt, auch wenn dieser breiter oder schmaler ist. Dies kann zu einer ungleichmäßigen Streckung führen: Dinge sehen breiter oder höher aus als vorgesehen.

    ../../_images/stretch_viewport_ignore.gif
  • Streckungsverhältnis = Beibehalten: Behält das Seitenverhältnis bei der Streckung des Bildschirms bei. Dies bedeutet, dass der Viewport seine ursprüngliche Größe unabhängig von der Bildschirmauflösung beibehält und schwarze Balken am oberen/unteren Bildschirmrand ("Letterboxing") oder an den Seiten ("Pillarboxing") hinzugefügt werden.

    Dies ist eine gute Option, wenn Sie das Seitenverhältnis Ihrer Zielgeräte im Voraus kennen oder wenn Sie nicht mit unterschiedlichen Seitenverhältnissen arbeiten möchten.

    ../../_images/stretch_viewport_keep.gif
  • Streckverhältnis = Breite beibehalten: Behält das Seitenverhältnis bei, wenn der Bildschirm gestreckt wird. Wenn der Bildschirm breiter ist als die Basisgröße, werden links und rechts schwarze Balken hinzugefügt (Pillarboxing). Ist der Bildschirm jedoch höher als die Basisauflösung, wird das Ansichtsfenster in vertikaler Richtung vergrößert (und es wird mehr Inhalt nach unten hin sichtbar). Sie können sich dies auch als "Vertikal erweitern" vorstellen.

    Dies ist normalerweise die beste Option zum Erstellen von skalierbaren GUIs oder HUDs, sodass einige Steuerelemente unten verankert werden können (Größe und Anker).

    ../../_images/stretch_viewport_keep_width.gif
  • Streckverhältnis = Höhe beibehalten: Behält das Seitenverhältnis bei, wenn der Bildschirm gestreckt wird. Wenn der Bildschirm größer als die Basisgröße ist, werden oben und unten schwarze Balken hinzugefügt (Letterboxing). Ist der Bildschirm jedoch breiter als die Basisauflösung, wird das Ansichtsfenster in horizontaler Richtung vergrößert (und es wird mehr Inhalt auf der rechten Seite sichtbar). Sie können dies auch als "Horizontal erweitern" bezeichnen.

    Dies ist in der Regel die beste Option für 2D-Spiele, die horizontal gescrollt werden (z.B. Runner oder Plattformer).

    ../../_images/stretch_viewport_keep_height.gif
  • Streckverhältnis = Erweitern: Beim Strecken des Bildschirms das Seitenverhältnis beibehalten, aber weder die Basisbreite noch die Basishöhe beibehalten. Je nach Seitenverhältnis des Bildschirms wird der Viewport entweder in horizontaler Richtung (wenn der Bildschirm breiter ist als die Basisgröße) oder in vertikaler Richtung (wenn der Bildschirm höher ist als die Originalgröße) vergrößert.

    ../../_images/stretch_viewport_expand.gif

Tipp

Um sowohl den Hoch- als auch den Querformatmodus mit einem ähnlichen automatisch ermittelten Skalierungsfaktor zu unterstützen, stellen Sie die Basisauflösung Ihres Projekts auf ein Quadrat (Seitenverhältnis 1:1) statt auf ein Rechteck ein. Wenn Sie beispielsweise eine Basisauflösung von 1280×720 wählen, aber sowohl den Hoch- als auch den Querformatmodus unterstützen möchten, verwenden Sie in den Projekteinstellungen 720×720 als Basisfenstergröße des Projekts.

Um dem Benutzer die Möglichkeit zu geben, seine bevorzugte Bildschirmausrichtung zur Laufzeit zu wählen, müssen Sie Anzeige > Fenster > Handheld > Ausrichtung auf Sensor setzen.

Um das Streckungsverhältnis zur Laufzeit aus einem Skript heraus zu konfigurieren, verwenden Sie die Property get_tree().root.content_scale_aspect (siehe Window.content_scale_aspect und das ContentScaleAspect-Enum).

Streckungs-Skalierung

Mit der Einstellung Skalierung können Sie einen zusätzlichen Skalierungsfaktor zu den bereits vorhandenen Streckungs-Optionen hinzufügen. Der Defaultwert 1,0 bedeutet, dass keine zusätzliche Skalierung erfolgt.

Wenn Sie zum Beispiel Skalierung auf 2.0 setzen und Streckungsmodus auf Deaktiviert lassen, wird jede Einheit in Ihrer Szene 2×2 Pixeln auf dem Bildschirm entsprechen. Dies ist ein guter Weg, um Skalierungsoptionen für Nicht-Spiel-Anwendungen bereitzustellen.

Wenn Streckungsmodus auf canvas_items eingestellt ist, werden 2D-Elemente relativ zur Basisfenstergröße skaliert und dann mit der Einstellung Skalierung multipliziert. Dies kann den Spielern mitgeteilt werden, um ihnen die Möglichkeit zu geben, die automatisch ermittelte Skalierung an ihre Wünsche anzupassen, um die Barrierefreiheit zu verbessern.

Wenn Streckungsmodus auf Viewport eingestellt ist, wird die Auflösung des Viewports durch Skalierung geteilt. Dies lässt die Pixel größer aussehen und reduziert die Rendering-Auflösung (bei einer bestimmten Fenstergröße), was die Performance verbessern kann.

Um die Skalierung zur Laufzeit von einem Skript aus zu konfigurieren, verwenden Sie die Property get_tree().root.content_scale_factor (siehe Window.content_scale_factor).

Streckungs-Skalierungsmodus

Seit Godot 4.2 können Sie mit der Einstellung Streckungs-Skalierungsmodus den automatisch ermittelten Skalierungsfaktor (wie auch die manuell festgelegte Streckungs-Skalierung-Einstellung) auf ganzzahlige Werte beschränken. Standardmäßig ist diese Einstellung auf Kommazahl gesetzt, was die Anwendung eines beliebigen Skalierungsfaktors erlaubt (einschließlich Kommazahlen wie 2,5). Wenn die Einstellung auf Ganzzahl gesetzt ist, wird der Wert auf die nächste Ganzzahl abgerundet. Anstelle eines Skalierungsfaktors von 2.5 würde er z.B. auf 2.0 abgerundet. Dies ist nützlich, um Verzerrungen bei der Darstellung von Pixelgrafiken zu vermeiden.

Vergleichen Sie diese Pixelgrafik, die mit dem Viewport-Streckungs-Modus angezeigt wird, wobei der Streckungs-Skalierungsmodus auf Kommazahl eingestellt ist:

Beispiel für Kommazahl-Skalierung (Pixel-Art sieht falsch aus)

Das Schachbrett sieht nicht "gleichmäßig" aus. Die Linienbreiten im Logo und im Text sind sehr unterschiedlich.

Diese Pixelgrafik wird auch mit dem Viewport-Streckungsmodus dargestellt, aber der Streckungs-Skalierungsmodus ist diesmal auf Ganzzahl eingestellt:

Beispiel für Ganzzahl-Skalierung (Pixel-Art wird korrekt dargestellt)

Das Schachbrett sieht vollkommen gleichmäßig aus. Die Linienbreiten sind gleichmäßig.

Wenn die Basisgröße des Viewports zum Beispiel 640×360 und die Fenstergröße 1366×768 beträgt:

  • Bei der Verwendung von fractional wird der Viewport mit einer Auflösung von 1366×768 angezeigt (Skalierungsfaktor ist ungefähr 2.133×). Der gesamte Fensterbereich wird genutzt. Jedes Pixel im Ansichtsfenster entspricht 2,133×2,133 Pixeln im angezeigten Bereich. Da Bildschirme jedoch nur "ganze" Pixel anzeigen können, führt dies zu einer ungleichmäßigen Pixel-Skalierung, die ein falsches Erscheinungsbild der Pixel-Art zur Folge hat.

  • Bei der Verwendung von Ganzzahl wird der Viewport mit einer Auflösung von 1280×720 angezeigt (Skalierungsfaktor ist 2×). Der verbleibende Platz wird mit schwarzen Balken an allen vier Seiten gefüllt, so dass jedes Pixel im Ansichtsfenster 2×2 Pixeln im angezeigten Bereich entspricht.

Diese Einstellung ist in jedem Streckungsmodus wirksam. Wenn man jedoch den deaktiviert-Streckungsmodus benutzt, wird nur die Streckungs-Skalierung-Einstellung beeinflusst, indem sie auf den nächsten ganzzahligen Wert abgerundet wird. Dies kann für 3D Spiele mit einer Pixel Art-UI verwendet werden, so dass der sichtbare Bereich im 3D-Viewport nicht verkleinert wird (was passiert, wenn man den canvas_items oder den Viewport-Streckungsmodus mit dem Ganzzahl-Skalierungsmodus verwendet).

Tipp

Games should use the Exclusive Fullscreen window mode, as opposed to Fullscreen which is designed to prevent Windows from automatically treating the window as if it was exclusive fullscreen.

Fullscreen is meant to be used by GUI applications that want to use per-pixel transparency without a risk of having it disabled by the OS. It achieves this by leaving a 1-pixel line at the bottom of the screen. By contrast, Exclusive Fullscreen uses the actual screen size and allows Windows to reduce jitter and input lag for fullscreen games.

When using integer scaling, this is particularly important as the 1-pixel height reduction from the Fullscreen mode can cause integer scaling to use a smaller scale factor than expected.

Häufige Anwendungsszenarien

Die folgenden Einstellungen werden empfohlen für eine optimale Unterstützung unterschiedlicher Bildschirmauflösungen und Seitenverhältnissen.

Desktop-Spiel

Nicht-Pixel Art:

  • Setzen Sie die Basisfensterbreite auf 1920 und die Fensterhöhe auf 1080. Wenn Sie einen Bildschirm haben, der kleiner als 1920×1080 ist, setzen Sie Fensterbreite Überschreiben und Fensterhöhe Überschreiben auf niedrigere Werte, damit das Fenster beim Start des Projekts kleiner ist.

  • Alternativ können Sie, wenn Sie hauptsächlich High-End-Geräte ansprechen, die Basisfensterbreite auf 3840 und die Fensterhöhe auf 2160 einstellen. Dadurch können Sie 2D-Assets mit höherer Auflösung bereitstellen, was zu einer schärferen Darstellung führt, allerdings zum Preis einer höheren Speichernutzung und Dateigröße. Beachten Sie, dass dies dazu führt, dass nicht-Mipmapping-Texturen auf Geräten mit niedriger Auflösung körnig werden, also stellen Sie sicher, dass Sie die Anweisungen befolgen, die in Reduzierung von Aliasing beim Downsampling beschrieben sind.

  • Setzen Sie den Streckungsmodus auf canvas_items.

  • Setzen Sie das Streckungsverhältnis auf expandieren. Dadurch werden mehrere Seitenverhältnisse unterstützt und hohe Smartphone-Displays (wie 18:9 oder 19:9) besser genutzt.

  • Konfigurieren Sie die Anker der Control-Nodes so, dass sie an den richtigen Ecken einrasten, indem Sie das Menü Layout verwenden.

Pixel-Art:

  • Setzen Sie die Basisfenstergröße auf die Größe des Ansichtsfensters, das Sie verwenden möchten. Die meisten Pixel-Art-Spiele verwenden Fenstergrößen zwischen 256×224 und 640×480. 640×360 ist eine gute Basisgröße, da sie sich bei ganzzahliger Skalierung ohne schwarze Balken auf 1280×720, 1920×1080, 2560×1440 und 3840×2160 skalieren lässt. Höhere Viewport-Größen erfordern eine höhere Auflösung des Bildmaterials, es sei denn, Sie wollen mehr von der Spielwelt zu einem bestimmten Zeitpunkt zeigen.

  • Setzen Sie den Streckungsmodus auf Viewport.

  • Setzen Sie das Streckungsverhältnis auf beibehalten, um ein einziges Seitenverhältnis (mit schwarzen Balken) zu erzwingen. Alternativ können Sie das Streckungsverhältnis auf expandieren setzen, um mehrere Seitenverhältnisse zu unterstützen.

  • Wenn Sie das Streckungsverhältnis expandieren verwenden, konfigurieren Sie die Anker der Control-Nodes so, dass sie an den richtigen Ecken einrasten, indem Sie das Menü Layout verwenden.

  • Setzen Sie den Streckungs-Skalierungsmodus auf Ganzzahl. Dies verhindert eine ungleichmäßige Pixelskalierung, die dazu führt, dass Pixel-Art nicht wie beabsichtigt angezeigt wird.

Bemerkung

Der Viewport-Streckungsmodus bietet ein Rendering mit niedriger Auflösung, das dann auf die endgültige Fenstergröße gestreckt wird. Wenn Sie kein Problem damit haben, daß sich Sprites in "Sub-Pixel"-Positionen bewegen oder rotieren können, oder wenn Sie ein hochauflösendes 3D-Viewport haben wollen, sollten Sie den canvas_items-Streckungsmodus anstelle des Viewport-Streckungsmodus verwenden.

Mobiles Spiel im Querformat

Godot ist standardmäßig für die Verwendung des Querformatmodus konfiguriert. Das bedeutet, dass Sie die Projekteinstellung für die Anzeigeausrichtung nicht ändern müssen.

  • Setzen Sie die Basisfensterbreite auf 1280 und die Fensterhöhe auf 720.

  • Alternativ können Sie, wenn Sie hauptsächlich High-End-Geräte ansprechen, die Basisfensterbreite auf 1920 und die Fensterhöhe auf 1080 einstellen. Dadurch können Sie 2D-Assets mit höherer Auflösung bereitstellen, was zu einer schärferen Darstellung führt, allerdings auf Kosten einer höheren Speichernutzung und Dateigröße. Viele Geräte haben Displays mit noch höherer Auflösung (1440p), aber der Unterschied zu 1080p ist angesichts der geringen Größe von Smartphone-Displays kaum sichtbar. Beachten Sie, dass dies dazu führt, dass nicht-Mipmapping-Texturen auf Geräten mit niedriger Auflösung körnig werden. Beachten Sie daher die Anweisungen in Reduzierung von Aliasing beim Downsampling.

  • Setzen Sie den Streckungsmodus auf canvas_items.

  • Setzen Sie das Streckungsverhältnis auf expandieren. Dadurch werden mehrere Seitenverhältnisse unterstützt und hohe Smartphone-Displays (wie 18:9 oder 19:9) besser genutzt.

  • Konfigurieren Sie die Anker der Control-Nodes so, dass sie an den richtigen Ecken einrasten, indem Sie das Menü Layout verwenden.

Tipp

Um Tablets und faltbare Smartphones (die häufig Bildschirme mit einem Seitenverhältnis von fast 4:3 haben) besser zu unterstützen, sollten Sie eine Basisauflösung mit einem Seitenverhältnis von 4:3 verwenden, während Sie den Rest der Anweisungen hier befolgen. Sie können zum Beispiel die Basisfensterbreite auf 1280 und die Basisfensterhöhe auf 960 einstellen.

Mobiles Spiel im Hochformat

  • Setzen Sie die Basisfensterbreite auf 720 und die Fensterhöhe auf 1280.

  • Alternativ können Sie die Basisfensterbreite auf 1080 und die Fensterhöhe auf 1920 setzen, wenn Sie hauptsächlich auf High-End-Geräte abzielen. Dadurch können Sie 2D-Assets mit höherer Auflösung bereitstellen, was zu einer schärferen Darstellung führt, allerdings auf Kosten einer höheren Speichernutzung und Dateigröße. Viele Geräte haben Displays mit noch höherer Auflösung (1440p), aber der Unterschied zu 1080p ist angesichts der geringen Größe von Smartphone-Displays kaum sichtbar. Beachten Sie, dass dies dazu führt, dass nicht-Mipmapping-Texturen auf Geräten mit niedriger Auflösung körnig werden. Beachten Sie daher die Anweisungen in Reduzierung von Aliasing beim Downsampling.

  • Stellen Sie Anzeige > Fenster > Handheld > Ausrichtung auf Hochformat.

  • Setzen Sie den Streckungsmodus auf canvas_items.

  • Setzen Sie das Streckungsverhältnis auf expandieren. Dadurch werden mehrere Seitenverhältnisse unterstützt und hohe Smartphone-Displays (wie 18:9 oder 19:9) besser genutzt.

  • Konfigurieren Sie die Anker der Control-Nodes so, dass sie an den richtigen Ecken einrasten, indem Sie das Menü Layout verwenden.

Tipp

Um Tablets und faltbare Smartphones (die häufig Bildschirme mit einem Seitenverhältnis von fast 4:3 haben) besser zu unterstützen, sollten Sie eine Basisauflösung mit einem Seitenverhältnis von 3:4 verwenden, während Sie den Rest der Anweisungen hier befolgen. Sie können zum Beispiel die Basisfensterbreite auf 960 und die Basisfensterhöhe auf 1280 einstellen.

Nicht-Spiel-Anwendung

  • Setzen Sie die Basisfensterbreite und -höhe auf die kleinste Fenstergröße, die Sie anvisieren. Dies ist nicht erforderlich, stellt aber sicher, dass Sie Ihre Benutzeroberfläche mit Blick auf kleine Fenstergrößen gestalten.

  • Lassen Sie den Streckungsmodus auf seinem Defaultwert, deaktiviert.

  • Behalten Sie das Streckungsverhältnis auf seinem Defaultwert, ignorieren (sein Wert wird nicht verwendet, da der Streckungsmodus deaktiviert ist).

  • Sie können eine minimale Fenstergröße definieren, indem Sie OS.min_window_size in der _ready() Funktion eines Skripts setzen. Dies verhindert, dass der Benutzer die Größe der Anwendung unter eine bestimmte Größe ändert, was das UI-Layout zerstören könnte.

Bemerkung

Godot unterstützt noch nicht das manuelle Überschreiben des 2D-Skalierungsfaktors, daher ist es nicht möglich, hiDPI-Unterstützung in Nicht-Spiel-Anwendungen zu haben. Aus diesem Grund wird empfohlen, Hidpi Erlauben in Nicht-Spiel-Anwendungen deaktiviert zu lassen, damit das Betriebssystem seinen Low-DPI-Fallback verwenden kann.

hiDPI-Unterstützung

Standardmäßig werden Godot-Projekte vom Betriebssystem nicht als DPI-kompatibel angesehen. Dies geschieht, um die Performance auf Low-End-Systemen zu verbessern, da die DPI-Fallback-Skalierung des Betriebssystems schneller ist als die Skalierung der Anwendung selbst (sogar bei Verwendung des Streckungsmodus Viewport).

Die vom Betriebssystem bereitgestellte DPI-Fallback-Skalierung funktioniert jedoch nicht gut im Vollbildmodus. Wenn Sie eine scharfe Darstellung auf HiDPI-Displays wünschen oder das Projekt den Vollbildmodus verwendet, empfiehlt es sich, Anzeige > Fenster > DPI > Hidpi zulassen in den Projekteinstellungen zu aktivieren.

Hidpi zulassen ist nur unter Windows und macOS wirksam. Auf allen anderen Plattformen wird es ignoriert.

Bemerkung

Der Godot-Editor selbst ist immer als DPI-fähig gekennzeichnet. Die Ausführung des Projekts aus dem Editor ist nur dann DPI-fähig, wenn Hidpi zulassen in den Projekteinstellungen aktiviert ist.

Reduzierung von Aliasing beim Downsampling

Wenn das Spiel eine sehr hohe Basisauflösung hat (z.B. 3840×2160), kann Aliasing auftreten, wenn das Downsampling auf eine wesentlich niedrigere Auflösung wie 1280×720 erfolgt.

Um dieses Problem zu lösen, können Sie Mipmaps für alle 2D-Texturen aktivieren. Die Aktivierung von Mipmaps erhöht jedoch die Speichernutzung, was auf leistungsschwachen mobilen Geräten ein Problem darstellen kann.

Umgang mit Seitenverhältnissen

Sobald die Skalierung für verschiedene Auflösungen berücksichtigt ist, stellen Sie sicher, dass Ihre Benutzeroberfläche auch für verschiedene Seitenverhältnisse skaliert. Dies kann mit Ankern und/oder Containern geschehen.

Skalierung des Sichtfelds

Die Eigenschaft Seitenverhältnis beibehalten des 3D-Kamera-Nodes ist standardmäßig auf den Skalierungsmodus Höhe beibehalten (auch Hor+ genannt) eingestellt. Dies ist in der Regel der beste Wert für Desktop-Spiele und mobile Spiele im Querformat, da Breitbildschirme automatisch ein breiteres Sichtfeld verwenden.

Wenn Ihr 3D-Spiel jedoch im Hochformat gespielt werden soll, kann es sinnvoller sein, stattdessen Breite beibehalten (auch Vert- genannt) zu verwenden. Auf diese Weise werden Smartphones mit einem größeren Seitenverhältnis als 16:9 (z. B. 19:9) ein größeres Sichtfeld verwenden, was hier logischer ist.

Skalieren von 2D- und 3D-Elementen in Viewports

Durch die Verwendung mehrerer Viewport-Nodes können Sie verschiedene Skalierungen für verschiedene Elemente verwenden. Auf diese Weise können Sie beispielsweise die 3D-Welt mit einer niedrigen Auflösung rendern, während 2D-Elemente in der nativen Auflösung bleiben. Dies kann die Performance erheblich verbessern, während das HUD und andere 2D-Elemente gestochen scharf bleiben.

Dazu wird der Root-Viewport-Node nur für 2D-Elemente verwendet, dann wird ein Viewport-Node erstellt, um die 3D-Welt anzuzeigen, und dieser wird mit einem SubViewportContainer- oder TextureRect-Node dargestellt. Im endgültigen Projekt wird es effektiv zwei Viewports geben. Ein Vorteil der Verwendung von TextureRect gegenüber SubViewportContainer besteht darin, dass lineare Filterung möglich ist. Dies lässt skalierte 3D-Viewports in vielen Fällen besser aussehen.

Siehe die 3D-Viewport-Skalierungs-Demo für Beispiele.