cursos:ensamblador:gfx2_direccionamiento

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anterior Revisión previa
Próxima revisión		 Revisión previa
cursos:ensamblador:gfx2_direccionamiento [19-01-2024 08:17] – sromerocursos:ensamblador:gfx2_direccionamiento [21-01-2024 17:22] (actual) – [Optimizaciones para Get_Pixel_Offset_HR] sromero
Línea 168: Línea 168:
     ; calcular dir_atributo como "inicio_attr + (32*f) + c"     ; calcular dir_atributo como "inicio_attr + (32*f) + c"
     ld h, 0     ld h, 0
-    ld l, b         ; HL = "fila" +    ld l, b                  ; HL = "fila" 
-    add hl, hl      ; HL = HL*2 +    add hl, hl               ; HL = HL*2 
-    add hl, hl      ; HL = HL*4 +    add hl, hl               ; HL = HL*4 
-    add hl, hl      ; HL = HL*8 +    add hl, hl               ; HL = HL*8 
-    add hl, hl      ; HL = HL*16 +    add hl, hl               ; HL = HL*16 
-    add hl, hl      ; HL = HL*32+    add hl, hl               ; HL = HL*32
     ld d, 0     ld d, 0
-    ld e, c         ; DE = "columna" +    ld e, c                  ; DE = "columna" 
-    add hl, de      ; HL = fila*32 + columna +    add hl, de               ; HL = fila*32 + columna 
-    ld de, 22528    ; Direccion de inicio de atributos +    ld de, 22528             ; Direccion de inicio de atributos 
-    add hl, de      ; HL = 22528 + fila*32 + columna+    add hl, de               ; HL = 22528 + fila*32 + columna
     ret     ret
 </code> </code>
Línea 226: Línea 226:
 ;------------------------------------------------------------- ;-------------------------------------------------------------
 Get_Attribute_Offset_LR: Get_Attribute_Offset_LR:
-    ld a, b            ; Ponemos en A la fila (000FFFFFb)+    ld a, b                  ; Ponemos en A la fila (000FFFFFb)
     rrca     rrca
     rrca     rrca
-    rrca               ; Desplazamos A 3 veces (A=A>>3) +    rrca                     ; Desplazamos A 3 veces (A=A>>3) 
-    and 3              ; A = A and 00000011 = los 2 bits mas +    and %00000011            ; A = A and %00000011 = los 2 bits mas 
-                       ; altos de FILA (000FFFFFb -> 000000FFb) +                             ; altos de FILA (%000FFFFF -> %000000FF) 
-    add a, $58         ; Ponemos los bits 15-10 como 010110b +    add a, %01011000         ; Ponemos los bits 15-10 como 010110b 
-    ld h, a            ; Lo cargamos en el byte alto de HL +    ld h, a                  ; Lo cargamos en el byte alto de HL 
-    ld a, b            ; Recuperamos de nuevo en A la FILA +    ld a, b                  ; Recuperamos de nuevo en A la FILA 
-    and 7              ; Nos quedamos con los 3 bits que faltan+    and %00000111            ; Nos quedamos con los 3 bits que faltan
     rrca     rrca
-    rrca               ; Los rotamos para colocarlos en su +    rrca                     ; Los rotamos para colocarlos en su 
-    rrca               ; ubicacion final (<<5 = >>3) +    rrca                     ; ubicacion final (<<5 = >>3) 
-    add a, c           ; Sumamos el numero de columna +    add a, c                 ; Sumamos el numero de columna 
-    ld l, a            ; Lo colocamos en L +    ld l, a                  ; Lo colocamos en L 
-    ret                ; HL = 010110FFFFFCCCCCb+    ret                      ; HL = %010110FFFFFCCCCC
 </code> </code>
  
Línea 255: Línea 255:
     call Get_Attribute_Offset_LR     call Get_Attribute_Offset_LR
  
-    ld a, 85             ; Brillo + Magenta sobre Cyan +    ld a, 85                 ; Brillo + Magenta sobre Cyan 
-    ld (hl), a           ; Establecemos el atributo de (12,10)+    ld (hl), a               ; Establecemos el atributo de (12,10)
 </code> </code>
  
Línea 268: Línea 268:
     srl b     srl b
     srl b     srl b
-    srl b              ; B = B/8 -> Ahora B es FILA+    srl b                    ; B = B/8 -> Ahora B es FILA
  
     srl c     srl c
     srl c     srl c
-    srl c              ; C = C/8 -> Ahora C es COLUMNA+    srl c                    ; C = C/8 -> Ahora C es COLUMNA
 </code> </code>
  
Línea 289: Línea 289:
     srl b     srl b
     srl b     srl b
-    srl b              ; B = B/8 -> Ahora B es FILA+    srl b                    ; B = B/8 -> Ahora B es FILA
  
     srl c     srl c
     srl c     srl c
-    srl c              ; C = C/8 -> Ahora C es COLUMNA+    srl c                    ; C = C/8 -> Ahora C es COLUMNA
  
     ld a, b     ld a, b
     rrca     rrca
     rrca     rrca
-    rrca               ; Desplazamos A 3 veces (A=A>>3) +    rrca                     ; Desplazamos A 3 veces (A=A>>3) 
-    and 3              ; A = A and 00000011 = los 2 bits mas +    and %00000011            ; A = A and 00000011 = los 2 bits mas 
-                       ; altos de FILA (000FFFFFb -> 000000FFb) +                             ; altos de FILA (000FFFFFb -> 000000FFb) 
- +    add a, %01011000         ; Ponemos los bits 15-10 como 010110b 
-    add a, $58         ; Ponemos los bits 15-10 como 010110b +    ld h, a                  ; Lo cargamos en el byte alto de HL 
-    ld h, a            ; Lo cargamos en el byte alto de HL +    ld a, b                  ; Recuperamos de nuevo en A la FILA 
-    ld a, b            ; Recuperamos de nuevo en A la FILA +    and %00000011            ; Nos quedamos con los 3 bits que faltan
-    and 7              ; Nos quedamos con los 3 bits que faltan+
     rrca     rrca
-    rrca               ; Los rotamos para colocarlos en su +    rrca                     ; Los rotamos para colocarlos en su 
-    rrca               ; ubicacion final (<<5 = >>3) +    rrca                     ; ubicacion final (<<5 = >>3) 
-    add a, c           ; Sumamos el numero de columna +    add a, c                 ; Sumamos el numero de columna 
-    ld l, a            ; Lo colocamos en L +    ld l, a                  ; Lo colocamos en L 
-    ret                ; HL = 010110FFFFFCCCCCb+    ret                      ; HL = 010110FFFFFCCCCCb
 </code> </code>
  
Línea 332: Línea 331:
 ;------------------------------------------------------------- ;-------------------------------------------------------------
 Get_Attribute_Coordinates_LR: Get_Attribute_Coordinates_LR:
-                      ; Descomponemos HL = 010110FF FFFCCCCCb +                             ; Descomponemos HL = 010110FF FFFCCCCCb 
-    ld a, h            ; A = 010110FFb +    ld a, h                  ; A = 010110FFb 
-    and 3              ; A = bits 0, 1 de HL = 2 bits altos de F, CF=0+    and %00000011            ; A = bits 0, 1 de HL = 2 bits altos de F, CF=0
     rlca     rlca
     rlca     rlca
-    rlca               ; Rotacion a izquierda 000000FFb -> 000FF000b +    rlca                     ; Rotacion a izquierda 000000FFb -> 000FF000b 
-    ld b, a            ; B = 000FF000b+    ld b, a                  ; B = 000FF000b
  
     ld a, l     ld a, l
