Zieltext abgeschnitten

es gibt noch Einträge in der Vmatrix_constfile_K++.txt

die ersten 3 sind selbsterklärend

Pixel Faktor, keine Ahnung

[const]
Matrix_Width
230

[const]
Matrix_Height
32

[const]
Matrix_HxW
7360

[const]
Matrix_PixelFactor
4

dazu solltest dir ggf. noch einen neuen Bitmap-Ordner zulegen. Sonst finde ich auch keine Hinweise weiter, wo die Auflösung gesteuert wird

            "..\..\Anzeigen\Krueger\230x32\palettes\" (L.$.yard) $+ ".bmp" $+

' else-1-3
                "..\..\Anzeigen\Krueger\"
                (L.L.Matrix_Res) 2 =
                {if}
                    "230x32\" $+

Moin, also zunächst muss ich dich enttäuschen: Die Matritzen in den MAN NLC von Schröder Reisen und DB Regio Nord-Ost haben alle eine Auflösung von 240x32, also 40 Pixel mehr als die reguläre 200x32-Matrix, wie man sie von aktuell allen BVG-Fahrzeugen kennt.

Ich vermute mal, du hast als Grundlage die Matrix aus dem MX C2 genommen. Es ist in jedem Fall nötig, im Script ein paar Änderungen vorzunehmen. Evtl. reicht es jedoch schon aus, die 200 durch eine 240 zu tauschen und es geht alles wie gewollt.

Da die Textur 256 Pixel breit ist, brauchst du gar keine breitere Auflösung, denn 240 < 256. Also gehen auch 1024 weiterhin für die hochskalierte Textur. Übrigens mag OMSI gerne Texturen mit 2er-Potenzen als Auflösung. 1024x1024 geht, aber auch sowas wie 512x64, es müssen also nicht quadratische Texturen sein.

Also ich weiß zwar nicht, was dich an meiner Anzeige aus dem 300er Solaris gestört hat, aber darum geht es ja hier nicht.

Das Problem liegt jedenfalls in zu wenigen Durchläufen beim pixelweisen Übertragen der ersten Skripttextur auf die zweite Skripttextur mit einer höheren Auflösung (doppelte Höhe+Breite soweit ich weiß). Diese werden im Skript unten im Makro Matrix_PrintBitmap festgelegt:

{macro:Matrix_PrintBitmap}
    0 (S.L.Matrix_Cursor)
    (M.L.Matrix_PrintBitmapPixel10)
    (M.L.Matrix_PrintBitmapPixel7)
    (M.L.Matrix_PrintBitmapPixel6)
    (M.L.Matrix_PrintBitmapPixel5)
    (L.L.Matrix_Modul) 0 =
    {if}
        (M.L.Matrix_PrintBitmapPixel12)
        (M.L.Matrix_PrintBitmapPixel10)
        (M.L.Matrix_PrintBitmapPixel5)
    {endif}
    (L.L.Matrix_Modul) 2 =
    (L.L.Matrix_Modul) 3 = ||
    {if}
        (M.L.Matrix_PrintBitmapPixel12)
        (M.L.Matrix_PrintBitmapPixel11)
        (M.L.Matrix_PrintBitmapPixel10)
        (M.L.Matrix_PrintBitmapPixel9)
        (M.L.Matrix_PrintBitmapPixel7)
        (M.L.Matrix_PrintBitmapPixel5)
        (M.L.Matrix_PrintBitmapPixel4)
    {endif}
    0 (S.L.Matrix_Cursor)
{end}

Dabei wird geguckt, welche Anzeige (Vorne, Fahrerseite/Heck oder Linie) gerade übertragen werden soll. In jedem Fall wird aber die Pixelanzahl der Linienanzeige übertragen (siehe Zeile 3-6), was 48 x 26 = 1248 Pixel sind. Die Variable Matrix_Modul entscheidet nun, wie viele Pixel noch für die jeweilige Anzeige übertragen werden müssen. Beim Wert 0 handelt es sich um die Frontanzeige, also die Anzeige, die nun um 40x32 Pixel größer geworden ist. Übertragen werden aber nur 200 x 32 = 6400 Pixel, es müssten aber nach der Vergrößerung 240 x 32 = 7680 Pixel sein, es fehlen also 1280 Pixel. Das sind 5 und 1/3 Reihen, wie auch auf dem Bild von dir zu sehen.
Die Makros Matrix_PrintBitmapPixelXX definieren nun also die Anzahl der Durchgänge. Dabei gilt: Anzahl = 2^XX. Somit muss man die Zahl 7680 nach Abzug der 1248 Pixel von der Linienanzeige in eine Binärzahl umwandeln. 6432 sieht in binärer Schreibweise so aus: 1100100100000. Nun muss man also von hinten an mit 0 beginnend (!) abzählen, wo eine 1 steht. Dabei kommen die Zahlen 5, 8, 11 und 12 raus. Nun einfach viermal das Makro Matrix_PrintBitmapPixelXX unter (L.L.Matrix_Modul) 0 = und dem darauffolgenden {if} mit den genannten Zahlen für XX aufrufen lassen und es wird genau die korrekte Anzahl an Durchgängen durchgeführt, sodass kein Pixel am Ende in OMSI auf der Anzeige fehlt (sofern ich keinen Rechenfehler hatte :D):

