OldComp.cz

; Rutina invertuje pixel
; vstup:
; HL = adresa bajtu s pixelem
; C = index pixelu v bajtu, kde 7 je uplne vlevo a 0 uplne vpravo
; zmeni: A
XorMask:
  ld a,DATA_PIXEL % 256      ;  7:2 o bajt delsi varianta, ale rychlejsi jak s ukladanim hl na zasobnik
  add a,c         ;  4:1
  ld (XM_Self+1),a      ; 13:3
XM_Self: 
  ld a,(DATA_PIXEL)      ; 13:3
  xor (hl)
  ld (hl),a
  ret            ; 10:1
 
DATA_PIXEL:
 db $01
 db $02
 db $04
 db $08
 db $10
 db $20
 db $40
 db $80
DATA_PIXEL_End
 
if ( DATA_PIXEL / 256) != ( DATA_PIXEL_End / 256 )
    .error 'Tabulka DATA_PIXEL preteka segment!'
endif

; Rutina posune adresu pixelu o jeden vpravo
; vstup:
; HL = adresa bajtu s pixelem
; C = index pixelu v bajtu, kde 7 je uplne vlevo a 0 uplne vpravo
; vystup: sign pokud se preslo na dalsi znak
PosunVpravo:
  dec c      ; 4:1 bohuzel nemeni carry
  ret p      ; 7..1 -> 6..0
  ld c,7   ; 0 -> $ff -> 7
  inc hl   ; pomalejsi ale nemeni priznaky
  ret

; Rutina vrati adresu bajtu obsahujiciho pixel o mikroradek nizsi nez byl
; vstup:
; HL = adresa bajtu s pixelem
; Pro spravnou funkcnost musi mit screen nebo buffer pocatek na adrese se segmentem delitelnym osmi 
; meni: A
PosunDolu:
  inc h
  ld a,$07   ; 7:2
  and h
  ret nz   ; nepretekli jsme do dalsiho znakoveho radku
 
  ld a,$20
  add a,l
  ld l,a
  ret c      ; jsme na zacatku dalsi tretiny
 
  ld a,h   ; preteceni do dalsiho znakoveho radku
  sub 8
  ld h,a
  ret

; Rutina vrati adresu bajtu obsahujiciho pixel o mikroradek vys nez byl
; vstup:
; HL = adresa bajtu s pixelem
; Pro spravnou funkcnost musi mit screen nebo buffer pocatek na adrese se segmentem delitelnym osmi 
; meni: A
PosunNahoru:
  ld a,h
  dec h
  and $07   
  ret nz   ; nepretekli jsme do dalsiho znakoveho radku
 
  ld a,l
  sub $20
  ld l,a
  ret c      ; jsme na konci dalsi tretiny
 
  ld a,h   ; preteceni do dalsiho znakoveho radku
  add a,8
  ld h,a
  ret

; Rutina zmeni adresu pixelu o B pozic doleva
; Vstup:
; HL = adresa bajtu s pixelem
; C = index pixelu v bajtu, kde 7 je uplne vlevo a 0 uplne vpravo
; B = o kolik doleva > 0
; Meni: A,B,C,L
PosunHodneVlevo:
   ld a,b
PHV_8x:
   dec l
   sub 8
   jr nc, PHV_8x
   inc l
   add a,8
   ret z      ; posun byl delitelny 8, nemusime hrabat na index pixelu
; zbyva posunout pixel o 1 az 7 pozic
   add a,c
   ld c,a
   sub 8
   ret c      ; vlezli jsme se do bajtu
; pretekli jsme o bajt vlevo
   dec l
   ld c,a
   ret

; Rutina nakresli vodorovnou caru od zadaneho bodu vcetne doprava   
; vstup:
; HL = adresa bajtu s pocatecnim pixelem, C obsahuje index prvniho pixelu v bajtu kde 7 je uplne vlevo a 0 uplne vpravo
; B = delka > 0
HorizontLine:
   push bc
   push hl
HL_loop:
   call XorMask
   call PosunVpravo
   djnz HL_loop            ; 13/8:2
   pop hl
   pop bc
   ret