-    and 224            ; Nos quedamos con los 3 bits mas altos+    and %11100000            ; Nos quedamos con los 3 bits mas altos
     rlca     rlca
     rlca     rlca
-    rlca               ; Rotacion a izquierda FFF00000b -> 00000FFFb +    rlca                     ; Rotacion a izquierda FFF00000b -> 00000FFFb 
-    or b               ; A = A + B = 000FFFFFb +    or b                     ; A = A + B = 000FFFFFb 
-    ld b, a            ; B = FILA+    ld b, a                  ; B = FILA
  
     ld a, l     ld a, l
-    and 31             ; Nos quedamos con los 5 bits mas bajos +    and %00011111            ; Nos quedamos con los 5 bits mas bajos 
-    ld c, a            ; C = COLUMNA+    ld c, a                  ; C = COLUMNA
  
     ret     ret
Línea 369: Línea 368:
 ;------------------------------------------------------------- ;-------------------------------------------------------------
 Get_Attribute_Coordinates_HR: Get_Attribute_Coordinates_HR:
-                       ; Descomponemos HL = 010110FF FFFCCCCCb +                             ; Descomponemos HL = 010110FF FFFCCCCCb 
-    ld a, h            ; A = 010110FFb +    ld a, h                  ; A = 010110FFb 
-    and 3              ; A = bits 0, 1 de HL = 2 bits altos de F, CF=0+    and 3                    ; A = bits 0, 1 de HL = 2 bits altos de F, CF=0
     rlca     rlca
     rlca     rlca
-    rlca               ; Rotacion a izquierda 000000FFb -> 000FF000b +    rlca                     ; Rotacion a izquierda 000000FFb -> 000FF000b 
-    ld b, a            ; B = 000FF000b+    ld b, a                  ; B = 000FF000b
  
     ld a, l     ld a, l
-    and 224            ; Nos quedamos con los 3 bits mas altos+    and %11100000            ; Nos quedamos con los 3 bits mas altos
     rlca     rlca
     rlca     rlca
-    rlca               ; Rotacion a izquierda FFF00000b -> 00000FFFb +    rlca                     ; Rotacion a izquierda FFF00000b -> 00000FFFb 
-    or b               ; A = A + B = 000FFFFFb +    or b                     ; A = A + B = 000FFFFFb 
-    ld b, a            ; B = FILA+    ld b, a                  ; B = FILA
  
     ld a, l     ld a, l
-    and 31             ; Nos quedamos con los 5 bits mas bajos +    and %00011111            ; Nos quedamos con los 5 bits mas bajos 
-    ld c, a            ; C = COLUMNA+    ld c, a                  ; C = COLUMNA
  
     sla c     sla c
     sla c     sla c
-    sla c              ; C = C*8+    sla c                    ; C = C*8
  
     sla b     sla b
     sla b     sla b
-    sla b              ; B = B*8+    sla b                    ; B = B*8
  
     ret     ret
Línea 409: Línea 408:
 <code z80> <code z80>
 Atributo_derecha: Atributo_derecha:
-    inc hl            ; HL = HL + 1+    inc hl                   ; HL = HL + 1
  
 Atributo_izquierda: Atributo_izquierda:
-    dec hl            ; HL = HL - 1+    dec hl                   ; HL = HL - 1
  
 Atributo_abajo: Atributo_abajo:
     ld de, 32     ld de, 32
-    add hl, de        ; HL = HL + 32+    add hl, de               ; HL = HL + 32
  
 Atributo_arriba: Atributo_arriba:
     ld de, -32     ld de, -32
-    add hl, de        ; HL = HL - 32+    add hl, de               ; HL = HL - 32
 </code> </code>
  
Línea 427: Línea 426:
 <code z80> <code z80>
 Atributo_abajo_sin_usar_DE_2: Atributo_abajo_sin_usar_DE_2:
-    ld a, l           ; A = L +    ld a, l                  ; A = L 
-    ADD 32            ; Sumamos A = A + 32 . El Carry Flag se ve afectado. +    add a, 32                ; Sumamos A = A + 32 . El Carry Flag se ve afectado. 
-    ld l, a           ; Guardamos en L (L = L+32)+    ld l, a                  ; Guardamos en L (L = L+32)
     jr nc, attrab_noinc     jr nc, attrab_noinc
     inc h     inc h
-attrab_noinc:         ; Ahora HL = (H+CF)*256 + (L+32) = HL + 32+attrab_noinc:                ; Ahora HL = (H+CF)*256 + (L+32) = HL + 32
  
 Atributo_arriba_sin_usar_DE: Atributo_arriba_sin_usar_DE:
-    ld a, l           ; A = L +    ld a, l                  ; A = L 
-    sub 32            ; Restamos A = A - 32 . El Carry Flag se ve afectado. +    sub 32                   ; Restamos A = A - 32 . El Carry Flag se ve afectado. 
-    ld l, a           ; Guardamos en L (L = L-32)+    ld l, a                  ; Guardamos en L (L = L-32)
     jr nc, attrab_nodec     jr nc, attrab_nodec
     dec h     dec h
-attrab_nodec:         ; Ahora HL = (H+CF)*256 + (L+32) = HL + 32+attrab_nodec:                ; Ahora HL = (H+CF)*256 + (L+32) = HL + 32
  
 </code> </code>
Línea 455: Línea 454:
  
 <code z80> <code z80>
-    ld a, 0           ; Ponemos A a cero, no podemos usar un "xor a" +    ld a, 0                  ; Ponemos A a cero, no podemos usar un "xor a" 
-                      ; o un "or a" porque afectariamos al Carry Flag. +                             ; o un "or a" porque afectariamos al Carry Flag. 
-    ADC H             ; A = H + CarryFlag +    adc a, h                 ; A = H + CarryFlag 
-    ld h, a           ; H = H + CarryFlag +    ld h, a                  ; H = H + CarryFlag 
-                      ; Ahora HL = (H+CF)*256 + (L+32) = HL + 32+                             ; Ahora HL = (H+CF)*256 + (L+32) = HL + 32
 </code> </code>
  
Línea 577: Línea 576:
 ;------------------------------------------------------------- ;-------------------------------------------------------------
 Get_Line_Offset_LR: Get_Line_Offset_LR:
-    ld a, b         ; A = B, para extraer los bits de tercio +    ld a, b                  ; A = B, para extraer los bits de tercio 
-    and $18         ; A = A and 00011000b +    and %00011000            ; A = A and 00011000b 
-                    ; A = estado de bits de TERCIO desde FILA +                             ; A = estado de bits de TERCIO desde FILA 
-    add a, $40      ; Sumamos $40 (2 bits superiores = 010) +    add a, %01000000         ; Sumamos $40 (bits superiores = 010) 
-    ld h, a         ; Ya tenemos la parte alta calculada +    ld h, a                  ; Ya tenemos la parte alta calculada 
-                    ; H = 010TT000 +                             ; H = 010TT000 
-    ld a, b         ; Ahora calculamos la parte baja +    ld a, b                  ; Ahora calculamos la parte baja 
-    and 7           ; Nos quedamos con los bits más bajos de FILA +    and %00000111            ; Nos quedamos con los bits más bajos de FILA 
-                    ; que coinciden con FT (Fila dentro del tercio) +                             ; que coinciden con FT (Fila dentro del tercio) 
-    rrca            ; Ahora A = 00000NNNb  (donde N=FT) +    rrca                     ; Ahora A = 00000NNNb  (donde N=FT) 
-    rrca            ; Desplazamos A 3 veces +    rrca                     ; Desplazamos A 3 veces 
-    rrca            ; A = NNN00000b +    rrca                     ; A = NNN00000b 
-    ld l, a         ; Lo cargamos en la parte baja de la direccion +    ld l, a                  ; Lo cargamos en la parte baja de la direccion 
-    ret             ; HL = 010TT000NNN00000b+    ret                      ; HL = 010TT000NNN00000b
 </code> </code>
  
