Turbo Toolbox/Turbo_Toolbox.iso/1989/12/praxis/asmgraph.asm

Assembly Source File | 1989-09-14 | 11.6 KB | 341 lines

;* ------------------------------------------------------- *
;*                   ASMGRAPH.ASM                          *
;*                                                         *
;*  Stellt Assemblerprozeduren bereit, um mit Topspeed     *
;*  Modula-2 den 16-Farbenmodus des Schneider PC 1512      *
;*  zu bedienen.                                           *
;*  Assemblieren mit:  MASM ASMGRAPH /ml;                  *
;*                                                         *
;*    (c) 1989  Cornelis van der Laan  &  TOOLBOX          *
;* ------------------------------------------------------- *
            PAGE   68, 132

            NAME ASMGraph

G_ASMGraph  GROUP  C_ASMGraph

PUBLIC      ASMGraph$ASMHires, ASMGraph$ASMText
PUBLIC      ASMGraph$ASMPlot,  ASMGraph$ASMPoint,
PUBLIC      ASMGraph$ASMLine

;* ------------------------------------------------------- *
;*  PROCEDURE ASMHires;
;*  PROCEDURE ASMText;
;*  PROCEDURE ASMPlot  (x, y : CARDINAL; color : CARDINAL);
;*  PROCEDURE ASMPoint (x, y : CARDINAL) : CARDINAL;
;*  PROCEDURE ASMLine  (x1, y1, x2, y2 : CARDINAL;
;*                      color          : CARDINAL);
;* ------------------------------------------------------- *

C_ASMGraph  SEGMENT BYTE PUBLIC 'FCODE'
            ASSUME CS : C_ASMGraph

;*  PROCEDURE ASMHires;

ASMGraph$ASMHires PROC FAR

            MOV  AX, 0006H      ; 640 x 200 hires-mode
            INT  10H
            MOV  AL, 0FH
            MOV  DX, 03D9H      ; 16-Farben Modus wählen
            OUT  DX, AL         ; Out (3D9H, 0FH)
            RETF

ASMGraph$ASMHires ENDP


;* PROCEDURE ASMText;

ASMGraph$ASMText  PROC FAR

            MOV  AX, 0003H      ; Textmode Co80
            INT  10H
            RETF

ASMGraph$ASMText  ENDP


; PROCEDURE ASMPlot (x, y : CARDINAL; color : CARDINAL);

PlotX       EQU WORD PTR [BP + 10] ; Parameter
PlotY       EQU WORD PTR [BP +  8]
PlotColor   EQU BYTE PTR [BP +  6]

ASMGraph$ASMPlot  PROC FAR

              PUSH BP
              MOV  BP, SP       ; Stack initialisieren
              PUSH DI           ; Eventuelle Register-
              PUSH SI           ; variablen sichern
              PUSH DS
              PUSH ES

              MOV  AX, 0B800H   ; DS initialisieren:
              MOV  DS, AX       ; Zeiger auf
                                ; Bildschirmspeicher
PlotStart :   MOV  CX, PlotX    ; Byte-Adresse des
              CMP  CX, 639      ; gültige Koordinate ?
              JA   PlotEnde     ; Nein -> RETURN
              MOV  DX, PlotY    ; Punktes berechnen
              CMP  DX, 199      ; gültige Koordinate ?
              JA   PlotEnde     ; Nein -> RETURN
              MOV  AL, 80       ; Zeilenlaenge 80 Byte
              ROR  DX, 1        ; y DIV 2. Bit 0 aufheben
              MUL  DL           ; Zeilenoffset berechnen
              TEST DH, 80H      ; Bit 0 testen. War y
              JZ   PlotY_Gerade ; ungerade, dann die zweite
              ADD  AX, 2000H    ; Hälfte des Screens nehmen
PlotY_Gerade: MOV  DX, CX       ; x-Koordinate holen
              SHR  DX, 1        ; Auf Byte abbilden :
              SHR  DX, 1        ; x := x DIV 8
              SHR  DX, 1
              ADD  AX, DX       ; Zum Offset addieren
              MOV  DI, AX       ; Und Offset nach DI

              AND  CL, 07H      ; Bitmaske berechnen
              MOV  AH, 80H
              SHR  AH, CL       ; AH = zu setzendes Bit

              MOV  CX, 0004H    ; Schleifenzähler. 4 Ebenen
              MOV  BH, PlotColor; Farbe
              MOV  BL, 08H      ; Farbebene 8, 4, 2, 1
              MOV  AL, 03       ; Read-Register 3, 2, 1, 0
              MOV  DX, 03DEH
