QUICK Ecke 31

von Harald Schönfeld


Schnelle Textausgabe in Grafik 8


Bei dieser Routine stütze ich mich in
weiten Teilen auf das Programm vom
letzten Mal: Die Ausgabe des Strings
bleibt gleich und auch das Einschalten
der Grafik geht so vor sich wie bei
QE30.QIK.


Die Ausgabe jedes einzelnen Zeichens
soll nun aber wesentlich schneller
werden. Dazu muß auf den PLOT-Befehl
verzichtet werden. Stattdessen will ich
die Daten direkt in den Bildschirm
schreiben.


Die Ausgabe eines Zeichens

Grundsätzlich sollen einfach die 8
Bytes aus dem Zeichensatz in den
Bildschirm kopiert werden. Soll das
Zeichen an der Position 0,0 ausgegeben
werden, dann geht das so vor sich:

Man holt sich die Bildschirmadresse aus
SAVMSC (88,89). Dorthin kopiert man das
erste Byte des Zeichens. Das nächste
Byte soll in die nächste Zeile. Da jede
Bildschirmzeile aus 40 Bytes besteht,
muß das nächste Zeichen also 40 Byte
weiter hinten in den Bildschirmspeicher
kopiert werden. Wenn man das für alle 8
Bytes macht ist man schon fertig. Und
das mit einer sehr hohen
Geschwindigkeit.

Soll das Zeichen in der Y. Zeile
gesetzt werden, so addiert man einfach
40*Y zur Anfangsadresse des
Bildspeichers hinzu. Auch das ist noch
trivial.


Kompliziert wird es, wenn das Zeichen
nicht an der 0. X Position sitzen soll
- was ja doch manchmal vorkommen dürfte
nehme ich an :-)


Bitgeshifte

Grundsätzlich muß man die X Position
durch 8 teilen, um die Adresse des
Zeichens im Bildschirmspeicher zu
erhalten, denn pro Byte hat man 8
Positionen an denen das Zeichen
beginnen kann. Also muß man X/8 zur
Adresse des Bildschirmanfangs zählen um
am korrekten Byte zu beginnen. Damit
allein ist es aber nicht getan.

Nun muß man die Bits noch entsprechend
verschieben. Liegt das Zeichen z.B. an
der X Position 1, so muß man die Bits
des Bytes im Zeichensatz einmal nach
rechts schieben bevor man sie in das
Byte des Bildschirms kopiert. Dabei
geht aber das rechteste Bit verloren.

Das was man rechts verliert muß also in
das nächste Byte des
Bildschirmspeichers kommen. Dazu nimmt
man also das Originalbyte aus dem
Zeichensatz, schiebt es 8-X mal nach
links und hat dann den Rest im Byte
stehen, den man bei Rechtsschieben des
anderen Bytes verloren hat.

Insgesamt darf man jeweils höchstens 7
mal Schieben. Denn alles weitere wird
ja dadurch abgedeckt, daß man wirklich
ins nächste Byte des Bildschirms
springt.

Man hat also nun 2 Bytes, in denen die
Bit-information des Zeichens korrekt
verschoben drinsteht. Diese müssen nun
in den Bildschirm kopiert werden. Dabei
ist es aber ratsam, diese nicht einfach
reinzukopieren, sondern die Daten zu
'odern'.


Nun, das alles ist ein bißchen
kompliziert, aber wenn man sich den
Quelltext ansieht, sollte es doch klar
werden was wann wie warum geschoben
wird.


Auf jeden Fall ist es schön schnell.




ß

Quick-Sourcetext
D1:QE31.QIK     


* QUICK Ecke 31
* by Harald Schoenfeld
*
* Text iN Grafikstufe 8



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

WORD
(+
X
)+

ARRAY
(+
STR(40)
)+

MAIN

-1 

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

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

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

* 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
(+
B,I,J,CX,B1
)+
WORD
(+
SAVMSC=88,BSADR,Z,P
)+
BEGIN

* Anfangsadresse des Zeichens im
* Bildspeicher berechnen bei 40 Bytes
* pro Zeile
  MULT(Y,40,BSADR)
  ADD(BSADR,SAVMSC,BSADR)
  DIV(X,8,CX)
  ADD(BSADR,CX,BSADR)

* Verschiebung des Zeichens im Byte
  AND(X,7,CX)

* Zeichen byteweise bearbeiten
  I=0
  REPEAT

* Ites Byte des Zeichens
    PEEK(ZADR,B)

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

    B1=B

* CX mal B nach rechts schieben
    J=0
    WHILE J<CX
      LSRB(B)
      J+
    WEND

* Byte in Zeichenword kopieren
    Z=B

* Falls geschoben werden musste
* nun das Byte aufbauen, das den
* nach rechts hinausgeschobenen Teil
* enthaelt

    IF CX<>0
      J=CX
      REPEAT
        ASLB(B1)
        J+
      UNTIL J=8

* dieses "rechte" Byte ins Highbyte
* von Z kopieren

      /Z=B1
    ENDIF

* Alten Bildschirmwert holen
    DPEEK(BSADR,P)
* Zeichensazuodern
    OR(P,Z,P)
* In Bildschirm schreiben
    DPOKE(BSADR,P)

* naechstes Byte des Zeichens
    ADD(ZADR,1,ZADR)

* naechste Zeile
    ADD(BSADR,40,BSADR)

    I+
  UNTIL I=8

ENDPROC