Línea 629: Línea 628:
 ;------------------------------------------------------------- ;-------------------------------------------------------------
 Get_Char_Offset_LR: Get_Char_Offset_LR:
-    ld a, b         ; A = B, para extraer los bits de tercio +    ld a, b                  ; A = B, para extraer los bits de tercio 
-    and $18         ; A = A and 00011000b +    and %00011000            ; A = A and 00011000b 
-                    ; A = estado de bits de TERCIO desde FILA +                             ; A = estado de bits de TERCIO desde FILA 
-    add a, $40      ; Sumamos $40 (2 bits superiores = 010) +    add a, %01000000         ; Sumamos $40 (bits superiores = 010) 
-    ld h, a         ; Ya tenemos la parte alta calculada +    ld h, a                  ; Ya tenemos la parte alta calculada 
-                    ; H = 010TT000 +                             ; H = 010TT000 
-    ld a, b         ; Ahora calculamos la parte baja +    ld a, b                  ; Ahora calculamos la parte baja 
-    and 7           ; Nos quedamos con los bits más bajos de FILA +    and %00000111            ; Nos quedamos con los bits más bajos de FILA 
-                    ; que coinciden con FT (Fila dentro del tercio) +                             ; que coinciden con FT (Fila dentro del tercio) 
-    rrca            ; Ahora A = 00000NNNb     (N=FT) +    rrca                     ; Ahora A = 00000NNNb     (N=FT) 
-    rrca            ; Desplazamos A 3 veces a la derecha +    rrca                     ; Desplazamos A 3 veces a la derecha 
-    rrca            ; A = NNN00000b +    rrca                     ; A = NNN00000b 
-    add a, c        ; Sumamos COLUMNA -> A = NNNCCCCCb +    add a, c                 ; Sumamos COLUMNA -> A = NNNCCCCCb 
-    ld l, a         ; Lo cargamos en la parte baja de la direccion +    ld l, a                  ; Lo cargamos en la parte baja de la direccion 
-    ret             ; HL = 010TT000NNNCCCCCb+    ret                      ; HL = 010TT000NNNCCCCCb
 </code> </code>
  
Línea 660: Línea 659:
     srl b     srl b
     srl b     srl b
-    srl b           ; B = B/8 -> Ahora B es FILA+    srl b                    ; B = B/8 -> Ahora B es FILA
  
     srl c     srl c
     srl c     srl c
-    srl c           ; C = C/8 -> Ahora C es COLUMNA+    srl c                    ; C = C/8 -> Ahora C es COLUMNA
  
-    (...)           ; Resto de la rutina Get_Char_Offset_LR+    (...)                    ; Resto de la rutina Get_Char_Offset_LR
     ret     ret
 </code> </code>
Línea 688: Línea 687:
     ; HL = 010TT000 NNNCCCCCb ->     ; HL = 010TT000 NNNCCCCCb ->
     ;      Fila = 000TTNNNb y Columna = 000CCCCCb     ;      Fila = 000TTNNNb y Columna = 000CCCCCb
-                    ; Calculo de la fila: 
-    ld a, h         ; A = H, para extraer los bits de tercio 
-    and $18         ; A = 000TT000b 
-    ld b, a         ; B = A = 000TT000b 
  
-    ld a, l         ; A = L, para extraer los bits de N (FT) +                             ; Calculo de la fila: 
-    and $e0         ; A = A and 11100000b = NNN00000b +    ld a, h                  ; A = H, para extraer los bits de tercio 
-    rlc a           ; Rotamos A 3 veces a la izquierda+    and %00011000            ; A = 000TT000b 
 +    ld b, a                  ; B = A = 000TT000b 
 + 
 +    ld a, l                  ; A = L, para extraer los bits de N (FT) 
 +    and %0b11100000          ; A = A and 11100000b = NNN00000b 
 +    rlc a                    ; Rotamos A 3 veces a la izquierda
     rlc a     rlc a
-    rlc a           ; A = 00000NNNb +    rlc a                    ; A = 00000NNNb 
-    or b            ; A = A or b = 000TTNNNb +    or b                     ; A = A or b = 000TTNNNb 
-    ld b, a         ; B = A = 000TTNNNb+    ld b, a                  ; B = A = 000TTNNNb
  
-                    ; Calculo de la columna: +                             ; Calculo de la columna: 
-    ld a, l         ; A = L, para extraer los bits de columna +    ld a, l                  ; A = L, para extraer los bits de columna 
-    and $1f         ; Nos quedamos con los ultimos 5 bits de L +    and %00011111            ; Nos quedamos con los ultimos 5 bits de L 
-    ld c, a         ; C = Columna +    ld c, a                  ; C = Columna 
-    ret             ; HL = 010TT000NNNCCCCCb+             ret             ; HL = 010TT000NNNCCCCCb
 </code> </code>
  
Línea 713: Línea 713:
     sla c     sla c
     sla c     sla c
-    sla c              ; C = C*8+    sla c                    ; C = C*8
  
     sla b     sla b
     sla b     sla b
-    sla b              ; B = B*8+    sla b                    ; B = B*8
 </code> </code>
  
Línea 733: Línea 733:
 <code z80> <code z80>
 Scanline_Arriba_HL: Scanline_Arriba_HL:
-  dec h            ; H = H - 1  (HL = HL-255)+  dec h                      ; H = H - 1  (HL = HL-255)
  
 Scanline_Abajo_HL: Scanline_Abajo_HL:
-  inc h            ; H = H + 1  (HL = HL-255)+  inc h                      ; H = H + 1  (HL = HL-255)
 </code> </code>
  
Línea 752: Línea 752:
 <code z80> <code z80>
 Caracter_Derecha_HL: Caracter_Derecha_HL:
-    inc hl            ; HL = HL + 1+    inc hl                   ; HL = HL + 1
  
 Caracter_Izquierda_HL: Caracter_Izquierda_HL:
-    dec hl            ; HL = HL - 1+    dec hl                   ; HL = HL - 1
 </code> </code>
  
Línea 774: Línea 774:
  
 <code z80> <code z80>
-    ld a, l                     ; Cargamos A en L y le sumamos 32 para +Caracter_Abajo_HL: 
-    add a, 32                   ; incrementar "Bloque dentro del tercio" +    ld a, l                       ; Cargamos A en L y le sumamos 32 para 
-    ld l, a                     ; L = A +    add a, %00100000              ; incrementar "Bloque dentro del tercio" (+32) 
-    jr nc, no_ajustar_H_abajob  ; Si esta suma produce acarreo, ajustar +    ld l, a                       ; L = A 
-    ld a, h                     ; la parte alta sumando 8 a H (TT = TT + 1). +    jr nc, no_ajustar_H_abajob    ; Si esta suma produce acarreo, ajustar 
-    add a, 8                    ; Ahora NNN=000b y TT se ha incrementado. +    ld a, h                       ; la parte alta sumando 8 a H (TT = TT + 1). 
-    ld h, a                     ; H = A+    add a, %00001000              ; Ahora NNN=000b y TT se ha incrementado. 
 +    ld h, a                       ; H = A
 no_ajustar_H_abajob no_ajustar_H_abajob
