Größere Zeilenabstände durch FLD

Hinter FLD verbirgt sich erstmal nichts anderes, als die Möglichkeit, einen beliebigen Zeilenabstand für die Bildschirmausgabe zu verwenden. Was das genau bedeutet, wie man diesen realisiert und was man damit machen kann, erfahrt ihr in den nächsten Minuten.

Wir benötigen hier zwar keinen, aber ihr solltet trotzdem die Texte zum Rasterzeilen-IRQ und vorallem zu den Bad Lines gelesen haben!

FLD – Was ist das?

FLD steht für Flexible Line Distance, das bedeutet soviel wie flexibler Zeilenabstand. Wie ihr wisst, bietet der C64 euch nach dem Einschalten den Textmodus mit 25 Zeilen zu je 40 Zeichen an. Der Abstand zwischen den einzelnen Zeilen beträgt normalerweise 0 (Null) Pixel, mittels FLD kann man nun für beliebig große Abstände zwischen den einzelnen Zeilen sorgen.

FLD – Funktionsweise

Wenn ihr bei den Bad Lines aufgepasst habt, dann wisst ihr, dass diese entstehen, weil der VIC-II extra Zeit benötigt, um die nächste Zeichenzeile vorzubereiten. Im Umkehrschluß bedeutet dies aber auch, dass erst nach einer Bad Line die nächste Zeichenzeile vom VIC-II dargestellt wird. Im Gegensatz zu einer FLI – Grafik, wo wir für zusätzliche Bad Lines sorgen mussten, müssen wir für den FLD-Effekt das Auftreten von Bad Lines verschieben.

Wichtig ist dabei: Das klappt nur für eine ganze Zeichenzeile!
Sobald der VIC mit der Zeichenzeile beginnt, werden auch alle acht Pixelzeilen ausgegeben! Ihr könnt per FLD also z. B. eine Textzeile nicht nach vier Zeilen splitten!

Da wir nur den Start einer Zeichenzeile verschieben können, bleibt die Reihenfolge der Zeilen immer gleich, ihr könnt also hiermit nicht Zeile drei vor Zeile eins anzeigen. Es ist auch nur möglich, die Zeilen (von ihrer „normalen“ Position aus) weiter nach unten zu verschieben.

FLD – Das Beispielprogramm

Wir fangen unser FLD-Beispiel ganz einfach an:

Mit FIXEDLINES legen wir fest, wieviele Zeichenzeilen komplett angezeigt werden sollen, bevor der FLD-Effekt einsetzt. Die STARTLINE bestimmt, in welcher Rasterzeile wir mit dem Unterdrücken der Bad Lines beginnen wollen und SKIPLINES legt fest, wieviele Rasterzeilen übersprungen werden sollen, bevor wir wieder Bad Lines zulassen.
Dann folgt der bekannte BASIC-Start und hinter main sperren wir erstmal die Interrupts, die uns sonst das Timing verhageln würden.

Jetzt folgt eine äußere Schleife, die dafür sorgt, dass jeder Bildaufbau wieder mit den selben Voraussetzungen beginnt.

Hinter @loop1 springen wir erstmal nach waitForNewFrame. Die Funktion (wie sie genau aussieht, sehen wir weiter unten) wartet darauf, dass der Rasterstrahl wieder an der ersten Position ankommt, um das nächste Bild zu zeichnen.
Anschließend schreiben wir nach $d011 die Standardwerte (25 Zeilen, Textmodus, Bildschirmausgabe ein, Y-Scrollposition = 3), wie sie auch nach dem Einschalten vorliegen. Dies ist notwendig, da wir $d011 in der nächsten Schleife ändern werden.
Jetzt warten wir auf unsere STARTLINE. Dazu holen wir uns diese in den Akku und vergleichen diesen Wert mit dem Inhalt des Rasterzeilenregisters $d012 (ihr erinnert euch: hier steht immer die aktuelle Rasterzeile, die der VIC-II gerade am Wickel hat). Sobald die gewünschte Zeile erreicht ist, holen wir uns SKIPLINES ins X-Register, das als Schleifenzähler dient.

Jetzt folgt eine zweite Schleife, die dafür sorgt, dass keine Bad Lines mehr auftreten. Eine Bad Line wird bekanntlich nur im sichtbaren Bereich (im Rahmen gibt es ja keine) ausgelöst, wenn die unteren drei Bits der aktuellen Rasterzeile mit der Y-Scroll-Position aus $d011 übereinstimmt. Unsere nächste Schleife wird nun dafür sorgen, dass (zumindest solange wir wollen) die Y-Scroll-Position nie mit den unteren drei Bits der aktuellen Rasterzeile übereinstimmt.

Hinter @loop2 warten wir auf den Beginn der nächsten Rasterzeile. Sobald eine neue Zeile beginnt, löschen wir das Carry-Flag, holen uns $d011 in den Akku und addieren 1 hinzu, um die Y-Scroll-Position zu erhöhen. Da wir nur die unteren drei Bits benötigen, blenden wir per and den Rest aus und setzen mittels ora noch die Bits für Bildschirmausgabe (ein) und 25 Zeilen. Zum Schluß schreiben wir den neuen Wert nach $d011 zurück.
Dann verringern wir unseren Schleifenzähler im X-Register und wiederholen die eben beschriebene Prozedur, für alle zu überspringenden Zeilen.
Sobald für alle gewünschten Zeilen die Bad Lines verhindert wurden, springen wir zurück an den Anfang zu @loop1, um wieder auf das Zeichnen des nächsten Bildes zu warten.

