Projektziel: Die Entwicklerversion von FlightGear (Zweig next, Version 2024.2) bringt echte Volumenwolken, eine neue Landschaft und eine neue Darstellung mit physikalisch basiertem Licht. Ich habe sie getrennt von der stabilen Version installiert und meine Dash 8 darin geflogen. Das Flugzeug flog sofort, sah aber falsch aus: ohne Lackierung, mit grünem Anzeigegerät, einer weißen Scheibe statt Höhenmesser und weißen Schildern am Blendschutz. Hier stehen die vier Ursachen und wie man ein Flugzeug so anpasst, dass es in beiden Versionen richtig aussieht.

Blick aus dem Cockpit der Dash 8 in FlightGear next auf Thüringen mit Volumenwolken
Bild 1 - FlightGear next: Dash 8 über Thüringen mit der neuen Landschaft und Volumenwolken

Was in der Entwicklerversion neu ist

  • Volumenwolken: Wolken sind keine flachen Bildchen mehr, sondern ein Gitter aus kleinen Würfeln (Voxeln) mit Dichtewerten. Ein Shader schickt pro Bildpunkt einen Strahl durch die Wolke und rechnet aus, wie viel Sonnenlicht durchkommt (Raymarching). Die Wolkenformen liegen als Bilder unter Textures/Sky/*.voxels.png.
  • Landschaft WS 3.0: Gelände und Bodenbedeckung kommen in einem neuen Format. TerraSync lädt sie in einen eigenen Ordner TerraSync_WS3.
  • Neue Darstellung: Materialien werden physikalisch basiert gerechnet (PBR). Alte Modelle laufen weiter, aber einige Techniken aus der 2024.1 gibt es nicht mehr.
Volumenwolken in FlightGear next: Haufenwolken unten, geschlossene Wolkendecke oben
Bild 2 - Volumenwolken: Haufenwolken unten, eine geschlossene Decke oben, mit Licht und Schatten

Getrennt installieren

Die stabile Version bleibt unangetastet. Die Nachtversion gibt es als AppImage auf flightgear.org, die passenden Daten (fgdata) holt man aus dem Zweig next. Wichtig sind ein eigener Einstellungsordner (FG_HOME) und der Schalter --launcher=false, sonst fragt das Programm nach dem Datenordner.


FG_NEXT="$HOME/FlightGear-next"
mkdir -p "$FG_NEXT/home" && cd "$FG_NEXT"
# AppImage der Nachtversion von flightgear.org/download/nightly hierher laden, dann:
chmod +x flightgear-*-linux-amd64.AppImage
git clone --depth 1 -b next https://gitlab.com/flightgear/fgdata.git fgdata

Ein kleines Startskript hält alles beisammen:


#!/bin/bash
D="$HOME/FlightGear-next"
export FG_HOME="$D/home"
exec "$D"/flightgear-*-linux-amd64.AppImage --fg-root="$D/fgdata" \
  --enable-terrasync --launcher=false "$@"

Eigene Flugzeuge bindet man mit --fg-aircraft= aus der stabilen Installation ein. FlightGear schreibt dort nichts hinein. Die alte Landschaft (WS 2.0) zeichnet next nur teilweise: Objekte und Höhe stimmen, der Boden erscheint aber als Wasser. Mit TerraSync lädt next die neue Landschaft selbst nach.

Landschaft WS 3.0 in FlightGear next am Flughafen Erfurt-Weimar
Bild 3 - Landschaft WS 3.0 bei Erfurt. Hinten noch Wasser, dort fehlen die Kacheln noch

Vier Fehler an der Dash 8

Was man siehtUrsache
Keine Lackierung, das Flugzeug ist weißDie Animation material gibt es in next nicht mehr
Anzeigegerät grün mit roter SchriftGraustufen-Textur mit Alpha wird als Rot/Grün gelesen
Weiße Scheibe statt HöhenmesserDas Glas ist nur über das Material durchsichtig
Weiße Schilder am BlendschutzBeschriftungsflächen ohne Effekt für Durchsichtigkeit

1. Lackierung: aus „material“ wird „pbr“

Lackierungen tauscht FlightGear über eine Animation, die eine Textur aus einer Eigenschaft liest. In der 2024.1 heißt sie material mit texture-prop. Im Quellcode von next (simgear, animation.cxx) fehlt diese Art ganz. An ihre Stelle tritt pbr mit base-color-texture-prop. Die 2024.1 kennt pbr nicht und überspringt die Animation. Trägt man also beide ein, wirkt in jeder Version die passende:


<!-- bisher, wirkt in 2024.1 -->
<animation>
  <type>material</type>
  <object-name>fuselage</object-name>
  <property-base>sim/model/livery</property-base>
  <texture-prop>texture</texture-prop>
  <texture>dhc-8-200.png</texture>
</animation>
<!-- neu, wirkt in next -->
<animation>
  <type>pbr</type>
  <object-name>fuselage</object-name>
  <base-color-texture-prop>/sim/model/livery/texture</base-color-texture-prop>
</animation>

Die Liste der Teile (object-name) ist dieselbe wie in der alten Animation. Bei der Dash 8 sind es 31. Der Pfad der Textur ist relativ zum Modellordner, wie bisher.

Dash 8 in FlightGear next ohne Lackierung, komplett weiß
Bild 4 - Vorher: Die Lackierung wird nicht gesetzt
Dash 8 in FlightGear next mit lila Leitwerk und Schriftzug
Bild 5 - Nachher: mit der zusätzlichen pbr-Animation

2. Graustufen-Texturen werden grün

Das Anzeigegerät ID-802 leuchtete grün, die Beschriftung rot. Die Textur ist ein PNG in Graustufen mit Alpha. Die neue Darstellung legt solche Bilder offenbar als zwei Farbkanäle an: Grau landet in Rot, Alpha in Grün. Abhilfe ist einfach, man speichert das Bild als normales RGBA. In der 2024.1 sieht es danach genauso aus wie vorher. Dieses Skript findet und wandelt alle Graustufen-Texturen eines Flugzeugs um (Pillow nötig, vorher eine Kopie anlegen):


import pathlib, sys
from PIL import Image

for f in pathlib.Path(sys.argv[1]).rglob("*.png"):
    im = Image.open(f)
    if im.mode in ("L", "LA"):
        ziel = "RGBA" if im.mode == "LA" else "RGB"
        im.convert(ziel).save(f, optimize=True)
        print(f, im.mode, "->", ziel)

Aufruf: python graustufen_umwandeln.py Aircraft/DHC-8. Bei der Dash 8 waren es sieben Dateien.

3. Das Glas wird zur weißen Scheibe

Vor dem Höhenmesser sitzt eine Glasscheibe. Ihre Durchsichtigkeit stand nur im Material des 3D-Modells (trans 0.85 in der AC3D-Datei). Der neue Shader für durchsichtige Teile multipliziert aber nur die Textur mit der Vertex-Farbe, und der Materialwert kommt dort offenbar nicht an. Dazu kam ein Tippfehler: Der Effekt für durchsichtige Teile zeigte auf alt.glass, das Teil heißt ALT.glass. Die 2024.1 kam damit zurecht, next nicht.

Lösung: Namen korrigieren und die Durchsichtigkeit in eine kleine Textur verlegen (grau, Alpha 0,15):


from PIL import Image
Image.new("RGBA", (8, 8), (204, 204, 204, 38)).save("glass-alpha.png")   # 38/255 = 0,15

<effect>
  <inherits-from>Effects/model-transparent</inherits-from>
  <object-name>ALT.glass</object-name>
</effect>

In der AC3D-Datei bekommt das Glas die Zeile texture "glass-alpha.png", und beim Material steht trans 0.000. So ergibt sich in beiden Versionen dieselbe Durchsichtigkeit.

4. Weiße Schilder am Blendschutz

Die Beschriftungen über den Tasten sind eigene Flächen mit durchsichtigem Hintergrund (im Modell *.lit). Der Effekt für Durchsichtigkeit stand nur für ein Teil namens glareshield_panel_label, das es im Modell gar nicht gibt. Die 2024.1 erkennt den Alpha-Kanal einer Textur von selbst, next zeichnet solche Flächen ohne Effekt undurchsichtig. Also kommen alle Beschriftungsflächen in den Effekt:


<effect>
  <inherits-from>Effects/model-transparent</inherits-from>
  <object-name>glareshield_panel.200.lit</object-name>
  <object-name>engine_fire.L.200.lit</object-name>
  <object-name>master_warning.lit</object-name>
  <!-- … alle übrigen *.lit-Teile -->
</effect>

Die Namen lassen sich direkt aus der AC3D-Datei lesen:


grep '^name ".*\.lit"' glareshieldpanel-123.ac
Cockpit der Dash 8 in FlightGear next vorher: grünes Anzeigegerät, weiße Scheibe, weiße Schilder
Bild 6 - Vorher: grünes ID-802, weiße Scheibe statt Höhenmesser, weiße Schilder
Cockpit der Dash 8 in FlightGear next nachher mit richtigem Anzeigegerät, Höhenmesser und Beschriftungen
Bild 7 - Nachher: alle vier Korrekturen, in der 2024.1 sieht es unverändert aus

Vergleich: Original, verbessert und next

Gleicher Blickwinkel, jedes Mal mit Strom, kurz vor dem Anlassen. Im Original (1) bleibt das EADI schwarz, das Anzeigegerät ID-802 leer, und auf dem Schild steht N/A. Die Flächen sind glatt grau. In meiner verbesserten Fassung hatten Instrumentenbrett und Blendschutz eine Kunststoff-Struktur bekommen. Im direkten Vergleich wirkte sie aber zu grob, fast wie fleckiger Beton. Ich habe sie auf ein Fünftel zurückgenommen (2). Dafür reicht es, den Alpha-Kanal der Struktur-Textur zu verkleinern:


from PIL import Image
im = Image.open("cockpit-grain.png")
r, g, b, a = im.split()
Image.merge("RGBA", (r, g, b, a.point(lambda v: round(v * 0.2)))).save("cockpit-grain.png")

In next (3) fehlt die Struktur ganz, denn der Effekt baut auf dem alten Shader auf, den die neue Darstellung nicht benutzt. Mit der schwachen Struktur sehen beide Versionen jetzt fast gleich aus. Die Anzeigen sind in next noch etwas blasser. Die Kontrollleuchten links neben dem ID-802 erschienen in next zunächst als weiße Kästchen. Wie bei den Beschriftungen fehlte ihnen der Effekt für Durchsichtigkeit, jetzt sind sie lesbar.

Dash-8-Cockpit in FlightGear: Original, verbesserte Fassung in 2024.1 und in FlightGear next
Bild 8 - Oben das Original, in der Mitte die verbesserte Fassung in 2024.1, unten dieselbe in next

Dazu: ein Wetterradar statt schwarzem Bildschirm

In der Mittelkonsole der Dash 8 sitzt ein Wetterradar Honeywell Primus 660. Im Modell war es nur ein Gehäuse mit schwarzem Bildschirm. Jetzt zeigt es eine Grundanzeige wie das echte Gerät: einen Sektor von 120 Grad mit Entfernungsbögen, einen schwenkenden Abtaststrahl, Modus, Reichweite und Antennenneigung (Tilt). Am Boden steht es auf STBY, denn am Boden wird nicht gesendet. Echos zeigt es keine: Ein echtes Wetterradar sieht nur Niederschlag, keinen Nebel und keine Schönwetterwolken.

Die Anzeige ist ein Canvas, das auf die Bildschirmfläche des 3D-Modells gelegt wird:


var anzeige = canvas.new({"name": "Primus660", "size": [512, 384], "view": [512, 384], "mipmapping": 1});
anzeige.addPlacement({"node": "primus660.display"});
anzeige.setColorBackground(0, 0, 0, 1);
var strahl = anzeige.createGroup().createChild("path")
    .setColor(0.1, 0.95, 0.2, 1).setStrokeLineWidth(2)
    .moveTo(0, 0).lineTo(0, -300);
strahl.setTranslation(256, 360);

var winkel = -60;
var richtung = 1;
var takt = maketimer(0.05, func {
    winkel += richtung * 3;
    if (winkel >= 60 or winkel <= -60) richtung = -richtung;
    strahl.setRotation(winkel * D2R);
});
takt.start();

Ein Haken: Die Bildschirmfläche lag im Modell 5 mm hinter der Gehäusefront und zeigte nach hinten. Solange sie schwarz war, fiel das niemandem auf. Erst als dort etwas zu sehen sein sollte, blieb sie unsichtbar. In der AC3D-Datei habe ich die vier Eckpunkte knapp vor die Front gesetzt und ihre Reihenfolge umgedreht, damit die Fläche nach vorn zeigt. Die Anzeige läuft in 2024.1 und in next.

Wetterradar Primus 660 der Dash 8 in FlightGear mit Entfernungsbögen und Abtaststrahl
Bild 10 - Wetterradar Primus 660 im Flug: Sektor, Abtaststrahl, WX, 20 NM, Tilt

Nachtbeleuchtung

Nachts blieb das Cockpit in next grau: keine leuchtenden Beschriftungen, keine Instrumentenbeleuchtung. Die Shader, die next für ältere Effekte benutzt, setzen die Leuchtkraft fest auf null, und die material-Animation, die bisher das Licht an- und ausdrehte, gibt es nicht mehr. Leuchten können in next nur die neuen PBR-Shader.

Die Lösung sind zwei eigene Effekte für Leuchtschichten und leuchtende Instrumente. Sie erben wie bisher von model-transparent bzw. model-default, sodass sich in 2024.1 nichts ändert, und bekommen zusätzlich die PBR-Technik aus next. Die Helligkeit kommt aus einer pbr-Animation, gekoppelt an die Instrumentenbeleuchtung:


<animation>
  <type>pbr</type>
  <object-name>glareshield_panel.200.lit</object-name>
  <emissive-factor>
    <red><property>systems/electrical/outputs/glareshield-norm</property><scale>0.02</scale></red>
    <green><property>systems/electrical/outputs/glareshield-norm</property><scale>0.02</scale></green>
    <blue><property>systems/electrical/outputs/glareshield-norm</property><scale>0.02</scale></blue>
  </emissive-factor>
</animation>

Drei Dinge musste ich dabei lernen:

  • Der Faktor heißt hier <scale>. Ein <factor> wird stillschweigend ignoriert.
  • Die Leuchtkraft ist physikalisch skaliert. Werte um 0,5 wirken wie Scheinwerfer, für Beschriftungen passen etwa 0,02, für Instrumente 0,008.
  • Die Leuchttextur beachtet den Alpha-Kanal nicht. Sonst leuchtet das ganze Schild statt nur der Schrift. Ich lege deshalb eigene Leuchttexturen an: Farbe mal Alpha, bei Instrumenten nur die weißen und farbigen Stellen.

import numpy as np
from PIL import Image

a = np.asarray(Image.open("glareshield.png").convert("RGBA")).astype(np.float32) / 255
leucht = a[..., :3] * a[..., 3:4]          # durchsichtige Stellen werden schwarz
Image.fromarray((leucht * 255 + 0.5).astype(np.uint8), "RGB").save("glareshield-leucht.png")

Im Cockpit der Dash 8 betrifft das 225 Teile in 43 Dateien, umgebaut mit einem kleinen Skript. Ein Stolperstein zum Schluss: Die 2024.1 lädt auch die Shader-Dateien von Techniken, die sie nie benutzt. Fehlen sie, wird das ganze Cockpit weiß. Der Patch bringt die Shader deshalb im Flugzeugordner unter Shaders/HDR/ mit, dort findet die 2024.1 sie.

Bildschirme brauchen einen eigenen Weg. Ihr Inhalt ist ein Canvas, und das Canvas lässt sich in next zusätzlich in die Leuchttextur legen. In der 2024.1 bedeutet "texture" „Textur mit diesem Namen ersetzen“, und eine Textur namens emissive gibt es dort nicht, also bleibt die Zeile ohne Wirkung:


EADI_display.addPlacement({"node": "EADI.screen"});
EADI_display.addPlacement({"node": "EADI.screen", "texture": "emissive"});   # next: Bildschirm leuchtet

Die Leuchtkraft der Bildschirme hängt am Sonnenstand. Die automatische Belichtung von next dunkelt bei Tag stark ab: Eine feste Leuchtkraft war nachts zu grell und am Tag unsichtbar. Warnlampen, die nur bei einem bestimmten Zustand leuchten, übernehmen ihre bisherige Bedingung, denn die pbr-Animation kennt ebenfalls <condition>:


<animation>
  <type>pbr</type>
  <object-name>EADI.screen</object-name>
  <emissive-factor>
    <red><property>/sim/time/sun-angle-rad</property><scale>-1.74</scale><offset>3.045</offset><min>0.008</min><max>1.5</max></red>
    <!-- green, blue gleich -->
  </emissive-factor>
</animation>
Cockpit der Dash 8 in FlightGear next nachts vor und nach dem Umbau der Beleuchtung
Bild 9 - FlightGear next nachts: oben ohne, unten mit Instrumenten- und Beschriftungsbeleuchtung

Was noch offen ist

  • Bildschirme sind in next bei Tag noch etwas blasser als in 2024.1.
  • Die Volumenwolken zeigen an manchen Stellen noch Streifen und harte Kanten. Das liegt an der Entwicklerversion selbst.
  • Mit dem ausdrücklichen Schalter für die HDR-Darstellung war bei mir auf einer AMD-Grafikkarte das ganze Bild grau. Ohne den Schalter lief alles.

Fazit

Die Entwicklerversion sieht schon jetzt deutlich besser aus, vor allem Wolken und Landschaft. Ein älteres Flugzeug fliegt darin sofort, braucht aber ein paar Anpassungen. Alle vier lassen sich so machen, dass die stabile Version unverändert bleibt: eine zusätzliche pbr-Animation, RGBA statt Graustufen, Durchsichtigkeit über die Textur und vollständige Effekt-Listen. Die Schritte stehen auch in der FlightGear-Doku, die geänderten Dateien sind im Dash-8-Patch.