-                                ; Ahora HL apunta al bloque de debajo.+                                  ; Ahora HL apunta al bloque de debajo.
 </code> </code>
  
Línea 788: Línea 789:
  
 <code z80> <code z80>
-    ld a, l                       ; Cargamos L en A 
-    and 224                       ; A = A and 11100000b 
-    jr nz, no_ajustar_h_arribab   ; Si no es cero, no retrocedemos tercio 
-    ld a, h                       ; Si es cero, ajustamos tercio (-1) 
-    sub 8                         ; Decrementamos TT 
-    ld h, a 
-no_ajustar_h_arribab: 
-    ld a, l                       ; Decrementar NNN 
-    sub 32 
-    ld l, a                       ; NNN = NNN-1 
-</code> 
- 
- En forma de rutina: 
- 
-<code z80> 
-Caracter_Abajo_HL: 
-    ld a, l                     ; Cargamos A en L y le sumamos 32 para 
-    add a, 32                   ; incrementar "Bloque dentro del tercio" 
-    ld l, a                     ; L = A 
-    ret nc                      ; Si esta suma no produce acarreo, fin 
-    ld a, h                     ; la parte alta sumando 8 a H (TT = TT + 1). 
-    add a, 8                    ; Ahora NNN=000b y TT se ha incrementado. 
-    ld h, a                     ; H = A 
-    ret 
- 
 Caracter_Arriba_HL: Caracter_Arriba_HL:
     ld a, l                       ; Cargamos L en A     ld a, l                       ; Cargamos L en A
-    and 224                       ; A = A and 11100000b+    and %11100000                 ; A = A and 11100000b
     jr nz, nofix_h_arribab        ; Si no es cero, no retrocedemos tercio     jr nz, nofix_h_arribab        ; Si no es cero, no retrocedemos tercio
     ld a, h                       ; Si es cero, ajustamos tercio (-1)     ld a, h                       ; Si es cero, ajustamos tercio (-1)
-    sub 8                         ; Decrementamos TT+    sub %00001000                 ; Decrementamos TT
     ld h, a     ld h, a
 nofix_h_arribab: nofix_h_arribab:
Línea 914: Línea 890:
 \\  \\ 
  
- No obstante, recordemos que esta dirección de memoria obtenida hace referencia a 8 píxeles, por lo que necesitamos obtener además la información del número de bit con el que se corresponde nuestro pixel, que podemos extraer del resto de la división entre 8 de la coordenada X (P = X and 7).+ No obstante, recordemos que esta dirección de memoria obtenida hace referencia a 8 píxeles, por lo que necesitamos obtener además la información del número de bit con el que se corresponde nuestro pixel, que podemos extraer del resto de la división entre 8 de la coordenada X (P = X and %00000111).
  
  La rutina resultante es similar a la vista en baja resolución con la descomposición de la coordenada Y en el "número de scanline" (0-7) y la "fila dentro del tercio (0-7)":  La rutina resultante es similar a la vista en baja resolución con la descomposición de la coordenada Y en el "número de scanline" (0-7) y la "fila dentro del tercio (0-7)":
Línea 931: Línea 907:
     ; Calculo de la parte alta de la direccion:     ; Calculo de la parte alta de la direccion:
     ld a, b     ld a, b
-    and 7                       ; A = 00000SSSb +    and %00000111            ; A = 00000SSSb 
-    ld h, a                     ; Lo guardamos en H +    ld h, a                  ; Lo guardamos en H 
-    ld a, b                     ; Recuperamos de nuevo Y+    ld a, b                  ; Recuperamos de nuevo Y
     rra     rra
     rra     rra
-    rra                         ; Rotamos para asi obtener el tercio +    rra                      ; Rotamos para asi obtener el tercio 
-    and 24                      ; con un and 00011000b -> 000TT000b +    and %00011000            ; con un and 00011000b -> 000TT000b 
-    or h                        ; H = H or a = 00000SSSb or 000TT000b +    or h                     ; H = H or a = 00000SSSb or 000TT000b 
-    or 64                       ; Mezclamos H con 01000000b (vram) +    or %01000000             ; Mezclamos H con 01000000b (vram) 
-    ld h, a                     ; Establecemos el "H" definitivo+    ld h, a                  ; Establecemos el "H" definitivo
  
     ; Calculo de la parte baja de la direccion:     ; Calculo de la parte baja de la direccion:
-    ld a, c                     ; A = coordenada X+    ld a, c                  ; A = coordenada X
     rra     rra
     rra     rra
-    rra                         ; Rotamos para obtener CCCCCb +    rra                      ; Rotamos para obtener CCCCCb 
-    and 31                      ; A = A and 31 = 000CCCCCb +    and %00011111            ; A = A and 31 = 000CCCCCb 
-    ld l, a                     ; L = 000CCCCCb +    ld l, a                  ; L = 000CCCCCb 
-    ld a, b                     ; Recuperamos de nuevo Y +    ld a, b                  ; Recuperamos de nuevo Y 
-    rla                         ; Rotamos para obtener NNN+    rla                      ; Rotamos para obtener NNN
     rla     rla
-    and 224                     ; A = A and 11100000b +    and %11100000            ; A = A and 11100000b 
-    or l                        ; L = NNNCCCCC +    or l                     ; L = NNNCCCCC 
-    ld l, a                     ; Establecemos el "L" definitivo+    ld l, a                  ; Establecemos el "L" definitivo
  
     ; Finalmente, calcular posicion relativa del pixel:     ; Finalmente, calcular posicion relativa del pixel:
-    ld a, c                      ; Recuperamos la coordenada X +    ld a, c                  ; Recuperamos la coordenada X 
-    and 7                        ; and 00000111 para obtener pixel +    and %00000111            ; and 00000111 para obtener pixel 
-                                 ; A = 00000PPP+                             ; A = 00000PPP
     ret     ret
 </code> </code>
  
- Esta rutina de 118 t-estados nos devuelve el valor de la dirección calculado en HL y la posición relativa del pixel dentro del byte:+ Esta rutina de 128 t-estados nos devuelve el valor de la dirección calculado en HL y la posición relativa del pixel dentro del byte:
  
 |< 50% >| |< 50% >|
 ^ Valor de A ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ^ 1 ^ 0 ^ ^ Valor de A ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ^ 1 ^ 0 ^
-| Posición del pixel\\ desde la izquierda | +7 | +6 | +5 | +4 | +3 | +2 | +1 | +0 |+| Posición del pixel\\ desde la izquierda | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
 | Posición del pixel\\ dentro del byte (Bit) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | | Posición del pixel\\ dentro del byte (Bit) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
  
Línea 976: Línea 952:
  Por otra parte, si necesitamos activar (PLOT, bit=1), desactivar (UNPLOT, b=0) o testear el estado del pixel (x,y), podremos utilizar este valor "**posición del pixel**" para generar una **máscara de pixel**.  Por otra parte, si necesitamos activar (PLOT, bit=1), desactivar (UNPLOT, b=0) o testear el estado del pixel (x,y), podremos utilizar este valor "**posición del pixel**" para generar una **máscara de pixel**.
  
 + Si queremos convertir la //posición del pixel// en una //máscara de pixel// (por ejemplo, convertir ''A=6'' en el bit 6 activo (''A=%01000000''), podemos hacerlo con un bucle:
 +
 +<code z80>
 +    and %00000111               ; and 00000111 para obtener pixel
 +                                ; A = 00000PPP, y además setear ZF si es 0
 +    ;--- Nuevo código ---
 +    
 +    ld b, a                     ; Poner en B el numero de pixel
 +    ld a, %10000000             ; Activar sólo el bit 7 de A
 +    jr z, getpixoff_norotate    ; Si el ''and %00000111' dice que A == 0
 +                                ; entonces ya no necesitamos rotar
 +getpixoff_loop:
 +    rra                         ; Rotar A a la derecha B veces
 +    djnz getpixoff_lop
 +getpixoff_norotate:
 +                                ; Ahora A es una máscara de pixel
 +    ;--- Fin nuevo código ---
 +
 +    ret
 +</code>
  
 \\  \\ 
