Scrollen in alle Richtungen

Nachdem ich bei einem Freund eine Maschinen-Routine sah, die es aus GFA-Basic heraus ermöglicht [mit dem Befehl CALL adr()], schnell pixelweise horizontal auf dem Bildschirm ‘um die Uhr’ zu scrollen, wurde ich neugierig: so etwas suchte ich, und eigene Versuche brachten bisher nicht das gewünschte Ergebnis. Allerdings ist diese Routine ziemlich ‘tricky’ programmiert, und es ist auch nur möglich, nach links zu scrollen.

Das Trickreiche an der Routine ist, daß, um Übergabeparameter zu sparen, die den Aufruf ja auch verlangsamen, in einer Initialisierungsroutine die Adresse der Scroll-Routine geladen wurde, und mittels Offset die für das Scrollen nötigen Parameter an die Stelle in der Scroll-Routine ‘geschoben’ wurden, an der sie benötigt werden. Werden nun in der Scroll-Routine Zeilen geändert, hinzugefügt oder gelöscht, kann sich der Offset ändern, was schöne Abstürze mit sich bringt. Genau die Probleme hatte ich bei dem Versuch, die Assembler-Routine in C einzubinden, da LASER an den Anfang jeder Funktion den LINK-Befehl des 68000 und eventuell den MOVEM-Befehl zum Registerretten setzt. Daher überlegte ich mir eine elegantere und auch nicht langsamere Methode. Die zum Scrollen nötigen Variablen werden in einer Struktur zusammengefaßt, und ein Zeiger darauf wird den Scroll-Routinen übergeben. Dadurch entfällt eine weitere Einschränkung; werden nämlich direkt in der Routine Werte geändert, braucht man für jeden zu scrollenden Block eine eigene Routine, bzw. es müßte jedes Mal die Initialisierungsroutine aufgerufen werden, wenn ein anderer Block gescrollt werden soll, was nicht besonders zur Geschwindigkeits-Steigerung beiträgt.

Die Struktur namens SCROLLER besteht aus folgenden Komponenten: words enthält die Wörter (16 Bit) pro Zeile, zeilen die Zeilenzahl, beide um 1 erniedrigt (spart im Assembler je eine Zeile), offset enthält die Breite in Bytes, wird zur Korrektur des an der abzuarbeitenden Zeile langlaufenden Zeigers benötigt, adr ist die Adresse auf dem Monitor, pixel die Breite in Pixeln, wird nur für Links-rechts-Scrollen benötigt.

Den Scroll-Routinen wird neben dem Zeiger auf die Struktur ein Wert (long warten) für die Pause übergeben, die nach jeder Zeile beim vertikalen bzw. nach jedem Pixel beim horizontalen Scrollen gemacht werden soll, die Zahl der Zeilen bzw. Pixel (int pixel), die pro Aufruf der Routine gescrollt werden sollen, und ein Flag für die Richtung (int richtung, 1 = links/oben, 0 = rechts/unten). warten verlangsamt das Scrollen absolut, auch für die anderen scrollenden Bereiche, während pixel das Scrollen des einen relativ zu den anderen ändert. So kann z.B ein Block bei jedem Durchlauf 4 Pixel scrollen, während die anderen nur 1 Pixel pro Durchlauf scrollen dürfen.

Die Routinen etwas näher betrachtet: scroll_lr(): Als erstes wird dem Compiler das Übertragen der Strukturkomponenten in die Register abgenommen! LASER hat nämlich die unangenehme Eigenschaft, vor jedem Zugriff auf eine Komponente die Adresse der Struktur in A0 zu laden und dann relativ zu adressieren, statt die Adresse nur einmal zu laden. Da die Scroll-Routinen nun etwas öfters aufgerufen werden, machen sich 3 zusätzliche MOVEA-Zeilen bemerkbar. Aber dafür gibt es ja den praktischen Inline-Assembler. Die erste Schleife zählt die Zahl der Zeilen pro Durchgang herunter (die relative Geschwindigkeit), als nächstes kommt die Pause. Adresse und Zeilenzahl werden in die Register geladen, auf die Richtung geprüft und zum entsprechenden Teil verzweigt. Das ganz linke bzw. rechte Wort wird mit dem roxr/roxl-Befehl gerollt und der Zeiger auf den Anfang bzw. das Ende der Zeile gesetzt, danach wird der Rest der Zeile wortweise gerollt.