Jetzt fehlt nur noch die Funktion…

Wie ihr wisst, gibt es mehr als 256 Rasterzeilen, daher dient das höchste Bit in $d011 sozusagen als 9. Bit für die Rasterzeilenposition, die wir in $d012 finden. Unsere kleine Routine wartet also erstmal darauf, dass in $d011 das höchste Bit gesetzt wird. Sobald dies der Fall ist, befindet sich der Rasterstrahl an einer Position über 255. Danach warten wir darauf, dass das höchste Bit wieder gelöscht wird. Dies passiert, sobald der Rasterstrahl vom Ende der letzten, zurück an den Anfang der ersten Rasterzeile gestellt wird. Dadurch wissen wir, wann der VIC-II mit dem Aufbau des nächsten Bildes beginnt.

Ein exaktes Timing ist hier nicht nötigt, daher können wir auf Interrupts verzichten.

FLD – Erster Start

Sobald ihr das Programm nun startet, werdet ihr euch vor Begeisterung wohl kaum noch zurückhalten können:

Super eine (evtl.) schwarze Lücke, na toll. 😉

Sollte bei euch die Lücke nicht schwarz sein, dann liegt das mal wieder an der Speicherstelle $3fff. Wie bereits an anderer Stelle erwähnt, wenn der VIC-II nicht mehr weiß, woher er die Daten für die Anzeige nehmen soll, dann greift er auf das letzte Byte der für ihn sichtbaren 16KB zurück. Da wir den VIC-II-Speicherbereich nicht verschoben haben, ist dies hier die erwähnte Adresse $3fff. Schreibt daher am besten erstmal direkt hinter main den Wert #$ff nach $3fff.

Auch wenn das Ergebnis auf den ersten Blick relativ enttäuschend aussieht, es ist mehr geschehen, als ihr jetzt vielleicht annehmt.

Wir haben eben immerhin den Bildschirm um 16 Pixelzeilen nach unten gescrollt, ohne dass wir Daten umkopieren mussten!

Ändert doch mal die Werte für  FIXEDLINES und SKIPLINES (mit 0 klappt es noch nicht, darum kümmern wir uns aber gleich), um euch die Auswirkung der beiden Werte genauer anzusehen. Dabei werdet ihr feststellen, dass wir den kompletten Bildschirm um eine beliebige Anzahl an Pixelzeilen nach unten verschieben können.

So, wie ihr eben manuell einige Werte geändert habt, können wir das natürlich auch per Programm machen…

FLD in Bewegung

In der bisherigen Form ist der Effekt dann doch etwas langweilig. Lasst uns daher mal etwas Bewegung in die Sache bringen. Wir werden den Bildschirm jetzt von unten nach oben ins Bild „laufen“ lassen. Nehmt dazu bitte die gelb hervorgehobenen Änderungen vor.

Die Änderungen im Überblick:

• 5: Für unseren Test nehmen wir eine Lücke von 45 Pixelzeilen.
• 20: Neues Label @loop, da wir eine weitere Schleife benötigen.
• 21 & 22: Da wir die Anzahl der zu überspringenden Zeilen verändern wollen, speichern wir den Startwert aus der Konstanten SKIPLINES beim Label linesToSkip ab.
• 34: Jetzt holen wir uns die Anzahl der zu überspringenden Zeilen vom Label linesToSkip, statt aus der Konstanten, ins X-Register.
• 35: Falls keine Zeilen übersprungen werden müssen (Wert = 0), beginnen wir wieder von vorne.
• 52: Die Anzahl der zu überspringenden Zeilen beim Label linesToSkip verringern.
• 65 & 66: Hier merken wir uns jetzt die zu überspringenden Zeilen.

Wenn ihr diese Version nun startet, sollte euer Ergebnis ungefähr so aussehen…

Auch hier könnt ihr wieder mit den Werten FIXEDLINES und SKIPLINES (nun geht auch die Null) experimentieren. Setzt z. B. FIXEDLINES = 0 und SKIPLINES = 200, um den Effekt auf den gesamten Bildschirm auszudehnen.

Wenn ihr jetzt auf den unteren Rand achtet, seht ihr ein kleines Problem. Auch dort kommt es, durch das Scrolling, zu schwarzen Zeilen. Diese könnt ihr bei Bedarf durch verschiedene Maßnahmen kaschieren. Ihr könnt z. B. die Hintergrundfarbe auf schwarz setzen oder in $3fff eine Null ablegen. Durch die Aktivierung des 24 Zeilenmodus verschwinden diese Zeilen ebenfalls. Auch ein Überdecken mit Sprites wäre denkbar. Probiert die verschiedenen Möglichkeiten bei Bedarf einfach mal aus.

Schlußbemerkung

Den Effekt könnt ihr jetzt noch weiter verfeinern. Ihr könnt das Bild natürlich auch wieder nach unten „fahren“. Es sind auch mehrere getrennte „Lücken“ möglich, ihr könnt so einzelne Zeilen über den Bildschirm „fliegen“ lassen und das Bild Zeile für Zeile auf- bzw. abbauen.

Und ganz wichtig: Das alles funktioniert auch im Bitmap-Modus!

Kombiniert FLD mit anderen Effekten.

Die beiden letzten Beispiele findet ihr auf dem folgenden D64-Image. Da die obigen GIFs nur eine Annäherung sind, empfehle ich euch den Download.

---

(8 Bewertungen | Ø 4,88 von 5 | 97,50%)

Loading...

---