Línea 1010: Línea 1006:
  
 <code z80> <code z80>
-    ld b, a         ; Cargamos A (posicion de pixel) en B +    ld b, a                  ; Cargamos A (posicion de pixel) en B 
-    inc b           ; Incrementamos B (para pasadas del bucle) +    inc b                    ; Incrementamos B (para pasadas del bucle) 
-    xor a           ; A = 0 +    xor a                    ; A = 0 
-    scf             ; Set Carry Flag (A=0, CF=1)+    scf                      ; Set Carry Flag (A=0, CF=1)
 pix_rotate_bit: pix_rotate_bit:
-    rra             ; Rotamos A a la derecha B veces+    rra                      ; Rotamos A a la derecha B veces
     djnz pix_rotate_bit     djnz pix_rotate_bit
 </code> </code>
Línea 1036: Línea 1032:
 ;-------------------------------------------------------- ;--------------------------------------------------------
 Relative_to_Mask: Relative_to_Mask:
-    ld b, a         ; Cargamos A (posicion de pixel) en B +    ld b, a                  ; Cargamos A (posicion de pixel) en B 
-    inc b           ; Incrementamos B (para pasadas del bucle) +    inc b                    ; Incrementamos B (para pasadas del bucle) 
-    xor a           ; A = 0 +    xor a                    ; A = 0 
-    scf             ; Set Carry Flag (A=0, CF=1)+    scf                      ; Set Carry Flag (A=0, CF=1)
 pix_rotate_bit: pix_rotate_bit:
-    rra             ; Rotamos A a la derecha B veces+    rra                      ; Rotamos A a la derecha B veces
     djnz pix_rotate_bit     djnz pix_rotate_bit
     ret     ret
Línea 1112: Línea 1108:
  
 <code z80> <code z80>
-  ld c, 127                   ; X = 127 +  ld c, 127                  ; X = 127 
-  ld b, 95                    ; Y = 95 +  ld b, 95                   ; Y = 95 
-  call Get_Pixel_Offset_HR    ; Calculamos HL y A +  call Get_Pixel_Offset_HR   ; Calculamos HL y A 
-  or (hl)                     ; OR de A y (HL) +  or (hl)                    ; OR de A y (HL) 
-  ld (hl), a                  ; Activamos pixel+  ld (hl), a                 ; Activamos pixel
 </code> </code>
  
Línea 1204: Línea 1200:
  
     ; Imprimimos un solo pixel en (0,0)     ; Imprimimos un solo pixel en (0,0)
-    ld c, 0                ; X = 0 +    ld c, 0                  ; X = 0 
-    ld b, 0                ; Y = 0 +    ld b, 0                  ; Y = 0 
-    ld a, b                ; A = Y = 0 +    ld a, b                  ; A = Y = 0 
-    call PIXEL_ADDRESS     ; HL = direccion (0,0) +    call PIXEL_ADDRESS       ; HL = direccion (0,0) 
-    ld a, 128              ; A = 10000000b (1 pixel). +    ld a, 128                ; A = 10000000b (1 pixel). 
-    ld (hl), a             ; Imprimimos el pixel+    ld (hl), a               ; Imprimimos el pixel
  
     ; Imprimimos 8 pixeles en (255,191)     ; Imprimimos 8 pixeles en (255,191)
-    ld c, 255              ; X = 255 +    ld c, 255                ; X = 255 
-    ld b, 191              ; Y = 191 +    ld b, 191                ; Y = 191 
-    ld a, b                ; A = Y = 191+    ld a, b                  ; A = Y = 191
     call PIXEL_ADDRESS     call PIXEL_ADDRESS
-    ld a, 255              ; A = 11111111b (8 pixeles)+    ld a, 255                ; A = 11111111b (8 pixeles)
     ld (hl), a     ld (hl), a
  
     ; Imprimimos 4 pixeles en el centro de la pantalla     ; Imprimimos 4 pixeles en el centro de la pantalla
-    ld c, 127              ; X = 127 +    ld c, 127                ; X = 127 
-    ld b, 95               ; Y = 95 +    ld b, 95                 ; Y = 95 
-    ld a, b                ; A = Y = 95+    ld a, b                  ; A = Y = 95
     call PIXEL_ADDRESS     call PIXEL_ADDRESS
-    ld a, 170              ; A = 10101010b (4 pixeles)+    ld a, %10101010          ; A = 10101010b (4 pixeles)
     ld (hl), a     ld (hl), a
  
-loop:                      ; Bucle para no volver a BASIC y que +loop:                        ; Bucle para no volver a BASIC y que 
-    jr loop                ; no se borren la 2 ultimas lineas+    jr loop                  ; no se borren la 2 ultimas lineas
  
     END 50000     END 50000
Línea 1250: Línea 1246:
 ;---------------------------------------------------------- ;----------------------------------------------------------
 PIXEL_ADDRESS_MASK: PIXEL_ADDRESS_MASK:
-    call PIXEL_ADDRESS   ; Llamamos a la rutina de la ROM +    call PIXEL_ADDRESS       ; Llamamos a la rutina de la ROM 
-    ld b, a              ; Cargamos A (posicion de pixel) en B +    ld b, a                  ; Cargamos A (posicion de pixel) en B 
-    inc b                ; Incrementamos B (para pasadas del bucle) +    inc b                    ; Incrementamos B (para pasadas del bucle) 
-    xor a                ; A = 0 +    xor a                    ; A = 0 
-    scf                  ; Set Carry Flag (A=0, CF=1)+    scf                      ; Set Carry Flag (A=0, CF=1)
 pix_rotate_bit: pix_rotate_bit:
-    rra                  ; Rotamos A a la derecha B veces+    rra                      ; Rotamos A a la derecha B veces
     djnz pix_rotate_bit     djnz pix_rotate_bit
     ret     ret
Línea 1274: Línea 1270:
 <code> <code>
 DIRECCION_DESTINO  = Tabla_Offsets_Linea[Y] + (X/8) DIRECCION_DESTINO  = Tabla_Offsets_Linea[Y] + (X/8)
-PIXEL_EN_DIRECCION = Resto(X/8) = X and 7+PIXEL_EN_DIRECCION = Resto(X/8) = X AND %00000111
 </code> </code>
  
Línea 1380: Línea 1376:
     ld (hl), e     ld (hl), e
     inc l     inc l
-    ld (hl), d           ; Guardamos en (HL) (tabla) +    ld (hl), d               ; Guardamos en (HL) (tabla) 
-    inc hl               ; el valor de DE (offset)+    inc hl                   ; el valor de DE (offset)
  
     ; Recorremos los scanlines y bloques en un bucle generando las     ; Recorremos los scanlines y bloques en un bucle generando las
Línea 1388: Línea 1384:
     inc d     inc d
     ld a, d     ld a, d
-    and 7+    and %00000111
     jr nz, genscan_nextline     jr nz, genscan_nextline
     ld a, e     ld a, e