PlotLoop :    OUT  DX, AL
              XCHG AL, BL       ; Farbebene holen
              DEC  DX           ; Port 3DDH
              OUT  DX, AL       ; Write-Register setzen
              INC  DX
              TEST AL, BH       ; Farbeebene AND Farbe = ?
              JZ   PlotLoeschen ; FALSE -> Punkt löschen
PlotSetzen :  OR   [DI], AH     ; TRUE  -> Punkt setzen
              XCHG AL, BL       ; Farben tauschen
              DEC  AL           ; nächste Read-Ebene
              SHR  BL, 1        ; nächste Write-Ebene
              LOOP PlotLoop
              JMP  SHORT PlotEnde
PlotLoeschen: NOT  AH           ; Punkt löschen
              AND  [DI], AH
              NOT  AH           ; Alter Wert für Schleife !
              XCHG AL, BL       ; Ohne Jmp ist's etwas
              DEC  AL           ; schneller
              SHR  BL, 1
              LOOP PlotLoop

PlotEnde :    POP  ES
              POP  DS
              POP  SI
              POP  DI
              MOV  SP, BP
              POP  BP
              RETF 6            ; Stack in Ordnung bringen

ASMGraph$ASMPlot  ENDP


;*  PROCEDURE ASMPoint (x, y : CARDINAL) : CARDINAL;

PointX        EQU WORD PTR [BP + 8]         ; Parameter
PointY        EQU WORD PTR [BP + 6]


ASMGraph$ASMPoint PROC FAR

              PUSH BP
              MOV  BP, SP       ; Stack initialisieren
              PUSH DI
              PUSH SI
              PUSH DS
              PUSH ES

PointStart :  MOV  CX, 0004H    ; 4 Farbebenen
              MOV  BX, 0003H    ; Start mit Nr. 3
              MOV  DX, 03DEH    ; Read-Register
              MOV  AH, 0DH      ; BIOS-Request GetPixel
PointEbenen : MOV  AL, BL       ; Farbebene holen
              OUT  DX, AL       ; Read-Ebene setzen
              PUSH CX           ; Register werden gebraucht
              PUSH DX
              MOV  CX, PointX   ; Arbeit vom BIOS machen
              MOV  DX, PointY   ; lassen.
              INT  10H          ; Und los ...
              MOV  CL, BL
              SHL  AL, CL       ; Bit an richtige Position
              OR   BH, AL       ; bringen und in BH merken
              POP  DX
              POP  CX
              DEC  BL           ; Nächste Read-Ebene
              LOOP PointEbenen

              MOV  AL, BH       ; Ergebnis in AX zurückgeben
              XOR  AH, AH       ; und HiByte zurücksetzen

PointEnde :   POP  ES
              POP  DS
              POP  SI
              POP  DI
              MOV  SP, BP
              POP  BP
              RETF 4            ; Parameter poppen

ASMGraph$ASMPoint ENDP


;*  PROCEDURE ASMLine (x1, y1, x2, y2 : CARDINAL;
;*                    color : CARDINAL);

LineX1        EQU WORD PTR [BP + 14]     ; Parameter
LineY1        EQU WORD PTR [BP + 12]
LineX2        EQU WORD PTR [BP + 10]
LineY2        EQU WORD PTR [BP +  8]
LineColor     EQU BYTE PTR [BP +  6]

ASMGraph$ASMLine  PROC FAR

              PUSH BP
              MOV  BP, SP       ; Stack initialisieren
              PUSH DI
              PUSH SI
              PUSH DS
              PUSH ES

LineStart :   MOV  AX, LineX2   ; x2 nach AX
              MOV  BX, LineY2   ; y2 nach BX
              MOV  CX, LineX1   ; x1 nach CX
              MOV  DX, LineY1   ; y1 nach DX
              CMP  AX, CX       ; IF x2 < x1 THEN SwapX
              JAE  DontSwapX
SwapX :       XCHG AX, CX       ; Koordinaten tauschen
              XCHG BX, DX
              MOV  LineX2, AX   ; und x2 und y2 sichern
              MOV  LineY2, BX   ; (wird noch gebraucht)
DontSwapX :   SUB  AX, CX       ; dx := x2 - x1
              MOV  DI, AX       ; dx nach DI
              MOV  AL, LineColor
              CMP  BX, DX       ; IF y2 < y1 THEN JMP Y_Decrease
              JB   Y_Decrease   ; ELSE Y_Increase
