Drawing lines: LOIN (Part 2 of 7)

       Name: LOIN (Part 2 of 7)                                      [Show more]
       Type: Subroutine
   Category: Drawing lines
    Summary: Draw a line: Line has a shallow gradient, step right along x-axis
  Deep dive: Bresenham's line algorithm
             Drawing lines in the NES version
    Context: See this subroutine in context in the source code
 References: No direct references to this subroutine in this source file


 This routine draws a line from (X1, Y1) to (X2, Y2). It has multiple stages.
 If we get here, then:

   * |delta_y| < |delta_x|

   * The line is closer to being horizontal than vertical

   * We are going to step right along the x-axis

   * We potentially swap coordinates to make sure X1 < X2


.STPX

 LDX X1                 ; Set X = X1

 CPX X2                 ; If X1 < X2, jump down to LI3, as the coordinates are
 BCC LI3                ; already in the order that we want

 DEC SWAP               ; Otherwise decrement SWAP from 0 to $FF, to denote that
                        ; we are swapping the coordinates around (though note
                        ; that we don't use this value anywhere, as in the
                        ; original versions of Elite it is used to omit the
                        ; first pixel of each line, which we don't have to do
                        ; in the NES version as it doesn't use EOR plotting)

 LDA X2                 ; Swap the values of X1 and X2
 STA X1
 STX X2

 TAX                    ; Set X = X1

 LDA Y2                 ; Swap the values of Y1 and Y2
 LDY Y1
 STA Y1
 STY Y2

.LI3

                        ; By this point we know the line is horizontal-ish and
                        ; X1 < X2, so we're going from left to right as we go
                        ; from X1 to X2

                        ; The following section calculates:
                        ;
                        ;   Q = Q / P
                        ;     = |delta_y| / |delta_x|
                        ;
                        ; using the log tables at logL and log to calculate:
                        ;
                        ;   A = log(Q) - log(P)
                        ;     = log(|delta_y|) - log(|delta_x|)
                        ;
                        ; by first subtracting the low bytes of the logarithms
                        ; from the table at LogL, and then subtracting the high
                        ; bytes from the table at log, before applying the
                        ; antilog to get the result of the division and putting
                        ; it in Q

 LDX Q                  ; Set X = |delta_y|

 BEQ LIlog7             ; If |delta_y| = 0, jump to LIlog7 to return 0 as the
                        ; result of the division

 LDA logL,X             ; Set A = log(Q) - log(P)
 LDX P                  ;       = log(|delta_y|) - log(|delta_x|)
 SEC                    ;
 SBC logL,X             ; by first subtracting the low bytes of log(Q) - log(P)

 BMI LIlog4             ; If A > 127, jump to LIlog4

 LDX Q                  ; And then subtracting the high bytes of log(Q) - log(P)
 LDA log,X              ; so now A contains the high byte of log(Q) - log(P)
 LDX P
 SBC log,X

 BCS LIlog5             ; If the subtraction fitted into one byte and didn't
                        ; underflow, then log(Q) - log(P) < 256, so we jump to
                        ; LIlog5 to return a result of 255

 TAX                    ; Otherwise we set A to the A-th entry from the antilog
 LDA antilog,X          ; table so the result of the division is now in A

 JMP LIlog6             ; Jump to LIlog6 to return the result

.LIlog5

 LDA #255               ; The division is very close to 1, so set A to the
 BNE LIlog6             ; closest possible answer to 256, i.e. 255, and jump to
                        ; LIlog6 to return the result (this BNE is effectively a
                        ; JMP as A is never zero)

.LIlog7

 LDA #0                 ; The numerator in the division is 0, so set A to 0 and
 BEQ LIlog6             ; jump to LIlog6 to return the result (this BEQ is
                        ; effectively a JMP as A is always zero)

.LIlog4

 LDX Q                  ; Subtract the high bytes of log(Q) - log(P) so now A
 LDA log,X              ; contains the high byte of log(Q) - log(P)
 LDX P
 SBC log,X

 BCS LIlog5             ; If the subtraction fitted into one byte and didn't
                        ; underflow, then log(Q) - log(P) < 256, so we jump to
                        ; LIlog5 to return a result of 255

 TAX                    ; Otherwise we set A to the A-th entry from the
 LDA antilogODD,X       ; antilogODD so the result of the division is now in A

.LIlog6

 STA Q                  ; Store the result of the division in Q, so we have:
                        ;
                        ;   Q = |delta_y| / |delta_x|

 LDA P                  ; Set P = P + 1
 CLC                    ;      = |delta_x| + 1
 ADC #1                 ;
 STA P                  ; We will use P as the x-axis counter, and we add 1 to
                        ; ensure we include the pixel at each end

 LDY Y1                 ; If Y1 >= Y2, skip the following instruction
 CPY Y2
 BCS P%+5

 JMP DOWN               ; Y1 < Y2, so jump to DOWN, as we need to draw the line
                        ; to the right and down