Línea 1419: Línea 1415:
 ;------------------------------------------------------------- ;-------------------------------------------------------------
 Get_Pixel_Offset_LUT_HR: Get_Pixel_Offset_LUT_HR:
-    ld de, Scanline_Offsets   ; Direccion de nuestra LUT +    ld de, Scanline_Offsets  ; Direccion de nuestra LUT 
-    ld l, b                   ; L = Y+    ld l, b                  ; L = Y
     ld h, 0     ld h, 0
-    add hl, hl                ; HL = HL * 2 = Y * 2 +    add hl, hl               ; HL = HL * 2 = Y * 2 
-    add hl, de                ; HL = (Y*2) + ScanLine_Offset +    add hl, de               ; HL = (Y*2) + ScanLine_Offset 
-                              ; Ahora Offset = [HL] +                             ; Ahora Offset = [HL] 
-    ld a, (hl)                ; Cogemos el valor bajo de la direccion en A+    ld a, (hl)               ; Cogemos el valor bajo de la direccion en A
     inc l     inc l
-    ld h, (hl)                ; Cogemos el valor alto de la direccion en H +    ld h, (hl)               ; Cogemos el valor alto de la direccion en H 
-    ld l, a                   ; HL es ahora Direccion(0,Y) +    ld l, a                  ; HL es ahora Direccion(0,Y) 
-                              ; Ahora sumamos la X, para lo cual calculamos CCCCC +                             ; Ahora sumamos la X, para lo cual calculamos CCCCC 
-    ld a, c                   ; Calculamos columna+    ld a, c                  ; Calculamos columna
     rra     rra
     rra     rra
-    rra                       ; A = A>>3 = ???CCCCCb +    rra                      ; A = A>>3 = ???CCCCCb 
-    and 31                    ; A = 000CCCCB +    and %00011111            ; A = 000CCCCB 
-    add a, l                  ; HL = HL + C+    add a, l                 ; HL = HL + C
     ld l, a     ld l, a
-    ld a, c                   ; Recuperamos la coordenada (X) +    ld a, c                  ; Recuperamos la coordenada (X) 
-    and 7                     ; A = Posicion relativa del pixel +    and %00000111            ; A = Posicion relativa del pixel 
-    ret                       ; HL = direccion destino+    ret                      ; HL = direccion destino
 </code> </code>
  
Línea 1454: Línea 1450:
  
 loop_draw: loop_draw:
-    push bc                ; Preservamos B (por el bucle)+    push bc                  ; Preservamos B (por el bucle)
  
-    ld c, 127              ; X = 127, Y = B+    ld c, 127                ; X = 127, Y = B
  
     call Get_Pixel_Offset_LUT_HR     call Get_Pixel_Offset_LUT_HR
  
-    ld a, 128 +    ld a, %10000000          ; 1 pixel en la parte izquierda del byte 
-    ld (hl), a             ; Imprimimos el pixel+    ld (hl), a               ; Imprimimos el pixel
  
     pop bc     pop bc
     djnz loop_draw     djnz loop_draw
  
-loop:                      ; Bucle para no volver a BASIC y que +loop:                        ; Bucle para no volver a BASIC y que 
-    jr loop                ; no se borren la 2 ultimas lineas+    jr loop                  ; no se borren la 2 ultimas lineas
  
     END 50000     END 50000
Línea 1529: Línea 1525:
  
 genscan_loop: genscan_loop:
-    ld (hl), e        ; Escribimos parte baja +    ld (hl), e               ; Escribimos parte baja 
-    inc h             ; Saltamos a tabla de partes altas +    inc h                    ; Saltamos a tabla de partes altas 
-    ld (hl), d        ; Escribimos parte alta +    ld (hl), d               ; Escribimos parte alta 
-    dec h             ; Volvemos a tabla de partes bajas +    dec h                    ; Volvemos a tabla de partes bajas 
-    inc l             ; Siguiente valor+    inc l                    ; Siguiente valor
  
     ; Recorremos los scanlines y bloques en un bucle generando las     ; Recorremos los scanlines y bloques en un bucle generando las
Línea 1540: Línea 1536:
     inc d     inc d
     ld a, d     ld a, d
-    and 7+    and %00000111
     jr nz, genscan_nextline     jr nz, genscan_nextline
     ld a, e     ld a, e
Línea 1571: Línea 1567:
  
 <code> <code>
-; Macro de alineacion para PASMO +    ; Macro de alineacion para PASMO 
-align   macro value+    align   macro value
        if $ mod value        if $ mod value
        ds value - ($ mod value)        ds value - ($ mod value)
Línea 1578: Línea 1574:
        endm        endm
  
-align 256+    align 256
  
 Scanline_Offsets: Scanline_Offsets:
Línea 1635: Línea 1631:
 ;------------------------------------------------------------- ;-------------------------------------------------------------
 Get_Pixel_Offset_LUT_2: Get_Pixel_Offset_LUT_2:
-    ld a, c                     ; Ponemos en A la X+    ld a, c                       ; Ponemos en A la X
     rra     rra
     rra     rra
-    rra                         ; A = ???CCCCC +    rra                           ; A = ???CCCCC 
-    and 31                      ; A = 000CCCCCb +    and %00011111                 ; A = 000CCCCCb 
-    ld l, b                     ; B = coordenada Y +    ld l, b                       ; B = coordenada Y 
-    ld h, Scanline_Offsets/256  ; Parte alta de la dir de tabla +    ld h, Scanline_Offsets/256    ; Parte alta de la dir de tabla 
-    add a, (hl)                 ; A = columna + tabla_baja[linea] +    add a, (hl)                   ; A = columna + tabla_baja[linea] 
-    inc h                       ; saltamos a la siguiente tabla +    inc h                         ; saltamos a la siguiente tabla 
-    ld h, (hl)                  ; cargamos en H la parte alta +    ld h, (hl)                    ; cargamos en H la parte alta 
-    ld l, a                     ; cargamos en L la parte baja +    ld l, a                       ; cargamos en L la parte baja 
-    ld a, c                     ; Recuperamos la coordenada (X) +    ld a, c                       ; Recuperamos la coordenada (X) 
-    and 7                       ; A = Posicion relativa del pixel+    and %00000111                 ; A = Posicion relativa del pixel
     ret     ret
 </code> </code>
Línea 1696: Línea 1692:
  
 Pixel_Izquierda_HL_Mask: Pixel_Izquierda_HL_Mask:
-    rlc a            ; Rotamos A a la izquierda +    rlc a                    ; Rotamos A a la izquierda 
-    ret nc           ; Si no se activa el carry flag, volvemos +    ret nc                   ; Si no se activa el carry flag, volvemos 
-    dec l            ; Si se activa, hemos pasado de 10000000b +    dec l                    ; Si se activa, hemos pasado de 10000000b 
-    ret              ; a 00000001b y ya podemos alterar HL+    ret                      ; a 00000001b y ya podemos alterar HL
  
 Pixel_Derecha_HL_Mask: Pixel_Derecha_HL_Mask:
-    rrc a            ; Rotamos A a la derecha +    rrc a                    ; Rotamos A a la derecha 
-    ret nc           ; Si no se activa el carry flag, volvemos +    ret nc                   ; Si no se activa el carry flag, volvemos 
-    inc l            ; Si se activa, hemos pasado de 00000001b +    inc l                    ; Si se activa, hemos pasado de 00000001b 
-    ret              ; a 10000000b y ya podemos alterar HL+    ret                      ; a 10000000b y ya podemos alterar HL
 </code> </code>
  