Y_Increase :  SUB  BX, DX       ; dy := y2 - y1
              MOV  SI, BX       ; dy nach SI
              XOR  BX, BX       ; BX = eps = 0
              CMP  DI, SI       ; IF dx < dy
              JB   SHORT SteilInc ; THEN JMP SteilInc
              JMP  SHORT FlachInc ; ELSE FlachInc
Y_Decrease :  SUB  BX, DX       ; y1 in DX bewahren !
              NEG  BX           ; dy := y1 - y2
              MOV  SI, BX       ; dy nach SI
              XOR  BX, BX
              CMP  DI, SI       ; IF dx < dy
              JB   SHORT SteilDec ; THEN JMP SteilDec
              JMP  SHORT FlachDec ; ELSE JMP FlachDec
SteilInc :
SteilIncLoop: PUSH AX           ; LOOP
              PUSH BX           ; Register sichern
              PUSH CX
              PUSH DX
              PUSH CX           ; Parameter pushen
              PUSH DX
              PUSH AX
              CALL ASMGraph$ASMPlot ; Plot (x1, y1, color)
              POP  DX               ; Register wieder holen
              POP  CX
              POP  BX
              POP  AX
              CMP  DX, LineY2   ; IF y1 = y2 THEN
              JE   LineEnde     ;   RETURN
              INC  DX           ; ELSE INC (y1)
              ADD  BX, DI       ;   INC (eps, dx)
              ADD  BX, DI       ;   INC (eps, dx)
              CMP  BX, SI       ;   IF eps > dy THEN
              JLE  SteilIncLoop ;
              SUB  BX, SI       ;     DEC (eps, dy)
              SUB  BX, SI       ;     DEC (eps, dy)
              INC  CX           ;     INC (x1);
              JMP  SHORT SteilIncLoop ; END (* LOOP *)
FlachInc :
FlachIncLoop: PUSH AX           ; Register sichern
              PUSH BX
              PUSH CX
              PUSH DX
              PUSH CX           ; Parameter pushen
              PUSH DX
              PUSH AX
              CALL ASMGraph$ASMPlot ; Plot (x1, y1, color)
              POP  DX               ; Register wieder holen
              POP  CX
              POP  BX
              POP  AX
              CMP  CX, LineX2
              JE   LineEnde
              INC  CX
              ADD  BX, SI
              ADD  BX, SI
              CMP  BX, DI
              JLE  FlachIncLoop
              SUB  BX, DI
              SUB  BX, DI
              INC  DX
              JMP  SHORT FlachIncLoop
SteilDec :
SteilDecLoop: PUSH AX           ; Register sichern
              PUSH BX
              PUSH CX
              PUSH DX
              PUSH CX           ; Parameter pushen
              PUSH DX
              PUSH AX
              CALL ASMGraph$ASMPlot ; Plot (x1, y1, color)
              POP  DX               ; Register wieder holen
              POP  CX
              POP  BX
              POP  AX
              CMP  DX, LineY2
              JE   LineEnde
              DEC  DX
              ADD  BX, DI
              ADD  BX, DI
              CMP  BX, SI
              JLE  SteilDecLoop
              SUB  BX, SI
              SUB  BX, SI
              INC  CX
              JMP  SHORT SteilDecLoop
FlachDec :
FlachDecLoop: PUSH AX           ; Register sichern
              PUSH BX
              PUSH CX
              PUSH DX
              PUSH CX           ; Parameter pushen
              PUSH DX
              PUSH AX
              CALL ASMGraph$ASMPlot ; Plot (x1, y1, color)
              POP  DX               ; Register wieder holen
              POP  CX
              POP  BX
              POP  AX
              CMP  CX, LineX2
              JE   LineEnde
              INC  CX
              ADD  BX, SI
              ADD  BX, SI
              CMP  BX, DI
              JLE  FlachDecLoop
              SUB  BX, DI
              SUB  BX, DI
              DEC  DX
              JMP  SHORT FlachDecLoop

LineEnde :    POP  ES
              POP  DS
              POP  SI
              POP  DI
              MOV  SP, BP       ; Lokale Variable poppen
              POP  BP
              RETF 10           ; Parameter poppen

ASMGraph$ASMLine  ENDP

C_ASMGraph    ENDS              ; Segmentende
              END
;* ------------------------------------------------------- *
;*               Ende von ASMGRAPH.ASM                     *