QUICK Ecke 30

von Harald Schönfeld



Textausgabe in allen Grafikstufen

Heute möchte ich zeigen, wie einfach es
in QUICk möglich ist eine relativ
schnelle Textausgabe für alle
Grafikstufen zu schreiben.


Der Zeichensatz im ATARI

Die Zeichen die auf dem Bildschirm
dargestellt werden, werden
normalerweise im Textmodus dargestellt,
was sehr schnell und einfach möglich
ist. Dazu steht im Bildschirm einfach
die Nummer des darzustellenden
Zeichens. Der Grafikchip berechnet aus
dieser Nummer dann die Adresse im
Zeichensatz, an der das Aussehen des
Zeichens festgelegt wird.

Die Zeichensatzdaten sind dabei einfach
so aufgebaut:

1.Byte Zeichen 1
2.Byte Zeichen 1
3.Byte Zeichen 1
4.Byte Zeichen 1
5.Byte Zeichen 1
6.Byte Zeichen 1
7.Byte Zeichen 1
8.Byte Zeichen 1
1.Byte Zeichen 2
2.Byte Zeichen 2
3.Byte Zeichen 2
4.Byte Zeichen 2
.
.
.

Jedes Byte legt somit fest welche der 8
Pixel pro Zeile eines Zeichens gesetzt
sind. Jedes Zeichen besteht aus 8 Bytes
(Zeilen). Dann folgen die Bytes für das
nächste Zeichen usw.

Will man also ein Zeichen in einer
pixel- Grafikstufe auf dem Bildschirm
ausgeben, muß man die
Zeicheninformation aus diesen Bytes auf
den Bilschirm setzen. Man muß sich also
die einzelen Bits der Bytes ansehen und
wenn diese gesetzt sind jeweils ein
Pixel auf den Bildschirm setzen.

Wo die Zeichensatzdaten beginnen kann
man aus der Speicherzelle 756 ersehen.
Den Wert muß man einfach mit 256
multiplizieren, und schon hat man die
Adresse das 1. Bytes des ersten
Zeichens in den Zeichensatzdaten.


Darstellung eines Zeichens

Um die Adresse der Zeichendaten des
ASCII-Zeichens A zu erhalten, muß man
zur Anfangsadresse ZS der
Zeichensatzdaten einfach A*8 addieren -
sollte man meinen. Leider sind die
Zeichen im Datenbereich aber nicht nach
dem ASCII-Code sortiert, sondern im
Internen-ATARI-Code. Aus diesem Grund
muß man die Zeichennummern zunächst
umrechnen:

IF A<96
  IF A>31
    A=A-32
  ELSE
    A=A+64
  ENDIF
ENDIF

So, nun hat man die interne Nummer,
deren 8facher Wert dann die Adresse in
den Zeichensatzdaten angibt.

Nun muß man also Byte für Byte des
Zeichens lesen und auf dem Bildschirm
darstellen.

Dazu geht man in einer Schleife die 8
Bits jedes Bytes durch und prüft ob
diese Bits gesetzt sind. Dazu dient der
AND-Befehl, der nur dann einen Wert <>0
enthält, wenn das gesuchte Bit gesetzt
ist:

AND(BYTE,128,TEST)

Hier wird gefragt, ob das linkeste Bit
des Bytes BYTE gesetzt ist. Wenn ja,
dann ist TEST <>0. Ist dem So, dann
setzt man mit PLOT ein Pixel auf den
Bildschirm. Nun wird in der Schleife
das BYTE einmal nach links geschoben,
so daß man nun mit dem gleichen Befehl
das nächste Bit im Originalbyte
untersuchen kann. Ist auch das gesetzt,
macht man ein Pixel an die nächste
X-Position, usw.

Wurden die 8 pixel untersucht, kommt
das nächste Byte und somit die nächste
Zeile des Zeichens dran. Man muß nun
also auf dem Schirm in die nächste
Zeile gehen.

Nach 8 Zeilen ist man mit dem Zeichen
fertig.

Es gibt noch einen Sonderfall zu
beachten. Ist der Zeichenwert größer
als 127, so handelt es sich um ein
inverses Zeichen. In diesem Fall, muß
man jedes Byte des Zeichens
invertieren, bevor man es ausgibt. Dazu
dient der Befehl
EOR(BYTE,255,BYTE)

Dabei werden alle Bits des Zeichens
invertiert.