; Rutina nakresli vodorovnou caru od zadaneho bodu vcetne doprava   
; vstup:
; HL = adresa bajtu s pocatecnim pixelem, C obsahuje index prvniho pixelu v bajtu kde 7 je uplne vlevo a 0 uplne vpravo
; B = delka > 0
HorizontLine:
   push bc
   push hl
   xor a            ; vynuluje priznaky
HL_loop:
   call m,ZrychleniHorizontLine      ; 17/10:3 nepovinne zrychleni
   call XorMask
   call PosunVpravo
   djnz HL_loop            ; 13/8:2
   pop hl
   pop bc
   ret

; Podrutina na zrychleni vykresleni vodorovne usecky
; vstup:
; HL = adresa bajtu s pocatecnim pixelem, C obsahuje index prvniho pixelu v bajtu kde 7 je uplne vlevo a 0 uplne vpravo
; B = delka v pixelech a ne znacich
; meni: A, B vraci v rozsahu 1..7, Pokud by B = 0 tak umaze na zasobniku navratovou adresu a skoci na predchozi, kvuli DJNZ 0
ZrychleniHorizontLine:
  ld a,b
  sub 8
  ret c         ; mene jak 8
  ld b,a

  ld a,(hl)      ; 7:1 !!!  nejpomalejsi cast programu
  cpl         ; 4:1 xor $ff !!!  nejpomalejsi cast programu
  ld (hl),a      ; 7:1 !!!  nejpomalejsi cast programu
  inc l         ; 4:1 !!!  nejpomalejsi cast programu

  ld a,b
  or a
  jr nz,ZrychleniHorizontLine+1
 
  pop af       ; chceme zrusit jeden ret
  pop hl
  pop bc
  ret

; Rutina na rychle vykresleni vodorovne usecky, ktera invertuje pozadi
; vstup:
; HL = adresa bajtu s pocatecnim pixelem, C obsahuje index prvniho pixelu v bajtu kde 7 je uplne vlevo a 0 uplne vpravo
; B = delka, kde 0 = 256
; vystup:
; uchova HL, BC, ale nici A

FastHorizontLine:

IF 0
  inc b
  dec b
ENDIF
  ld a,c
IF 0
  jr z,FHL_DokonciZnak      ; 0 = 256
  cp b
  jr c,FHL_DokonciZnak
 
; Primka nedokaze dolezt ani na konec prvniho znaku

  push bc         ; 11:1 kvuli jednomu pouziti C
  push hl         ; 11:1
  ld h,DATA_ZBYTEKZNAKU / 256   ; 7:2
  add a,DATA_ZBYTEKZNAKU % 256   ; 7:2
  ld l,a         ; 4:1
  sub b            ; 4:1
  ld c,(hl)         ; 7:1
  ld l,a         ; 4:1
  ld a,(hl)         ; 7:1
  xor c            ; 4:1 rozdil masek
  pop hl         ; 10:1
  pop bc         ; 10:1
  xor (hl)
  ld (hl),a
  ret            ; HL,BC zachovan

ENDIF
; Pokud mam osu soumernosti na predelu znaku tak vzdy dokoncim znak, takze mohu vse nahore smazat, krome ld a,c

FHL_DokonciZnak:      ; b > c
   
  add a,DATA_ZBYTEKZNAKU % 256   ; 7:2
  ld (FHL_Self0+1),a      ; 13:3
FHL_Self0: 
  ld a,(DATA_ZBYTEKZNAKU)   ; 13:3
 
  xor (hl)         ; 7:1
  ld (hl),a         ; 7:1
 
  ld a,b
  sub c
  dec a            ; 4:1
  ret z            ; 11/5:1 HL,BC zachovan

; Zbyva max 31 znaku, takze jsme v rozsahu skoku JR u rozbalene smycky

  push bc
  push hl
  inc l            ; 4:1
  ld b,a         ; b = F8..1
 
  ld a,$FF
  sub b
  and $F8
  rra
  ld (FHL_SelfJump+1),a
 
FHL_SelfJump:
  jr FHL_SelfJump;FHL_Zbytek