Línea 1719: Línea 1715:
  
 Pixel_Derecha_HL_Rel: Pixel_Derecha_HL_Rel:
-    inc a            ; Incrementamos A +    inc a                    ; Incrementamos A 
-    and 7            ; Si A=8 -> A=0 +    and %00000111            ; Si A=8 -> A=0 
-    ret nz           ; Si no es cero, hemos acabado +    ret nz                   ; Si no es cero, hemos acabado 
-    inc l            ; Si se activa, hemos pasado al byte +    inc l                    ; Si se activa, hemos pasado al byte 
-    ret              ; siguiente -> alterar HL+    ret                      ; siguiente -> alterar HL
  
 Pixel_Izquierda_HL_Rel: Pixel_Izquierda_HL_Rel:
-    dec a            ; Decrementamos A +    dec a                    ; Decrementamos A 
-    ret p            ; Si no hay overflow (A de 0 a 255), fin +    ret p                    ; Si no hay overflow (A de 0 a 255), fin 
-    and 7            ; 11111111b -> 00000111b +    and %00000111            ; 11111111b -> 00000111b 
-    dec l            ; Hemos pasado al byte siguiente -> +    dec l                    ; Hemos pasado al byte siguiente -> 
-    ret              ; alteramos HL+    ret                      ; alteramos HL
 </code> </code>
  
Línea 1751: Línea 1747:
 <code z80> <code z80>
 ; Avanzamos HL 1 scanline: ; Avanzamos HL 1 scanline:
-    inc h                       ; Incrementamos HL en 256 (siguiente scanline) +    inc h                    ; Incrementamos HL en 256 (siguiente scanline) 
-    ld a, h                     ; Cargamos H en A +    ld a, h                  ; Cargamos H en A 
-    and 7                       ; Si despues del inc h los 3 bits son 0, +    and %00000111            ; Si despues del inc h los 3 bits son 0, 
-                                ; es porque era 111b y ahora 1000b. +                             ; es porque era 111b y ahora 1000b. 
-    jr nz, nofix_abajop         ; Si no es cero, hemos acabado (solo inc h). +    jr nz, nofix_abajop      ; Si no es cero, hemos acabado (solo inc h). 
-    ld a, l                     ; Es cero, hemos pasado del scanline 7 de un +    ld a, l                  ; Es cero, hemos pasado del scanline 7 de un 
-                                ; caracter al 0 del siguiente: ajustar NNN +                             ; caracter al 0 del siguiente: ajustar NNN 
-    add a, 32                   ; Ajustamos NNN (caracter dentro de tercio += 1) +    add a, %00100000         ; Ajustamos NNN (caracter dentro de tercio += 1) 
-    ld l, a                     ; Ahora hacemos la comprobacion de salto de tercio +    ld l, a                  ; Ahora hacemos la comprobacion de salto de tercio 
-    jr c, nofix_abajop          ; Si esta suma produce acarreo, habria que ajustar +    jr c, nofix_abajop       ; Si esta suma produce acarreo, habria que ajustar 
-                                ; tercio, pero ya lo hizo el inc h (111b -> 1000b) +                             ; tercio, pero ya lo hizo el inc h (111b -> 1000b) 
-    ld a, h                     ; Si no produce acarreo, no hay que ajustar +    ld a, h                  ; Si no produce acarreo, no hay que ajustar 
-    sub 8                       ; tercio, por lo que restamos el bit TT que sumo +    sub %00001000            ; tercio, por lo que restamos el bit TT que sumo 
-    ld h, a                     ; el inc h inicial.+    ld h, a                  ; el inc h inicial.
  
 nofix_abajop: nofix_abajop:
Línea 1775: Línea 1771:
 <code z80> <code z80>
     ld a, h     ld a, h
-    and 7                       ; Comprobamos scanline +    and %00000111            ; Comprobamos scanline 
-    jr z, Anterior_SL_DEC       ; Si es cero, hay salto de caracter +    jr z, Anterior_SL_DEC    ; Si es cero, hay salto de caracter 
-    dec h                       ; No es cero, basta HL = HL - 256 +    dec h                    ; No es cero, basta HL = HL - 256 
-    ret                         ; Hemos acabado (solo inc h). +    ret                      ; Hemos acabado (solo inc h). 
-Anterior_SL_DEC:               ; Hay que ir de caracter 000b a 111b +Anterior_SL_DEC:             ; Hay que ir de caracter 000b a 111b 
-    dec h                       ; Decrementamos H +    dec h                    ; Decrementamos H 
-    ld a, l                     ; Ajustamos NNN (caracter en tercio -=1) +    ld a, l                  ; Ajustamos NNN (caracter en tercio -=1) 
-    sub 32+    sub %00100000            ; -32
     ld l, a     ld l, a
-    ret c                       ; Si se produjo carry, no hay que ajustar +    ret c                    ; Si se produjo carry, no hay que ajustar 
-    ld a, h                     ; Se produjo carry, ajustamos el tercio +    ld a, h                  ; Se produjo carry, ajustamos el tercio 
-    add a, 8                    ; por el dec h inicial.+    add a, %00001000         ; por el dec h inicial. (+8)
     ld h, a     ld h, a
 </code> </code>
Línea 1807: Línea 1803:
     inc h     inc h
     ld a, h     ld a, h
-    and 7+    and %00000111
     ret nz     ret nz
     ld a, l     ld a, l
-    add a, 32+    add a, %00100000         ; +32
     ld l, a     ld l, a
     ret c     ret c
     ld a, h     ld a, h
-    sub 8+    sub %00001000            ; -8
     ld h, a     ld h, a
-    ret             ; Devolvemos en HL el valor ajustado+    ret                      ; Devolvemos en HL el valor ajustado
 </code> </code>
  
Línea 1836: Línea 1832:
     ld a, h     ld a, h
     dec h     dec h
-    and 7+    and %00000111
     ret nz     ret nz
-    ld a, 8+    ld a, %00001000          ; A = 8
     add a, h     add a, h
     ld h, a     ld h, a
     ld a, l     ld a, l
-    sub 32+    sub %00100000            ; -32
     ld l, a     ld l, a
     ret nc     ret nc
     ld a, h     ld a, h
-    sub 8+    sub %00001000            ; -8
     ld h, a     ld h, a
-    ret             ; Devolvemos en HL el valor ajustado+    ret                      ; Devolvemos en HL el valor ajustado
 </code> </code>
  
Línea 1876: Línea 1872:
     rrca     rrca
     rrca     rrca
-    and 3 +    and %00000011 
-    or $58+    or %01011000
     ld d, a     ld d, a
     ld e, l     ld e, l
Línea 1894: Línea 1890:
 Image_Offset_From_Attr: Image_Offset_From_Attr:
     ld a, h     ld a, h
-    and 3+    and %00000011
     rlca     rlca
     rlca     rlca
     rlca     rlca
-    or $40+    or %01000000
     ld d, a     ld d, a
     ld e, l     ld e, l
Línea 1917: Línea 1913:
 Get_Char_Data: Get_Char_Data:
     ld a, b     ld a, b
-    and $18+    and %00011000
     ld h, a     ld h, a
     set 6, h     set 6, h
Línea 1923: Línea 1919:
     rrca     rrca
     rrca     rrca
-    or $58+    or %01011000
     ld d, a     ld d, a
     ld a, b     ld a, b
-    and 7+    and %00000111
     rrca     rrca
     rrca     rrca