Ausgabe eines Strings

Die Ausgabe eines Strings gestaltet
sich also einfach so, daß man in einer
Schleife immer wieder die Ausgabe eines
Zeichens aufruft, wobei man die X
Position natürlich jedes Mal um 8
erhöhen muß.
Das Ende des Strings markiert wie immer
die Null.



Es stellt sich heraus, daß die
Geschwindingkeit der Zeichenausgabe in
QUICK schon recht hoch ist. Allerdings
ist sie natürlich wesentlich langsamer
als im Textmodus.

Das nächste Mal werde ich zeigen, wie
man zumindest in Grafik 8 noch viel
schneller sein kann.



ß

Quick-Sourcetext
D1:QE30.QIK     


* QUICK Ecke 30
* by Harald Schoenfeld
*
* Text in allen Grafikstufen



BYTE
(+
Y,GR,CH=764
)+

WORD
(+
X
)+

ARRAY
(+
STR(40)
)+

MAIN

-1 

* Grafikstufe 3 bis 15 waehlen
  ?("Grafikstufe waehlen")
  INPUT(GR)
  AND(GR,15,GR)

* Text eingeben
  ?("Text:")
  INPUT(STR)

* Position festlegen
  ?("X Positon")
  INPUT(X)
  ?("Y Position")
  INPUT(Y)

* Grafik einschalten
  CLOSE(6)
  OPEN(6,12,GR,"S:")

* Textfarbe sichtbar in jeder
* Grafikstufe
  COLOR(7)

* Text ausgeben
  .TEXT(X,Y,STR)

* Auf Tastendruck warten und ihn
* gleich wieder loeschen
  REPEAT
  UNTIL CH<>255
  CH=255

* Alles von vorne
  JUMP(1)

ENDMAIN


PROC TEXT
IN
WORD
(+
X
)+
BYTE
(+
Y
)+
ARRAY
(+
TXT(40)
)+
LOCAL
BYTE
(+
CHBAS=756,I,Z,INV
)+
WORD
(+
CHADR,ZADR
)+
BEGIN

* Adresse des Begins der Zeichensatz-
* daten berechnen
  MULT(CHBAS,256,CHADR)

  I=0
  Z=TXT(I)

* Den String zeichenweise bearbeiten
  WHILE Z<>0

* Falls inverses Zeichen Flag setzen
    IF Z>127
      INV=1
      SUB(Z,128,Z)
    ELSE
      INV=0
    ENDIF

* ASCII nach Internen Zeichencode
* umrechnen
    IF Z<96
      IF Z>31
        SUB(Z,32,Z)
      ELSE
        ADD(Z,64,Z)
      ENDIF
    ENDIF

* Adresse der Daten des Zeichens
* berechnen
    MULT(Z,8,ZADR)
    ADD(CHADR,ZADR,ZADR)

* Zeichen asugeben
    .CHAR(X,Y,ZADR,INV)

* naechstes Zeichen
    I+
    Z=TXT(I)

* naechste Bildschirmposition
    ADD(X,8,X)

  WEND

ENDPROC


PROC CHAR
IN
WORD
(+
X
)+
BYTE
(+
Y
)+
WORD
(+
ZADR
)+
BYTE
(+
INV
)+
LOCAL
BYTE
(+
CY,B,PIXEL,I,J
)+
WORD
(+
CX
)+
BEGIN

* Zeichenanfangsposition
  CX=X
  CY=Y

* Zeichen byteweise bearbeiten
  I=0
  REPEAT

* Byte fuer Ite Zeile aus Zeichensatz
* lesen
    PEEK(ZADR,B)

* Falls Invers dann Byte invertieren
    IF INV=1
      EOR(B,255,B)
    ENDIF

* 8 Bits abarbeiten
    J=0
    REPEAT

* linkestes Bit holen
      AND(B,128,PIXEL)
* wenn gesetzt dann auf Bildschirm 
* Pixel setzen
      IF PIXEL<>0
        PLOT(CX,CY)
      ENDIF

* Zaehler erhoehen
      J+
* Bit nach links schieben
      ASLB(B)
* naechste Bildschirmpos.
      ADD(CX,1,CX)
    UNTIL J=8

* naechstes Byte des Zeichens
    ADD(ZADR,1,ZADR)
* Anfangs-X-Position
    CX=X
* naechste Zeile
    CY+

    I+
  UNTIL I=8

ENDPROC