;**********************************************************;
;*  FRAXZ.ASM -- Extremely fast fractal program for the   *;
;* Mandelbrot and Julia Sets, and only 1311 bytes (1.3K)! *;
;*  (This is the same as FRAX except it allows zooming)   *;
;*       Uses the diagonal interpolation algorithm.       *;
;*           Requires 386, VGA, color monitor.            *;
;**********************************************************;

Ideal

TIMES           = 5                     ;Interpolation level, can be 1-6
                                        ;5 or 6 is fastest (7 won't work)

MAXZOOM         = 3

LEFT            = 4Bh
RIGHT           = 4Dh
UP              = 48h
DOWN            = 50h
HOME            = 47h
SPACE           = 39h
ESCAPE          = 01h
PGUP            = 49h
PGDN            = 51h
RETURN          = 1Ch

Model Tiny
CodeSeg
P386
Org 100h

Proc            Program

                mov ax,cs               ;Point FS to offscreen buffer
                add ax,1000h
                mov fs,ax
                push 0A000h             ;Point ES to video memory
                pop es
                mov ax,13h              ;Change video mode
                int 10h                 ;to 320x200
                jmp GoCenter            ;Center screen and redraw

KeyLoop:        xor ah,ah               ;Wait for a key
                int 16h
                cmp ah,LEFT             ;Left?
                je GoLeft
                cmp ah,RIGHT            ;Right?
                je GoRight
                cmp ah,UP               ;Up?
                je GoUp
                cmp ah,DOWN             ;Down?
                je GoDown
                cmp ah,SPACE            ;Space?
                je Toggle
                cmp ah,ESCAPE           ;Escape?
                je Quit
                cmp ah,PGUP             ;PgUp?
                je ZoomIn
                cmp ah,PGDN             ;PgDn?
                je ZoomOut
                cmp ah,HOME             ;Home?
                jne KeyLoop

GoCenter:       xor eax,eax             ;Re-center screen
                mov [dword RowOffset],eax
                jmp ReDraw              ;Redraw fractal

GoLeft:         sub [ColOffset],160     ;Move left 1/2 screen
                jmp ReDraw              ;Redraw fractal

GoRight:        add [ColOffset],160     ;Move right 1/2 screen
                jmp ReDraw              ;Redraw fractal

GoUp:           sub [RowOffset],100     ;Move up 1/2 screen
                jmp ReDraw              ;Redraw fractal

GoDown:         add [RowOffset],100     ;Move down 1/2 screen
                jmp ReDraw              ;Redraw fractal

ZoomIn:         cmp [Zoom],MAXZOOM      ;Already in?
                je KeyLoop              ;If so, ignore
                inc [Zoom]              ;Zoom in
                cmp [Zoom],1
                je ZIskip
                sal [PLimit],1
                sal [NLimit],1
ZIskip:         sub [RowOffset],50
                sub [ColOffset],80
                sal [RowOffset],1
                sal [ColOffset],1
                jmp ReDraw              ;Redraw fractal

ZoomOut:        cmp [Zoom],0            ;Already out?
                je KeyLoop              ;If so, ignore
                dec [Zoom]              ;Zoom out
                cmp [Zoom],0
                je ZOskip
                sar [PLimit],1
                sar [NLimit],1
ZOskip:         sar [RowOffset],1
                sar [ColOffset],1
                add [RowOffset],50
                add [ColOffset],80
                jmp ReDraw              ;Redraw fractal

Toggle:         cmp [Mode],0            ;Julia mode?
                jne ToMandel

                cmp [Zoom],1            ;Only works with zoom 1
                jne KeyLoop

                call GetPos             ;Switch to julia mode
                test al,al              ;If AL = 1, cancel
                jne KeyLoop
                mov [Mode],1
                mov eax,[dword RowOffset]
                mov [dword SaveRow],eax
                jmp GoCenter            ;Center picture

ToMandel:       mov [Mode],0            ;Switch to mandel mode
                mov [Zoom],1
                mov [PLimit],512
                mov [NLimit],-512
                mov eax,[dword SaveRow]
                mov [dword RowOffset],eax
                jmp ReDraw              ;Redraw

Quit:           cmp [Mode],1            ;If in julia mode,
                je ToMandel             ;change back to mandel mode.
                mov ax,3                ;Switch to text mode
                int 10h
                ret

ReDraw:         mov [Dist],(1 shl (TIMES - 1))  ;Initialize vars
                mov [Incr],(1 shl TIMES)
                mov [IncrM],((1 shl TIMES) - 1)
                mov [LDist],((1 shl (TIMES - 1)) * 320)
                mov [LDist2],((1 shl (TIMES - 1)) * 640)
                mov cl,[Zoom]

                xor si,si               ;Zero SI
                xor di,di               ;Zero DI

                cmp [Mode],1            ;If julia, call DrawJ,
                je IsJulia              ;otherwise call DrawM.
                call DrawM              ;Then jump to keyloop.
                jmp KeyLoop
IsJulia:        call DrawJ
                jmp KeyLoop

EndP            Program

;**************************** GetPos -- Get julia coordinates

Proc            GetPos

                mov [dword CurX],6400A0h;Start at middle of screen

gKeyLoop:       call ShowCursor         ;Show cursor
                xor ah,ah               ;Wait for a key
                int 16h
                call HideCursor         ;Hide cursor
                cmp ah,LEFT             ;Left?
                je gLeft
                cmp ah,RIGHT            ;Right?
                je gRight
                cmp ah,UP               ;Up?
                je gUp
                cmp ah,DOWN             ;Down?
                je gDown
                cmp ah,ESCAPE           ;Escape?
                je gCancel
                cmp ah,RETURN           ;Enter?
                jne gKeyLoop

                mov ax,320              ;X = 320 - ColOffset - CurY
                sub ax,[ColOffset]
                sub ax,[CurX]
                cwde
                sal eax,8
                mov [JuliaX],eax

                mov ax,200              ;Y = 200 - RowOffset - CurX
                sub ax,[RowOffset]
                sub ax,[CurY]
                cwde
                sal eax,8
                mov [JuliaY],eax

                xor al,al               ;Return 0
                ret

gCancel:        mov al,1                ;Return 1 (Cancel)
                ret

gUp:            cmp [CurY],0            ;If not at the top,
                je $+6                  ;decrement cursor Y
                dec [CurY]
                jmp gKeyLoop

gDown:          cmp [CurY],199          ;If not at the bottom,
                je $+6                  ;increment cursor Y
                inc [CurY]
                jmp gKeyLoop

gLeft:          cmp [CurX],0            ;If not at the left,
                je $+6                  ;decrement cursor X
                dec [CurX]
                jmp gKeyLoop

gRight:         cmp [CurX],319          ;If not at the right,
                je $+6                  ;increment cursor X
                inc [CurX]
                jmp gKeyLoop

EndP            GetPos

;**************************** ShowCursor -- Show the cursor

Proc            ShowCursor

                pusha                   ;Save registers

                mov bx,[CurX]           ;Calculate offset
                mov cx,[CurY]
                add bh,cl
                shl cx,6
                add bx,cx

                mov ax,[fs:bx-2]        ;Save screen data
                mov [word SaveBuf],ax
                mov ax,[fs:bx+1]
                mov [word SaveBuf+2],ax
                mov al,[fs:bx-640]
                mov [SaveBuf+4],al
                mov al,[fs:bx-320]
                mov [SaveBuf+5],al
                mov al,[fs:bx+320]
                mov [SaveBuf+6],al
                mov al,[fs:bx+640]
                mov [SaveBuf+7],al

                mov ax,0F0Fh            ;Plot cursor
                mov [es:bx-2],ax
                mov [fs:bx-2],ax
                mov [es:bx+1],ax
                mov [fs:bx+1],ax
                mov [es:bx-640],al
                mov [fs:bx-640],al
                mov [es:bx-320],al
                mov [fs:bx-320],al
                mov [es:bx+320],al
                mov [fs:bx+320],al
                mov [es:bx+640],al
                mov [fs:bx+640],al

                popa                    ;Restore registers
                ret                     ;Return

EndP            ShowCursor

;**************************** HideCursor -- Hide the cursor

Proc            HideCursor

                pusha                   ;Save registers

                mov bx,[CurX]           ;Calculate offset
                mov cx,[CurY]
                add bh,cl
                shl cx,6
                add bx,cx

                mov ax,[word SaveBuf]   ;Restore screen data
                mov [es:bx-2],ax
                mov [fs:bx-2],ax
                mov ax,[word SaveBuf+2]
                mov [es:bx+1],ax
                mov [fs:bx+1],ax
                mov al,[SaveBuf+4]
                mov [es:bx-640],al
                mov [fs:bx-640],al
                mov al,[SaveBuf+5]
                mov [es:bx-320],al
                mov [fs:bx-320],al
                mov al,[SaveBuf+6]
                mov [es:bx+320],al
                mov [fs:bx+320],al
                mov al,[SaveBuf+7]
                mov [es:bx+640],al
                mov [fs:bx+640],al

                popa                    ;Restore registers
                ret                     ;Return

EndP            HideCursor

;**************************** DrawM -- Draw Mandelbrot Set

Proc            DrawM

                mov [RowCtr],200        ;Init row counter
CalcRow:        add si,320              ;Init column counter

CalcPixel:      call DoPixel            ;Calculate pixel

                mov ax,bp               ;Get pixel in AL
                mov [es:di],al          ;Write pixel
                mov [fs:di],al
                inc di
                add di,(1 shl TIMES)-1  ;Advance DI

                sub si,(1 shl TIMES)    ;Dec column counter
                jg CalcPixel            ;Loop back

                test di,(1 shl TIMES)-1 ;Slant off the edge?
                jnz $+5                 ;Jump if not
                add di,(1 shl TIMES)    ;Next diag. line
                dec di                  ;Slant back
                mov si,di               ;SI = -(DI AND 7)
                and si,(1 shl TIMES)-1
                neg si

                dec [RowCtr]            ;Row loop
                jnz CalcRow

FlashLoop:      mov di,[Dist]           ;DI = Distance
                mov si,[Dist]           ;SI = -Distance
                neg si
                mov [RowCtr],200        ;Init row counter
a_CalcRow:      add si,320              ;Init column counter

a_PixLoop:      mov bp,di               ;If the points directly
                add di,[Dist]           ;above, below, and to the
                mov al,[fs:di]          ;left and right are all
                sub di,[Incr]           ;the same color, plot the
                cmp al,[fs:di]          ;pixel in that color.
                jne a_CalcPixel         ;Otherwise, calculate
                add di,[Dist]           ;the pixel separately.
                sub di,[LDist]
                cmp al,[fs:di]
                jne a_CalcPixel
                add di,[LDist2]
                cmp al,[fs:di]
                mov di,bp
                je a_WrtPixel

a_CalcPixel:    mov di,bp               ;Restore DI
                call DoPixel            ;Calculate pixel

                mov ax,bp               ;Get pixel in AL
a_WrtPixel:     mov [es:di],al          ;Write pixel
                mov [fs:di],al
                inc di
                add di,[IncrM]          ;Advance DI

                sub si,[Incr]           ;Dec column counter
                jg a_PixLoop            ;Loop back

                test di,[IncrM]         ;Slant off the edge?
                jnz a_DecDI             ;Jump if not
                add di,[Incr]           ;Next diag. line
a_DecDI:        dec di                  ;Slant back
                mov si,di               ;SI = -(DI AND 7)
                and si,[IncrM]
                neg si

                dec [RowCtr]            ;Row loop
                jnz a_CalcRow

                shr [Incr],1            ;Divide all lengths by 2
                shr [IncrM],1           ;for next interpolation
                shr [LDist],1
                shr [LDist2],1          ;If it was the last one,
                shr [Dist],1            ;this will be zero, so
                jnz FlashLoop           ;JNZ to loop

                ret                     ;Return

DoPixel:        mov bp,91               ;Init color counter
                xor bx,bx               ;Init i coefficient
                xor dx,dx               ;Init j coefficient

CycleColors:    mov [Scratch],dx        ;Save j

                mov ax,bx               ;AX = i
                sub ax,dx               ;AX = i - j
                add dx,bx               ;DX = i + j
                imul dx                 ;DX:AX = (i+j)*(i-j) = i*i - j*j

                mov al,ah               ;Save middle bits
                mov ah,dl               ;(i*i - j*j)

                mov dx,[Scratch]        ;Restore j

                xchg bx,ax              ;Now swap new i with old i
                sal bx,1                ;Adjust for zoom factor
                sar bx,cl
                sub bx,si               ;Subtract column counter
                add bx,[ColOffset]      ;Add in offset

                cmp bx,[PLimit]         ;Is i >= 2 ?
                jg CPret                ;If so, draw this pixel
                cmp bx,[NLimit]         ;Is i <= -2 ?
                jl CPret                ;If so, draw this pixel

                imul dx                 ;Now DX:AX = old i * j

                mov dh,dl               ;Get middle bits in DX
                mov dl,ah
                sal dx,2                ;Adjust for zoom factor
                sar dx,cl
                sub dx,[RowCtr]         ;Add row counter
                add dx,[RowOffset]      ;Add in offset

                cmp dx,[PLimit]         ;Is j >= 2 ?
                jg CPret                ;If so, draw this pixel
                cmp dx,[NLimit]         ;Is j <= -2 ?
                jl CPret                ;If so, draw this pixel

                dec bp                  ;Dec color counter
                jnz CycleColors         ;Loop back

CPret:          ret

EndP            DrawM

;**************************** DrawJ -- Draw Julia Set

Proc            DrawJ

                mov [RowCtr],200        ;Init row counter
jCalcRow:       add si,320              ;Init column counter

jCalcPixel:     call jDoPixel           ;Calculate pixel

jDraw:          mov ax,bp               ;Get pixel in AL
                mov [es:di],al          ;Write pixel
                mov [fs:di],al
                inc di
                add di,(1 shl TIMES)-1  ;Advance DI

                sub si,(1 shl TIMES)    ;Dec column counter
                jg jCalcPixel           ;Loop back

                test di,(1 shl TIMES)-1 ;Slant off the edge?
                jnz $+5                 ;Jump if not
                add di,(1 shl TIMES)    ;Next diag. line
                dec di                  ;Slant back
                mov si,di               ;SI = -(DI AND 7)
                and si,(1 shl TIMES)-1
                neg si

                dec [RowCtr]            ;Row loop
                jnz jCalcRow

jFlashLoop:     mov di,[Dist]           ;DI = Distance
                mov si,[Dist]           ;SI = -Distance
                neg si
                mov [RowCtr],200        ;Init row counter
ja_CalcRow:     add si,320              ;Init column counter

ja_PixLoop:     mov bp,di               ;If the points directly
                add di,[Dist]           ;above, below, and to the
                mov al,[fs:di]          ;left and right are all
                sub di,[Incr]           ;the same color, plot the
                cmp al,[fs:di]          ;pixel in that color.
                jne ja_CalcPixel        ;Otherwise, calculate
                add di,[Dist]           ;the pixel separately.
                sub di,[LDist]
                cmp al,[fs:di]
                jne ja_CalcPixel
                add di,[LDist2]
                cmp al,[fs:di]
                mov di,bp
                je ja_WrtPixel

ja_CalcPixel:   mov di,bp
                call jDoPixel           ;Calculate pixel

                mov ax,bp               ;Get pixel in AL
ja_WrtPixel:    mov [es:di],al          ;Write pixel
                mov [fs:di],al
                inc di
                add di,[IncrM]          ;Advance DI

                sub si,[Incr]           ;Dec column counter
                jg ja_PixLoop           ;Loop back

                test di,[IncrM]         ;Slant off the edge?
                jnz ja_DecDI            ;Jump if not
                add di,[Incr]           ;Next diag. line
ja_DecDI:       dec di                  ;Slant back
                mov si,di               ;SI = -(DI AND 7)
                and si,[IncrM]
                neg si

                dec [RowCtr]            ;Row loop
                jnz ja_CalcRow

                shr [Incr],1            ;Divide all lengths by 2
                shr [IncrM],1           ;for next interpolation
                shr [LDist],1
                shr [LDist2],1          ;If it was the last one,
                shr [Dist],1            ;this will be zero, so
                jnz jFlashLoop          ;JNZ to loop

                ret                     ;Return

jDoPixel:       mov bp,135              ;Init color counter
                mov bx,si               ;Init i coefficient
                sub bx,[ColOffset]
                mov dx,[RowCtr]         ;Init j coefficient
                sub dx,[RowOffset]
                movsx ebx,bx            ;Shift them to 32-bit
                movsx edx,dx            ;fixed point values
                sal ebx,9
                sal edx,9
                sar ebx,cl              ;Adjust for zoom factor
                sar edx,cl

jCycleColors:   mov [dword Scratch],edx ;Save j

                mov eax,ebx             ;AX = i
                sub eax,edx             ;AX = i - j
                add edx,ebx             ;DX = i + j
                imul edx                ;DX:AX = (i+j)*(i-j) = i*i - j*j

                shrd eax,edx,16         ;Save middle bits (i*i - j*j)

                mov edx,[dword Scratch] ;Restore j

                xchg ebx,eax            ;Now swap new i with old i
                sub ebx,[JuliaX]        ;Subtract julia X parameter

                cmp ebx,[dword PLimit-1];Is i >= 2 ?
                jg jCPret               ;If so, draw this pixel
                cmp ebx,[dword NLimit-1];Is i <= -2 ?
                jl jCPret               ;If so, draw this pixel

                imul edx                ;Now EDX:EAX = old i * j

                shld edx,eax,17         ;Get middle bits in DX
                sub edx,[JuliaY]        ;Subtract julia Y parameter

                cmp edx,[dword PLimit-1];Is j >= 2 ?
                jg jCPret               ;If so, draw this pixel
                cmp edx,[dword NLimit-1];Is j <= -2 ?
                jl jCPret               ;If so, draw this pixel

                dec bp                  ;Dec color counter
                jnz jCycleColors        ;Loop back

jCPret:         ret

EndP            DrawJ

Mode            db 0                    ;Memory variables
Zoom            db 1
                db 0
PLimit          dw 512
                dw 0
NLimit          dw -512
                db -1
Scratch         dw ?,?
Dist            dw ?
Incr            dw ?
IncrM           dw ?
LDist           dw ?
LDist2          dw ?
RowOffset       dw ?
ColOffset       dw ?
CurX            dw ?
CurY            dw ?
JuliaX          dd ?
JuliaY          dd ?
SaveRow         dw ?
SaveCol         dw ?
RowCtr          dw ?
SaveBuf         db 8 dup(?)

End Program