Línea 1938: Línea 1934:
  
  Llamando a la anterior rutina con unas coordenadas (c,f) en C y B obtenemos la dirección de memoria de imagen (HL) y de atributo (DE) de dicho carácter, así como el valor del atributo en sí mismo (A).  Llamando a la anterior rutina con unas coordenadas (c,f) en C y B obtenemos la dirección de memoria de imagen (HL) y de atributo (DE) de dicho carácter, así como el valor del atributo en sí mismo (A).
 +
 +\\ 
 +===== Optimizaciones para Get_Pixel_Offset_HR =====
 +
 + En ocasiones se puede reescribir una rutina de otra forma para ser ligeramente más eficiente, y las rutinas relacionadas con los gráficos (tanto "dibujar" gráficos como calcular la posición de dibujado) es una firma candidata a optimizarla todo lo posible.
 +
 +\\ //Dean Belfield//, en su página //L Break Into Program// nos proporciona la siguiente rutina optimizada para obtener la dirección de memoria de un pixel dadas su coordenadas (x,y) que requiere 117 t-estados, a costa de no devolvernos la posición relativa del pixel:
 +
 +\\ 
 +<code z80>
 +; Get screen address - by Dean Belfield
 +;
 +;  B = Y pixel position
 +;  C = X pixel position
 +;  Returns address in HL
 +Get_Pixel_Address:
 +    ld a, b                  ; Calculate Y2,Y1,Y0
 +    and %00000111            ; Mask out unwanted bits
 +    or %01000000             ; Set base address of screen
 +    ld h, a                  ; Store in H
 +    ld a, b                  ; Calculate Y7,Y6
 +    rra                      ; Shift to position
 +    rra
 +    rra
 +    and %00011000            ; Mask out unwanted bits
 +    or h                     ; OR with Y2,Y1,Y0
 +    ld h, a                  ; Store in H
 +    ld a, b                  ; Calculate Y5,Y4,Y3
 +    rla                      ; Shift to position
 +    rla
 +    and %11100000            ; Mask out unwanted bits
 +    ld l, a                  ; Store in L
 +    ld a, c                  ; Calculate X4,X3,X2,X1,X0
 +    rra                      ; Shift into position
 +    rra
 +    rra
 +    and %00011111            ; Mask out unwanted bits
 +    or l                     ; OR with Y5,Y4,Y3
 +    ld l, a                  ; Store in L
 +    ret
 +</code>
 +
 +Finalmente, //David Black// en su web //Overtaken by events// nos ofrece la siguiente rutina de 105 t-estados y 26 bytes:
 +
 +\\ 
 +<code z80>
 +; Get screen address - by David Black
 +;  B = Y pixel position
 +;  C = X pixel position
 +; Returns address in HL
 +Get_Screen_Address:
 +    ld a,b                  ; Work on the upper byte of the address
 +    and %00000111                ; a = Y2 Y1 y0
 +    or %01000000                 ; first three bits are always 010
 +    ld h,a                  ; store in h
 +    ld a,b                  ; get bits Y7, Y6
 +    rra                  ; move them into place
 +    rra
 +    rra
 +    and %00011000                ; mask off
 +    or h                  ; a = 0 1 0 Y7 Y6 Y2 Y1 Y0
 +    ld h,a                  ; calculation of h is now complete
 +    ld a,b                  ; get y
 +    rla
 +    rla
 +    and %11100000                ; a = y5 y4 y3 0 0 0 0 0
 +    ld l,a                  ; store in l
 +    ld a,c
 +    and %00011111                ; a = X4 X3 X2 X1
 +    or l                  ; a = Y5 Y4 Y3 X4 X3 X2 X1
 +    ld l,a                  ; calculation of l is complete
 +    ret
 +</code>
 +
 +Utilizando tablas, en esta misma web podemos ver las siguientes 2 aproximaciones de //Patrick Prendergast// en base a organizar los datos en memoria alineándolos de una forma que "desperdiciamos" memoria a cambio de que las rutinas sean más rápidas por cómo están alineados esos datos:
 +
 +<code z80>
 +; Store the LUT table in the format "y5 y4 y3 y7 y6 y2 y1 y0"
 +; Lower 5 bits where you need them for y and upper 3 bits to mask
 +; out to OR with X (which are replaced with 010 anyway).
 +; This way you'd only need 192 bytes for the table, which could be
 +; page-aligned for speed. You'd be looking at 69 cycles por request
 +; and 16 + 192 for the code + table.
 +;
 +; By Patrick Prendergast.
 +
 +; b = y, c = x
 +getScreenAddress:
 +    ld h,tbl >> 8
 +    ld l,b
 +    ld h,(hl)
 +    ld a,%11100000
 +    and h
 +    or c
 +    ld l,a
 +    ld a,%00011111
 +    and h
 +    or %01000000
 +    ld h,a
 +    ret
 +
 +tbl: ; y5 y4 y3 y7 y6 y2 y1 y0
 +    .db 0,1,2,3,4,5,6,7,32,33...
 +    
 +
 +; Option 2: if you are willing to [potentially] sacrifice
 +; some space for speed, you can divide the table so that
 +; you have the low and high bytes of your address list in
 +; 2 independent tables and have them both page aligned -
 +; with the low byte first in memory.
 +; This would completely remove to need to calc y*2 to get
 +; to your table offset.
 +; This would require 64 bytes of padding after the 1st table
 +; (due to both tables being page aligned) meaning you would
 +; need 448 bytes all up. That being said the 64 bytes of
 +; padding space is not needed so you can include any other
 +; data you might need there so it's not wasted.
 +; Then you would only need 47 cycles to lookup your address!
 +;
 +; By Patrick Prendergast.
 +
 +; b = y, c = x
 +getScreenAddress:
 +    ld h,tblLow >> 8
 +    ld l,b
 +    ld a,(hl)
 +    inc h
 +    ld h,(hl)
 +    or c
 +    ld l,a
 +    ret
 +
 +    ALIGN 256
 +tblLow: ; (ADDR & 0xFF)
 +    .db 0,0,0,0,0,0,0,0,32,32,32...
 +
 +    ALIGN 256
 +tblHigh: ; (ADDR >> 8)
 +    .db 64,65,66,67,68,69,70,71,64,65,66...
 +</code>
 +
 +Estas rutinas son realmente rápidas, teniendo la segunda un coste de sólo 47 t-estados por cálculo de dirección, a costa de ocupar más espacio por separar la parte alta y la parte baja de la tabla precalculada, y alinearlas en memoria en un múltiplo de 256 para evitar cálculos.
  
 \\  \\ 
Línea 1956: Línea 2094:
   * [[http://www.worldofspectrum.org/faq/reference/z80reference.htm|Z80 Reference de WOS]].   * [[http://www.worldofspectrum.org/faq/reference/z80reference.htm|Z80 Reference de WOS]].
   * [[http://www.speccy.org/trastero/cosas/Fichas/fichas.htm|Microfichas de CM de MicroHobby]].   * [[http://www.speccy.org/trastero/cosas/Fichas/fichas.htm|Microfichas de CM de MicroHobby]].
 +  * [[https://www.overtakenbyevents.com/lets-talk-about-the-zx-specrum-screen-layout-part-three/|Overtaken by Events - the screen layout (III)]].
  
 \\  \\ 
 **[ [[.:indice|⬉]] | [[.:gfx1_vram|⬅]] | [[.:gfx3_sprites_lowres|➡]] ]** **[ [[.:indice|⬉]] | [[.:gfx1_vram|⬅]] | [[.:gfx3_sprites_lowres|➡]] ]**
  
  • cursos/ensamblador/gfx2_direccionamiento.1705652238.txt.gz
  • Última modificación: 19-01-2024 08:17
  • por sromero