scroll_ou(): Es werden 3 Zeiger verwendet, in Al liegt die Adresse der ersten Zeile (beim Hoch-Scrollen) bzw. der letzten Zeile, last_line zeigt auf die letzte bzw. erste Zeile. Dadurch lassen sich die erste und die letzte Zeile nach jedem Durchlauf (wenn also alle Zeilen 1 Zeile verschoben wurden) einfach tauschen, lauf ist ein Zeiger auf die jeweils aktuelle Zeile, die verschoben wird. Da A1 und last_line nach jedem Durchgang um Bytes verschoben sind, werden sie in den Variablen anfang und ende gebuffert, um Rechenzeit zu sparen. Vor jedem Durchgang (label z1) werden die Adressen neu geladen, es folgen wie beim horizontalen Scrollen die Zeilenschleife und die absolute Pause. Die wortweise Verschiebeschleife für die Zeilen (wo bzw. wu) kann durch Verwendung eines festen Offsets sehr kurz ausfallen (läuft daher auch nur mit 640 Pixeln Breite). Nun wird der laufende Zeiger korrigiert und auf die nächste Zeile gesetzt. Nach Verschieben aller Zeilen wird noch die erste Zeile gegen die letzte getauscht (labels ll bzw. fl), das war es dann auch schon.

Die Funktion scrollinit() errechnet die für das Scrollen nötigen Parameter, wobei für die Richtungen links und oben der Zeiger auf den Anfang des Blocks, für rechts und unten auf das Ende gesetzt wird. Zu beachten ist, daß das Flag, das die Richtung bestimmt, den gleichen Wert haben muß wie beim Aufruf der Scroll-Routinen, da sonst falsche Bereiche gescrollt werden. Es findet auch keine Überprüfung auf negative Werte statt, die entstehen, wenn man (x2/y2) kleiner als (x1/y1) übergibt, also Vorsicht!

Im Source sind an einigen Stellen Pfeile (==>), die deutlich machen, wo die Routinen an die Bildschirmbreite angepaßt werden sollten, damit wenigstens monochrom auf größeren Bildschirmen gescrollt werden kann.

Die Routinen sind so geschrieben, daß sie ohne globale Zugriffe auskommen, es müssen nur die beiden Strukturen vereinbart werden, was ja in einer Header-Datei geschehen kann. Extra compiliert braucht man das File dann nur noch hinzuzulinken. Natürlich sind die Routinen weniger geeignet, wenn es darum geht, den ganzen Bildschirm zu verschieben. Die wortweise Schleife ist dann einfach zu langsam. Für kleinere Bereiche (und dann auch gerne mehrere) lassen sich aber doch recht flüssige Bewegungen erzielen.

Besondere Effekte erzielt man beim Übereinanderlegen von scrollenden Blöcken. Rechts + Oben = Diagonal, das ist ja wohl klar; überkreuzen sich z.B. 2 Blöcke, die in die gleiche Richtung scrollen. wird der überlappende Bereich auseinandergezogen, scrollen sie entgegengesetzt, scheint der Schnittpunkt stillzustehen. Weisen die beiden auch noch unterschiedliche relative Geschwindigkeiten auf, läuft der Schnittpunkt plötzlich spiegelverkehrt! Ein nettes Feld zum Experimentieren ergibt sich auch, wenn 2 senkrechte und 2 waagerechte ‘Stäbe’ so eingestellt sind, daß die Pixel im Kreis (bzw. im Rechteck) laufen.

Eine ‘ernsthaftere’ Anwendung ist z.B. eine Laufschrift, wie im Beispiel-Source. Vielleicht kommt ja mal jemand auf die Idee, wichtige Alert-Boxen mit scrollenden Stopschildem auszustatten? Die werden dann bestimmt nicht mehr übersehen!

Bei dem Demoprogramm sind einige Tasten des Zehnerblocks belegt: ‘+’ und ‘-’ erhöhen bzw. erniedrigen die relative Geschwindigkeit der horizontalen Schrift, ’*’ und ’/’ die der vertikal scrollenden Schrift. ‘(‘ und ')’ erhöhen/erniedrigen die absolute Geschwindigkeit (Pause), Enter setzt die Parameter zurück. Mit ‘ESC’ wird das Programm verlassen.