REPT 31
  ld a,(hl)         ; 7:1 !!!  nejpomalejsi cast programu
  cpl            ; 4:1 xor $ff !!!  nejpomalejsi cast programu
  ld (hl),a         ; 7:1 !!!  nejpomalejsi cast programu
  inc l            ; 4:1 !!!  nejpomalejsi cast programu
ENDM
 
  ld a,b
  and 7

  ld b,ZBYTEKPRIMKY / 256
  add a,ZBYTEKPRIMKY % 256
  ld  c,a

  ld a,(bc)
  xor (hl)
  ld (hl),a
 
  pop hl
  pop bc
  ret

DATA_ZBYTEKZNAKU:
db $01  ; 0
db $03   ; 1
db $07   ; 2
db $0F   ; 3
db $1F   ; 4
db $3F   ; 5
db $7F   ; 6
db $FF   ; 7
DATA_ZBYTEKZNAKU_End:

if ( DATA_ZBYTEKZNAKU / 256) != ( DATA_ZBYTEKZNAKU_End / 256 )
    .error 'Tabulka DATA_ZBYTEKZNAKU preteka segment!'
endif

ZBYTEKPRIMKY:
db $00  ; 0
db $80   ; 1
db $C0   ; 2
db $E0   ; 3
db $F0   ; 4
db $F8   ; 5
db $FC   ; 6
db $FE   ; 7
ZBYTEKPRIMKYend:

if ( ZBYTEKPRIMKY / 256) != ( ZBYTEKPRIMKYend / 256 )
    .error 'Tabulka ZBYTEKPRIMKY preteka segment!'
endif

        ld    a,xl
    cpl    
    add    a,a
    add    a,a
    add    a,a
    or    #c7

    ld    a,l
    and   $07
    add    a,a      ; 2*l
    add    a,a       ; 4*l
    add    a,a       ; 8*l
    cpl         ; invertuje bity = -a-1

; ========================
; rutina pro vytvoreni prevodnich tabulek z X,Y na adresa bajtu s pixelem a jeho maska
; vstup: nic
; vystup: inicializuje tabulku tabbod
; prvnich 256 bajtu obsahuje segmenty pocatku radku od Y = 0 az 255
; druhych 256 bajtu obsahuje jejich ofsety
; tretich 265 bajtu obsahuje bajt na radku s pixelem
; ctvrtych 256 bajtu obsahuje masku
IF Original
; meni: a,hl,ix
mkbod    ld    ix,tabbod
    ld    hl,#4000