{macro:Matrix_PrintBitmap}
    0 (S.L.Matrix_Cursor)
    (M.L.Matrix_PrintBitmapPixel10)
    (M.L.Matrix_PrintBitmapPixel7)
    (M.L.Matrix_PrintBitmapPixel6)
    (M.L.Matrix_PrintBitmapPixel5)
    (L.L.Matrix_Modul) 0 =
    {if}
        (M.L.Matrix_PrintBitmapPixel12)
        (M.L.Matrix_PrintBitmapPixel11)
        (M.L.Matrix_PrintBitmapPixel8)
        (M.L.Matrix_PrintBitmapPixel5)
    {endif}
    (L.L.Matrix_Modul) 2 =
    (L.L.Matrix_Modul) 3 = ||
    {if}
        (M.L.Matrix_PrintBitmapPixel12)
        (M.L.Matrix_PrintBitmapPixel11)
        (M.L.Matrix_PrintBitmapPixel10)
        (M.L.Matrix_PrintBitmapPixel9)
        (M.L.Matrix_PrintBitmapPixel7)
        (M.L.Matrix_PrintBitmapPixel5)
        (M.L.Matrix_PrintBitmapPixel4)
    {endif}
    0 (S.L.Matrix_Cursor)
{end}

Ich hätte die Lösung jetzt auch in zwei Sätzen ohne weitere Erläuterung schreiben können, aber ich wollte, dass man versteht, wie sich das ganze zusammensetzt. Evtl. findet es ja sogar jemand interessant, wer weiß.

Ah, also das mit der Helligkeit ist darauf zurückzuführen, dass die Mipmaps der .dds-Dateien beim Vergrößern auf 240x32 wieder gelöscht oder zmd. wieder mit den automatisch erzeugten Mipmaps überschrieben wurden. Wenn du dir die Originaltexturen aus dem Solaris mal in GIMP (!) ansiehst, wirst du auf den unteren, kleineren Mipmaps sehen, dass irgendwann alles komplett weiß wird, was bei der modifizierten Textur nicht mehr so sein wird. Normalerweise wird bei den automatischen Mipmaps die Textur nämlich deutlich grauer und sieht somit deutlich weniger hell aus, da die Originaltextur in voller Größe einige dunklere Zwischenräume hat, die zusammen mit den eigentlichen Pixeln beim Verkleinern zu einem Grau heruntergemischt werden.
In der Ferne werden dann die kleineren, dunklen Mipmaps angezeigt (Nah: Größte Mipmap, Fern: Kleinste Mipmap -> dazwischen werden jeweils die Abstufungen mit Übergang zur nächst größeren oder kleineren Mipmap angezeigt). Damit es nun aber nicht nur von Nahem, sondern auch in der Ferne noch schön hell und weiß aussieht, muss man die Mipmaps jeweils manuell aufhellen bzw. ab einem bestimmten Grad einfach komplett weiß färben in GIMP.

Ich hänge dir hier mal die beiden .dds-Dateien an, also Lightmap und normale Textur, wo das ganze bereits für die 240x32-Matrix geschehen ist.


Zum Thema Skript: Dort reicht es aus im Makro Matrix_SetCoords bei (L.L.Matrix_Modul) 0 = die Matrix_Width auf 240 zu setzen und am Ende des Skripts die in meinem letzten Post genannten Änderungen fürs Übertragen der ersten Skripttextur auf die zweite Skripttextur anzuwenden.

Dazu kommen dann nur noch die Änderungen im Modell der vorderen Anzeige, das proportional breiter gemacht werden müsste, also mit dem Faktor 240 / 200 = 1,2 skaliert werden muss. Das Mapping der Textfläche muss dann nur noch um 40 "Pixel" bzw. eigentlich 320 Pixel weiter nach rechts erweitert werden. Der Hintergrund der Anzeige besteht aus einer geloopten Textur, die ebenfalls um 320 Pixel nach rechts erweitert werden muss.
Das sollte es dann schon gewesen sein.

Schön, dass es funktioniert! Mir fällt nur gerade auf, dass ich bei meiner Erklärung etwas verwirrt habe. Gut, dass du aber selber so schlau warst und es trotzdem hinbekommen hast.
Ich habe immer von Matrix_PrintBitmapPixelXX gesprochen, aber da ich bei der Matrix aus dem Solaris die Makros wohl alle umbenannt habe in die jeweilige Anzahl der übertragenen Pixel und nicht mehr den Exponent für die Benennung genutzt habe, würde das gar nicht wie in dem Code meines Beitrages beschrieben funktionieren. Hab da ausversehen mit einem anderen Skript erklärt, wo ich das nicht getan hatte. Aber da hat ja dann evtl. die lange Erklärung doch beim Verständnis geholfen.
Ich hoffe, du hast jetzt nicht allzu lange rumgerätselt, sorry.