; inicializace prvnich dvou 256 bajtovych tabulek obsahujicich adresy pocatku radku
mkbb1    ld    (ix+#00),h
    inc    ixh
    ld    (ix+#00),l
    dec    ixh
    call    dole
    inc    ixl
    jr    nz,mkbb1
; inicializace druhych dvou tabulek
    inc    ixh
    inc    ixh
mkbb2    ld    a,ixl
    rrca    
    rrca    
    rrca    
    and    #1f       ; a / 8, nebo a >>= 3, nebo zjisteni v jakem jsme bajtu s pixelem o souradnici X
    ld    (ix+#00),a
    ld    a,ixl
    cpl         ; invertuje bity
    add    a,a      ; 2*(-ixl-1)
    add    a,a       ; 4*
    add    a,a       ; 8*(-ixl-1) => 0,1,2,3,4.. => -8,-16,-24,-32, => F8,F0,E8
    or    #c7       ;                                              => FF,F7
    ld    (mkbb3+1),a
    xor    a
mkbb3    set    1,a      ; $CB $C7 + x*8 = set x,a; $C7,CF,D7,DF,E7,EF,F7,FF = -8*x-1 = and a,$07: 3x add a,a: cpl
    inc    ixh
    ld    (ix+#00),a
    dec    ixh
    inc    ixl
    jr    nz,mkbb2
    ret
ELSE
; meni: a,hl,de   
mkbod    ld    hl,tabbod
    ld    de,#4000
; inicializace prvnich dvou 256 bajtovych tabulek obsahujicich adresy pocatku radku
loop1    ld    (hl),d
    inc    h
    ld    (hl),e
    dec    h
    ex de,hl
    call    dole
    ex de,hl
    inc    l
    jr    nz,loop1
; inicializace druhych dvou tabulek
    inc    h
    inc    h
loop2    ld    a,l
    rra    
    rra    
    rra    
    and    #1f       ; a / 8, nebo a >>= 3, nebo zjisteni v jakem jsme bajtu s pixelem o souradnici X
    ld    (hl),a
    ld    a,l
    and   $07
    add    a,a      ; 2*l
    add    a,a       ; 4*l
    add    a,a       ; 8*l
    cpl         ; invertuje bity = -a-1
    ld    (self+1),a
    xor    a
self    set    1,a      ; $CB $C7 + x*8 = set x,a; $C7,CF,D7,DF,E7,EF,F7,FF = -8*x-1 = and a,$07: 3x add a,a: cpl
    inc    h
    ld    (hl),a
    dec    h
    inc    l
    jr    nz,loop2
    ret
ENDIF

; ========================
; Rutina vykresli vodorovnou usecku podle rezimu nastaveneho rutinou "over"
; vstup: [Y,X] krajniho bodu v [B,C]
; D = X konec
; meni: A,HL,BC,DE
rovno    ld    a,d
    cp    c
    jr    nc,rov01      ; X konec > X pocatek?
    ld    d,c
    ld    c,a          ; prohozeni C a D
rov01    ld    h,hitbod+2      ; segment 256 bajtove tabulky obsahujici bajt na radku podle X
    ld    l,c
    ld    a,(hl)         ; a = kolikaty je to bajt radku
    dec    h
    ld    l,b
    or    (hl)          ; a = ofset adresy bajtu s pixelem
    dec    h
    ld    h,(hl)         ; h = segment adresy bajtu s pixelem
    ld    l,a         ; hl = adresa bajtu s pixelem
    ld    a,c
    and    #f8
    ld    e,a         ; e = pocatecni bajt * 8
    ld    a,d
    and    #f8          ; a = koncovy bajt * 8
IF Original
    cp    e         ; chybka, tady melo byt sub e
ELSE
   sub   e
ENDIF
    jr    nz,r2byte
; usecka neopusti prvni bajt
    ld    a,c
    and    #07         
    ld    b,a          ; index prvniho pixelu v bajtu, zleva doprava 0..7
    ld    a,#ff          
    jr    z,rov02
rov03    srl    a
    djnz    rov03
rov02    ld    c,a          ; maska od prvniho pixelu do konce
; sem skocime i v pripade ze je usecka delsi, pri poslednim bajtu s maskou c = $ff
rov99    ld    a,d
    and    #07          
    ld    b,a         ; index posledniho pixelu v bajtu, zleva doprava 0..7
    ld    a,#80
    jr    z,rov04         ; tohle by melo nastat jen pokud je usecka dlouha jeden pixel a to ten uplne nalevo
rov05    scf            ; set carry flag
    rra    
    djnz    rov05         ; vytvarime masku od zacatku bajtu az po posledni pixel
rov04    and    c          ; maska usecky
ooset1    xor    (hl)
    ld    (hl),a
    ret
; usecka je preleza bajt
r2byte
IF Original
   sub    e         ; nechapu proc predtim jsem teda delali cp e, kdyz u druhe varianty hned prepisem registr a
ENDIF
   rrca    
    rrca    
    rrca    
    ld    e,a         ; rozdil bajtu
; vykresleni pro prvni bajt
    ld    a,c
    and    #07
    ld    b,a         ; index prvniho pixelu v bajtu, zleva doprava 0..7
    ld    a,#ff
    jr    z,ooset2
rov06    srl    a
    djnz    rov06         ; vytvareni masky prvniho pixelu az do konce bajtu
ooset2    xor    (hl)
    ld    (hl),a
; prvni bajt vyresen
IF Original
    ld    b,c         ; nadbytecna instrukce?
ENDIF
    ld    c,#ff
rov40    inc    l
    dec    e         ; v e je citac bajtu do konce
    jr    z,rov99
    ld    a,c
ooset3    xor    (hl)
    ld    (hl),a         ; kresleni pres cely bajt
    jr    rov40