;Copyright (C) 1997-2001 ZSNES Team ( zsknight@zsnes.com / _demo_@zsnes.com )
;
;This program is free software; you can redistribute it and/or
;modify it under the terms of the GNU General Public License
;as published by the Free Software Foundation; either
;version 2 of the License, or (at your option) any later
;version.
;
;This program is distributed in the hope that it will be useful,
;but WITHOUT ANY WARRANTY; without even the implied warranty of
;MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;GNU General Public License for more details.
;
;You should have received a copy of the GNU General Public License
;along with this program; if not, write to the Free Software
;Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

%include "macros.mac"

EXTSYM disableeffects,winl1,winl2,winbgdata,winr1,winr2,winspdata
EXTSYM winlogica
EXTSYM winenabm,winobjen
EXTSYM winlogicb 
EXTSYM scrndis,scrnon
EXTSYM bgmode,bgtilesz,winbg1en,winenabs
EXTSYM bg1objptr,bg1ptr,bg1ptrb,bg1ptrc,bg1ptrd,bg1scrolx,bg1scroly
EXTSYM cachebg1,curbgofs1,curcolbg1,vcache2b,vcache4b,vcache8b
EXTSYM vcache2ba,vcache4ba,vcache8ba
EXTSYM vidbuffer
EXTSYM bg3highst,cbitmode,colormodedef,colormodeofs,drawline16b
EXTSYM forceblnk,newengine8b,preparesprpr,scaddset,spritetablea
EXTSYM sprleftpr,vidbright,ForceNewGfxOff
EXTSYM curypos,drawmode7,mode7set,mosaicon,mosaicsz,sprleftpr1,sprleftpr2
EXTSYM sprleftpr3,sprlefttot,sprprifix,drawmode7extbg,interlval,drawmode7extbg2
EXTSYM sprclprio,sprpriodata,sprsingle
EXTSYM cachetile2b,cachetile4b,cachetile8b,vram,CacheCheckSkip
EXTSYM cachetile2b16x16,cachetile4b16x16,cachetile8b16x16
EXTSYM osm2dis,xtravbuf
EXTSYM bg3ptr,bg3scrolx,bg3scroly,cachesingle,colormoded2
EXTSYM tempoffset,vidmemch2,vidmemch4,vidmemch8
EXTSYM ofsmcptr,ofsmady,ofsmadx,yposng,yposngom,flipyposng,flipyposngom
EXTSYM ofsmtptr,ofsmmptr,ofsmcyps,bgtxadd,bg1ptrx,bg1ptry

NEWSYM MakeVidAsmStart

%include "video/vidmacro.mac"





;drawspritesprio

NEWSYM bgcoloradder, db 0
NEWSYM res512switch, db 0

;    mov cl,[bshifter]
;*******************************************************
; DrawLine                        Draws the current line
;*******************************************************
; use curypos+bg1scroly for y location and bg1scrolx for x location
; use bg1ptr(b,c,d) for the pointer to the tile number contents
; use bg1objptr for the pointer to the object tile contents

%macro decideonmode 0
    cmp bl,2
    je .yes4bit
    cmp bl,1
    je .yes2bit
    mov byte[bshifter],6
    mov edx,[vcache8b]
    jmp .skipbits
.yes4bit
    mov byte[bshifter],2
    mov edx,[vcache4b]
    shl eax,1
    jmp .skipbits
.yes2bit
    mov byte[bshifter],0
    shl eax,2
    mov edx,[vcache2b]
.skipbits
%endmacro

%macro procmode7 3
    xor eax,eax
    xor edx,edx
    mov ax,[curypos]
    test byte[mode7set],02h
    jz %%noflip
    mov ax,261
    sub ax,[curypos]
%%noflip
    mov byte[curmosaicsz],1
    test byte[mosaicon],%3
    jz %%nomos
    mov bl,[mosaicsz]
    cmp bl,0
    je %%nomos
    inc bl
    mov [curmosaicsz],bl
    xor edx,edx
    xor bh,bh
    div bx
    xor edx,edx
    mul bx
    xor edx,edx
    mov dl,[mosaicsz]
    add ax,[MosaicYAdder+edx*2]
%%nomos
    add ax,%1
    mov dx,%2
    call drawmode7
%endmacro

%macro procmode7extbg 3
    xor eax,eax
    xor edx,edx
    mov ax,[curypos]
    test byte[mode7set],02h
    jz %%noflip
    mov ax,261
    sub ax,[curypos]
%%noflip
    mov byte[curmosaicsz],1
    test byte[mosaicon],%3
    jz %%nomos
    mov bl,[mosaicsz]
    cmp bl,0
    je %%nomos
    inc bl
    mov [curmosaicsz],bl
    xor edx,edx
    xor bh,bh
    div bx
    xor edx,edx
    mul bx
    xor edx,edx
    mov dl,[mosaicsz]
    add ax,[MosaicYAdder+edx*2]
%%nomos
    add ax,%1
    mov dx,%2
    call drawmode7extbg
%endmacro

%macro procmode7extbg2 3
    xor eax,eax
    xor edx,edx
    mov ax,[curypos]
    test byte[mode7set],02h
    jz %%noflip
    mov ax,261
    sub ax,[curypos]
%%noflip
    mov byte[curmosaicsz],1
    test byte[mosaicon],%3
    jz %%nomos
    mov bl,[mosaicsz]
    cmp bl,0
    je %%nomos
    inc bl
    mov [curmosaicsz],bl
    xor edx,edx
    xor bh,bh
    div bx
    xor edx,edx
    mul bx
    xor edx,edx
    mov dl,[mosaicsz]
    add ax,[MosaicYAdder+edx*2]
%%nomos
    add ax,%1
    mov dx,%2
    call drawmode7extbg2
%endmacro

NEWSYM MosaicYAdder, dw 0,0,0,1,0,2,1,0,0,4,2,2,3,1,0,7

NEWSYM pwinbgenab, db 0
NEWSYM pwinbgtype, dd 0
NEWSYM winonbtype, db 0
NEWSYM dualwinbg,  db 0
NEWSYM pwinspenab, db 0
NEWSYM pwinsptype, dd 0
NEWSYM winonstype, db 0
NEWSYM dualwinsp,  db 0
NEWSYM cwinptr,    dd winbgdata
NEWSYM dwinptrproc, dd 0

; is this macro even used?
%macro ClearWindowData 0
    mov edi,winbgdata+16
    xor eax,eax
    mov ecx,64
    rep stosd
%endmacro

NEWSYM makewindow
    ; upon entry, al = win enable bits
    cmp byte[disableeffects],1
    je near .finishwin
    mov bl,al
    and bl,00001010b
    cmp bl,00001010b
    je near makedualwin
    cmp bl,0
    je near .finishwin
    mov byte[winon],1
    mov ebx,[winl1]
    ; check if data matches previous sprite data
    cmp al,[pwinspenab]
    jne .skipsprcheck
    cmp ebx,[pwinsptype]
    jne .skipsprcheck
    mov dword[cwinptr],winspdata+16
    mov al,[winonstype]
    mov [winon],al
    ret
.skipsprcheck
    ; check if data matches previous data
    cmp al,[pwinbgenab]
    jne .skipenab
    cmp ebx,[pwinbgtype]
    jne .skipenab2
    mov dword[cwinptr],winbgdata+16
    mov al,[winonbtype]
    mov [winon],al
    ret
.skipenab
    mov [pwinbgenab],al
    mov ebx,[winl1]
.skipenab2
    mov [pwinbgtype],ebx
    mov dl,[winl1]
    mov dh,[winr1]
    test al,00000010b
    jnz .win1
    mov dl,[winl2]
    mov dh,[winr2]
    shr al,2
.win1
    test al,01h
    jnz near .outside
    cmp dl,254
    je .clipped
    cmp dl,dh
    jb .clip
.clipped
    mov byte[winon],0
    mov byte[winonbtype],0
    ret
.clip
    mov edi,winbgdata+16
    xor eax,eax
    ; start drawing 1's from 0 to left
    cmp dl,0
    je .nextdot2
.nextdot
    mov byte[edi+eax],0
    inc al
    cmp al,dl
    jb .nextdot         ; blah
.nextdot2
    mov byte[edi+eax],1
    inc al
    cmp al,dh
    jb .nextdot2
    mov byte[edi+eax],1
    cmp dh,255
    je .nextdot4
    ; start drawing 1's from right to 255
.nextdot3
    mov byte[edi+eax],0
    inc al
    jnz .nextdot3
.nextdot4
    mov byte[winon],1
    mov byte[winonbtype],1
    mov dword[cwinptr],winbgdata+16
    ret
.outside
    cmp dl,dh
    jb .clip2
    mov byte[winon],0FFh
    mov byte[winonbtype],0FFh
    mov dword[cwinptr],winbgdata+16
    ret
.clip2
    cmp dl,1
    ja .nooutclip
    cmp dh,254
    jae near .clipped
.nooutclip
    mov edi,winbgdata+16
    xor eax,eax
    ; start drawing 1's from 0 to left
.nextdoti
    mov byte[edi+eax],1
    inc al
    cmp al,dl
    jb .nextdoti
.nextdot2i
    mov byte[edi+eax],0
    inc al
    cmp al,dh
    jb .nextdot2i
    mov byte[edi+eax],0
    cmp al,255
    je .nextdot4i
    inc al
    ; start drawing 1's from right to 255
.nextdot3i
    mov byte[edi+eax],1
    inc al
    jnz .nextdot3i
.nextdot4i
    mov byte[winon],1
    mov byte[winonbtype],1
    mov dword[cwinptr],winbgdata+16
    ret
.finishwin
    ret

NEWSYM makedualwin
    mov ecx,ebp
    shl cl,1
    mov dl,[winlogica]
    shr dl,cl
    and dl,03h
    mov cl,dl
    mov byte[winon],1
    mov ebx,[winl1]
    ; check if data matches previous sprite data
    cmp cl,[dualwinsp]
    jne .skipsprcheck
    cmp al,[pwinspenab]
    jne .skipsprcheck
    cmp ebx,[pwinsptype]
    jne .skipsprcheck
    mov dword[cwinptr],winspdata+16
    mov al,[winonstype]
    mov [winon],al
    ret
.skipsprcheck
    ; check if data matches previous data
    cmp cl,[dualwinbg]
    jne .skipenab3
    cmp al,[pwinbgenab]
    jne .skipenab
    cmp ebx,[pwinbgtype]
    jne .skipenab2
    mov dword[cwinptr],winbgdata+16
    mov al,[winonbtype]
    mov [winon],al
    ret
.skipenab3
    mov [dualwinbg],cl
.skipenab
    mov [pwinbgenab],al
    mov ebx,[winl1]
.skipenab2
    mov [pwinbgtype],ebx
    mov dword[dwinptrproc],winbgdata+16
    mov dword[cwinptr],winbgdata+16
    mov byte[winon],1
    mov byte[winonbtype],1

NEWSYM dualstartprocess

    mov dl,[winl1]
    mov dh,[winr1]

    push eax
    push ecx
    test al,01h
    jnz near .outside
    cmp dl,254
    je .clipped
    cmp dl,dh
    jb .clip
.clipped
    mov edi,[dwinptrproc]
    xor eax,eax
    mov ecx,64
    rep stosd
    jmp .donextwin
.clip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
    cmp dl,0
    je .nextdot2
.nextdot
    mov byte[edi+eax],0
    inc al
    cmp al,dl
    jbe .nextdot
.nextdot2
    mov byte[edi+eax],1
    inc al
    cmp al,dh
    jb .nextdot2
    mov byte[edi+eax],1
    cmp dh,255
    je .nextdot4
    ; start drawing 1's from right to 255
.nextdot3
    mov byte[edi+eax],0
    inc al
    jnz .nextdot3
.nextdot4
    jmp .donextwin
.outside
    cmp dl,dh
    jb .clip2
    mov edi,[dwinptrproc]
    mov eax,01010101h
    mov ecx,64
    rep stosd
    jmp .donextwin
.clip2
    cmp dl,1
    ja .nooutclip
    cmp dh,254
    jae near .clipped
.nooutclip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
.nextdoti
    mov byte[edi+eax],1
    inc al
    cmp al,dl
    jb .nextdoti
.nextdot2i
    mov byte[edi+eax],0
    inc al
    cmp al,dh
    jb .nextdot2i
    mov byte[edi+eax],0
    cmp al,255
    je .nextdot4i
    inc al
    ; start drawing 1's from right to 255
.nextdot3i
    mov byte[edi+eax],1
    inc al
    jnz .nextdot3i
.nextdot4i
.donextwin
    pop ecx
    pop eax
    cmp cl,0
    je near dualwinor
    cmp cl,2
    je near dualwinxor
    cmp cl,3
    je near dualwinxnor

NEWSYM dualwinand
    mov dl,[winl2]
    mov dh,[winr2]
    test al,04h
    jnz near .outside
    cmp dl,254
    je .clipped
    cmp dl,dh
    jb .clip
.clipped
    mov edi,[dwinptrproc]
    xor eax,eax
    mov ecx,64
    rep stosd
    jmp .donextwin
.clip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
    cmp dl,0
    je .nextdot2
.nextdot
    mov byte[edi+eax],0
    inc al
    cmp al,dl
    jbe .nextdot
.nextdot2
    and byte[edi+eax],1
    inc al
    cmp al,dh
    jb .nextdot2
    and byte[edi+eax],1
    cmp dh,255
    je .nextdot4
    ; start drawing 1's from right to 255
.nextdot3
    mov byte[edi+eax],0
    inc al
    jnz .nextdot3
.nextdot4
    jmp .donextwin
.outside
    cmp dl,dh
    jb .clip2
    jmp .donextwin
.clip2
    cmp dl,1
    ja .nooutclip
    cmp dh,254
    jae near .clipped
.nooutclip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
.nextdoti
    and byte[edi+eax],1
    inc al
    cmp al,dl
    jb .nextdoti
.nextdot2i
    mov byte[edi+eax],0
    inc al
    cmp al,dh
    jb .nextdot2i
    mov byte[edi+eax],0
    cmp al,255
    je .nextdot4i
    inc al
    ; start drawing 1's from right to 255
.nextdot3i
    and byte[edi+eax],1
    inc al
    jnz .nextdot3i
.nextdot4i
.donextwin
    ret

NEWSYM dualwinor
    mov dl,[winl2]
    mov dh,[winr2]
    test al,04h
    jnz near .outside
    cmp dl,254
    je .clipped
    cmp dl,dh
    jb .clip
.clipped
    jmp .donextwin
.clip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
    cmp dl,0
    je .nextdot2
    mov al,dl
    inc al
.nextdot2
    mov byte[edi+eax],1
    inc al
    cmp al,dh
    jb .nextdot2
    mov byte[edi+eax],1
    jmp .donextwin
.outside
    cmp dl,dh
    jb .clip2
    mov edi,[dwinptrproc]
    mov eax,01010101h
    mov ecx,64
    rep stosd
    jmp .donextwin
.clip2
    cmp dl,1
    ja .nooutclip
    cmp dh,254
    jae near .clipped
.nooutclip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
.nextdoti
    mov byte[edi+eax],1
    inc al
    cmp al,dl
    jb .nextdoti
    mov al,dh
    cmp al,255
    je .nextdot4i
    inc al
    ; start drawing 1's from right to 255
.nextdot3i
    mov byte[edi+eax],1
    inc al
    jnz .nextdot3i
.nextdot4i
.donextwin
    ret

NEWSYM dualwinxor
    mov dl,[winl2]
    mov dh,[winr2]
    test al,04h
    jnz near .outside
    cmp dl,254
    je .clipped
    cmp dl,dh
    jb .clip
.clipped
    jmp .donextwin
.clip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
    cmp dl,0
    je .nextdot2
    mov al,dl
    inc al
.nextdot2
    xor byte[edi+eax],1
    inc al
    cmp al,dh
    jb .nextdot2
    xor byte[edi+eax],1
    jmp .donextwin
.outside
    cmp dl,dh
    jb .clip2
    mov edi,[dwinptrproc]
    mov ecx,64
.loopxor
    xor dword[edi],01010101h
    add edi,4
    dec ecx
    jnz .loopxor
    jmp .donextwin
.clip2
    cmp dl,1
    ja .nooutclip
    cmp dh,254
    jae near .clipped
.nooutclip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
.nextdoti
    xor byte[edi+eax],1
    inc al
    cmp al,dl
    jb .nextdoti
    mov al,dh
    cmp al,255
    je .nextdot4i
    inc al
    ; start drawing 1's from right to 255
.nextdot3i
    xor byte[edi+eax],1
    inc al
    jnz .nextdot3i
.nextdot4i
.donextwin
    ret

NEWSYM dualwinxnor
    mov dl,[winl2]
    mov dh,[winr2]
    test al,04h
    jnz near .outside
    cmp dl,254
    je .clipped
    cmp dl,dh
    jb .clip
.clipped
    jmp .donextwin
.clip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
    cmp dl,0
    je .nextdot2
    mov al,dl
    inc al
.nextdot2
    xor byte[edi+eax],1
    inc al
    cmp al,dh
    jb .nextdot2
    xor byte[edi+eax],1
    jmp .donextwin
.outside
    cmp dl,dh
    jb .clip2
    mov edi,[dwinptrproc]
    mov ecx,64
.loopxor
    xor dword[edi],01010101h
    add edi,4
    dec ecx
    jnz .loopxor
    jmp .donextwin
.clip2
    cmp dl,1
    ja .nooutclip
    cmp dh,254
    jae near .clipped
.nooutclip
    mov edi,[dwinptrproc]
    xor eax,eax
    ; start drawing 1's from 0 to left
.nextdoti
    xor byte[edi+eax],1
    inc al
    cmp al,dl
    jb .nextdoti
    mov al,dh
    cmp al,255
    je .nextdot4i
    inc al
    ; start drawing 1's from right to 255
.nextdot3i
    xor byte[edi+eax],1
    inc al
    jnz .nextdot3i
.nextdot4i
.donextwin
    mov edi,[dwinptrproc]
    mov ecx,64
.loopxor2
    xor dword[edi],01010101h
    add edi,4
    dec ecx
    jnz .loopxor2
    ret

;pwinspenab db 0
;pwinsptype dd 0
;winonstype db 0
;dualwinsp  db 0
NEWSYM winonsp, db 0

NEWSYM makewindowsp
    mov al,[winobjen]
    mov byte[winonsp],0
    test dword[winenabm],1010h
    jz near .finishwin
    ; upon entry, al = win enable bits
    cmp byte[disableeffects],1
    je near .finishwin
    mov bl,al
    and bl,00001010b
    cmp bl,00001010b
    je near makedualwinsp
    cmp bl,0
    je near .finishwin
    mov byte[winonsp],1
    ; check if data matches previous data
    cmp al,[pwinspenab]
    jne .skipenab
    mov ebx,[winl1]
    cmp ebx,[pwinsptype]
    jne .skipenab2
    mov dword[cwinptr],winspdata+16
    mov al,[winonstype]
    mov [winonsp],al
    ret
.skipenab
    mov [pwinspenab],al
    mov ebx,[winl1]
.skipenab2
    mov [pwinsptype],ebx
    mov dl,[winl1]
    mov dh,[winr1]
    test al,00000010b
    jnz .win1
    mov dl,[winl2]
    mov dh,[winr2]
    shr al,2
.win1
    test al,01h
    jnz near .outside
    cmp dl,254
    je .clipped
    cmp dl,dh
    jb .clip
.clipped
    mov byte[winonsp],0
    mov byte[winonstype],0
    ret
.clip
    mov edi,winspdata+16
    xor eax,eax
    ; start drawing 1's from 0 to left
    cmp dl,0
    je .nextdot2
.nextdot
    mov byte[edi+eax],0
    inc al
    cmp al,dl
    jbe .nextdot
.nextdot2
    mov byte[edi+eax],1
    inc al
    cmp al,dh
    jb .nextdot2
    mov byte[edi+eax],1
    cmp dh,255
    je .nextdot4
    ; start drawing 1's from right to 255
.nextdot3
    mov byte[edi+eax],0
    inc al
    jnz .nextdot3
.nextdot4
    mov byte[winonsp],1
    mov byte[winonstype],1
    mov dword[cwinptr],winspdata+16
    ret
.outside
    cmp dl,dh
    jb .clip2
    mov byte[winonsp],0FFh
    mov byte[winonstype],0FFh
    mov dword[cwinptr],winspdata+16
    ret
.clip2
    cmp dl,1
    ja .nooutclip
    cmp dh,254
    jae near .clipped
.nooutclip
    mov edi,winspdata+16
    xor eax,eax
    ; start drawing 1's from 0 to left
.nextdoti
    mov byte[edi+eax],1
    inc al
    cmp al,dl
    jb .nextdoti
.nextdot2i
    mov byte[edi+eax],0
    inc al
    cmp al,dh
    jb .nextdot2i
    mov byte[edi+eax],0
    cmp al,255
    je .nextdot4i
    inc al
    ; start drawing 1's from right to 255
.nextdot3i
    mov byte[edi+eax],1
    inc al
    jnz .nextdot3i
.nextdot4i
    mov byte[winonsp],1
    mov byte[winonstype],1
    mov dword[cwinptr],winspdata+16
    ret
.finishwin
    ret

NEWSYM makedualwinsp
    mov ecx,ebp
    shl cl,1
    mov dl,[winlogicb]
    and dl,03h
    mov cl,dl
    mov byte[winonsp],1
    ; check if data matches previous data
    cmp cl,[dualwinsp]
    jne .skipenab3
    cmp al,[pwinspenab]
    jne .skipenab
    mov ebx,[winl1]
    cmp ebx,[pwinsptype]
    jne .skipenab2
    mov dword[cwinptr],winspdata+16
    mov al,[winonstype]
    mov [winonsp],al
    ret
.skipenab3
    mov [dualwinsp],cl
.skipenab
    mov [pwinspenab],al
    mov ebx,[winl1]
.skipenab2
    mov [pwinsptype],ebx
    mov dword[dwinptrproc],winspdata+16
    mov dword[cwinptr],winspdata+16
    mov byte[winonsp],1
    mov byte[winonstype],1
    jmp dualstartprocess

; window logic data
NEWSYM windowdata, times 16 db 0
NEWSYM numwin, db 0
NEWSYM multiwin, db 0
NEWSYM multiclip, db 0
NEWSYM multitype, db 0

;    jmp .finishwin
%macro procwindow 1
    cmp byte[disableeffects],1
    je near .finishwin
    mov al,%1
    test al,00001010b
    jz near .finishwin
    mov esi,windowdata
    mov bl,al
    mov byte[winon],1
    and bl,00001010b
    and al,00000101b
    mov byte[numwin],0
    cmp bl,00001010b
    je near .multiwin
    mov byte[multiwin],0
    test bl,00000010b
    jnz .win1
    mov cl,[winl2]
    mov ch,[winr2]
    shr al,2
    jmp .okaywin
.win1
    mov cl,[winl1]
    mov ch,[winr1]
    and al,01h
.okaywin
    cmp ch,255
    je .noinc
    inc ch
.noinc
    test al,01h
    jnz .wininside
    cmp cl,ch
    jae .noinsidemask
    mov [esi],cl
    mov byte[esi+1],01h
    mov [esi+2],ch
    mov byte[esi+3],0FFh
    mov byte[numwin],2
    jmp .finishwin
.noinsidemask
    mov byte[winon],0
    jmp .finishwin
.wininside
    cmp cl,ch
    ja .nooutsidemask
.nonotoutside
    cmp ch,254
    jb .skipnodraw
    cmp cl,1
    jbe .noinsidemask
.skipnodraw
    mov byte[esi],0
    mov byte[esi+1],01h
    mov byte[esi+2],cl
    mov byte[esi+3],0FFh
    mov byte[esi+4],ch
    mov byte[esi+5],01h
    mov byte[numwin],3
    jmp .finishwin
.nooutsidemask
    mov byte[esi],0
    mov byte[esi+1],01h
    mov byte[numwin],1
    jmp .finishwin
    ; **************
    ; *Multiwindows*
    ; **************
.multiwin
    mov byte[winon],0
    mov byte[multiwin],0
    mov byte[multiclip],al
    mov al,[winlogica]
    mov ecx,ebp
    shl ecx,1
    shr al,cl
    and al,3h
    mov byte[multitype],al
    mov cl,[winl1]
    mov ch,[winr1]
    mov esi,windowdata
    cmp ch,255
    je .noinc2
    inc ch
.noinc2
    test byte[multiclip],01h
    jnz .wininside2
    cmp cl,ch
    jae .nowina
    mov [esi],cl
    mov byte[esi+1],01h
    mov [esi+2],ch
    mov byte[esi+3],0FFh
    add esi,4
    mov byte[numwin],2
    jmp .secondwin
.nowina
    mov cl,[winl2]
    mov ch,[winr2]
    mov al,[multiclip]
    shr al,2
    jmp .okaywin
.wininside2
    cmp cl,ch
    ja .nooutsidemask2
    cmp ch,254
    jb .skipnodraw2
    cmp cl,1
    jbe .nooutsidemask2
.skipnodraw2
    mov byte[esi],0
    mov byte[esi+1],01h
    mov byte[esi+2],cl
    mov byte[esi+3],0FFh
    mov byte[esi+4],ch
    mov byte[esi+5],01h
    mov byte[numwin],3
    jmp .secondwin
.nooutsidemask2
    mov byte[esi],0
    mov byte[esi+1],01h
    mov byte[numwin],1
.secondwin
    mov byte[multiwin],1
    mov byte[winon],1
.finishwin
%endmacro

NEWSYM procspritessub
    test byte[scrndis],10h
    jnz .nosprites
    test byte[scrnon+1],10h
    jz .nosprites
    test byte[scrnon],10h
    jnz .nosprites
    cmp byte[winonsp],0FFh
    je .nosprites
    xor ebx,ebx
    mov bl,[curypos]
    add ebx,[cursprloc]
    mov cl,[ebx]
    cmp byte[sprprifix],0
    jne .sprprio
    add dword[cursprloc],256
.sprprio
    or cl,cl
    jz .nosprites
    call drawsprites
.nosprites
    ret

NEWSYM procspritesmain
    test byte[scrndis],10h
    jnz .nosprites
    test byte[scrnon],10h
    jz .nosprites
    cmp byte[winonsp],0FFh
    je .nosprites
    xor ebx,ebx
    mov bl,[curypos]
    add ebx,[cursprloc]
    mov cl,[ebx]
    cmp byte[sprprifix],0
    jne .sprprio
    add dword[cursprloc],256
.sprprio
    or cl,cl
    jz .nosprites
    call drawsprites
.nosprites
    ret

NEWSYM curbgnum, db 0

NEWSYM drawbackgrndsub
    mov esi,[colormodeofs]
    mov bl,[esi+ebp]
    cmp bl,0
    je near .noback
    mov al,[curbgnum]
    test byte[scrnon+1],al
    jz near .noback
    test byte[scrnon],al
    jnz near .noback
    test byte[alreadydrawn],al
    jnz near .noback
    test byte[scrndis],al
    jnz near .noback
    mov byte[winon],0
    test byte[winenabs],al
    jz near .nobackwin
;    procwindow [winbg1en+ebp]
    mov al,[winbg1en+ebp]
    call makewindow
    cmp byte[winon],0FFh
    je near .noback
.nobackwin
    mov bl,[curbgnum]
    mov byte[curmosaicsz],1
    test byte[mosaicon],bl
    jz .nomos
    mov bl,[mosaicsz]
    cmp bl,0
    je .nomos
    inc bl
    mov [curmosaicsz],bl
.nomos
    mov byte[bgcoloradder],0
    cmp byte[bgmode],0
    jne .nomode0
    mov eax,ebp
    shl eax,5
    mov byte[bgcoloradder],al
.nomode0
    mov esi,[bg1vbufloc+ebp*4]
    mov edi,[bg1tdatloc+ebp*4]
    mov edx,[bg1tdabloc+ebp*4]
    mov ebx,[bg1cachloc+ebp*4]
    mov eax,[bg1xposloc+ebp*4]
    mov cl,[curbgnum]
    test byte[bgtilesz],cl
    jnz .16x16
    mov ecx,[bg1yaddval+ebp*4]
    call draw8x8
    cmp byte[drawn],33
    jne .notalldrawn
    mov al,[curbgnum]
    or [alreadydrawn],al
.notalldrawn
    jmp .noback
.16x16
    mov ecx,[bg1yaddval+ebp*4]
    call draw16x16
    cmp byte[drawn],33
    jne .notalldrawnb
    mov al,[curbgnum]
    or [alreadydrawn],al
.notalldrawnb
.noback
    ret

NEWSYM drawbackgrndmain
    mov esi,[colormodeofs]
    mov bl,[esi+ebp]
    cmp bl,0
    je near .noback
    mov al,[curbgnum]
    test byte[scrnon],al
    jz near .noback
    test byte[alreadydrawn],al
    jnz near .noback
    test byte[scrndis],al
    jnz near .noback
    mov byte[winon],0
    test byte[winenabm],al
    jz near .nobackwin
;    procwindow [winbg1en+ebp]
    mov al,[winbg1en+ebp]
    call makewindow
    cmp byte[winon],0FFh
    je near .noback
.nobackwin
    mov bl,[curbgnum]
    mov byte[curmosaicsz],1
    test byte[mosaicon],bl
    jz .nomos
    mov bl,[mosaicsz]
    cmp bl,0
    je .nomos
    inc bl
    mov [curmosaicsz],bl
.nomos
    mov byte[bgcoloradder],0
    cmp byte[bgmode],0
    jne .nomode0
    mov eax,ebp
    shl eax,5
    mov byte[bgcoloradder],al
.nomode0
    mov esi,[bg1vbufloc+ebp*4]
    mov edi,[bg1tdatloc+ebp*4]
    mov edx,[bg1tdabloc+ebp*4]
    mov ebx,[bg1cachloc+ebp*4]
    mov eax,[bg1xposloc+ebp*4]
    mov cl,[curbgnum]
    test byte[bgtilesz],cl
    jnz .16x16
    mov ecx,[bg1yaddval+ebp*4]
    call draw8x8
    cmp byte[drawn],33
    jne .notalldrawn
    mov al,[curbgnum]
    or [alreadydrawn],al
.notalldrawn
    jmp .noback
.16x16
    mov ecx,[bg1yaddval+ebp*4]
    call draw16x16
    cmp byte[drawn],33
    jne .notalldrawnb
    mov al,[curbgnum]
    or [alreadydrawn],al
.notalldrawnb
.noback
    ret

NEWSYM procbackgrnd
    mov esi,[colormodeofs]
    mov bl,[esi+ebp]
    cmp bl,0
    je near .noback
    mov al,[curbgnum]
    mov ah,al
    test byte[scrndis],al
    jnz near .noback
    test [scrnon],ax
    jz near .noback
    push ebp
    shl ebp,6
    mov edi,cachebg1
    add edi,ebp
    pop ebp
    cmp bl,[curcolbg1+ebp]
    je .skipclearcache
    mov [curcolbg1+ebp],bl
    mov ax,[bg1ptr+ebp*2]
    mov [curbgofs1+ebp*2],ax
    call fillwithnothing
.skipclearcache
    xor eax,eax
    mov [curcolor],bl
    mov ax,[bg1objptr+ebp*2]
    decideonmode
    add edx,eax
    xor eax,eax
    mov [tempcach],edx
    xor edx,edx
    mov ax,[bg1objptr+ebp*2]
    mov [curtileptr],ax
    mov ax,[bg1ptr+ebp*2]
    mov [bgptr],ax
    cmp ax,[curbgofs1+ebp*2]
    je .skipclearcacheb
    mov [curbgofs1+ebp*2],ax
    call fillwithnothing
.skipclearcacheb
    mov ax,[bg1ptrb+ebp*2]
    mov [bgptrb],ax
    mov ax,[bg1ptrc+ebp*2]
    mov [bgptrc],ax
    mov ax,[bg1ptrd+ebp*2]
    mov [bgptrd],ax
    mov bl,[curbgnum]
    mov ax,[curypos]

    mov byte[curmosaicsz],1
    test byte[mosaicon],bl
    jz .nomos
    mov bl,[mosaicsz]
    cmp bl,0
    je .nomos
    inc bl
    mov [curmosaicsz],bl
    xor edx,edx
    xor bh,bh
    div bx
    xor edx,edx
    mul bx
    xor edx,edx
    mov dl,[mosaicsz]
    add ax,[MosaicYAdder+edx*2]
.nomos

    add ax,[bg1scroly+ebp*2]
    mov dx,[bg1scrolx+ebp*2]
    mov cl,[curbgnum]
    test byte[bgtilesz],cl
    jnz .16x16
    call proc8x8
    mov [bg1vbufloc+ebp*4],esi
    mov [bg1tdatloc+ebp*4],edi
    mov [bg1tdabloc+ebp*4],edx
    mov [bg1cachloc+ebp*4],ebx
    mov [bg1yaddval+ebp*4],ecx
    mov [bg1xposloc+ebp*4],eax
    ret
.16x16
    call proc16x16
    mov [bg1vbufloc+ebp*4],esi
    mov [bg1tdatloc+ebp*4],edi
    mov [bg1tdabloc+ebp*4],edx
    mov [bg1cachloc+ebp*4],ebx
    mov [bg1yaddval+ebp*4],ecx
    mov [bg1xposloc+ebp*4],eax
.noback
    ret

NEWSYM nextprimode, db 0
NEWSYM cursprloc,   dd 0
NEWSYM curcolor,    db 0
NEWSYM curtileptr,  dw 0
; esi = pointer to video buffer
; edi = pointer to tile data
; ebx = cached memory
; al = current x position
NEWSYM bg1vbufloc,  dd 0
NEWSYM bg2vbufloc,  dd 0
NEWSYM bg3vbufloc,  dd 0
NEWSYM bg4vbufloc,  dd 0
NEWSYM bg1tdatloc,  dd 0
NEWSYM bg2tdatloc,  dd 0
NEWSYM bg3tdatloc,  dd 0
NEWSYM bg4tdatloc,  dd 0
NEWSYM bg1tdabloc,  dd 0
NEWSYM bg2tdabloc,  dd 0
NEWSYM bg3tdabloc,  dd 0
NEWSYM bg4tdabloc,  dd 0
NEWSYM bg1cachloc,  dd 0
NEWSYM bg2cachloc,  dd 0
NEWSYM bg3cachloc,  dd 0
NEWSYM bg4cachloc,  dd 0
NEWSYM bg1yaddval,  dd 0
NEWSYM bg2yaddval,  dd 0
NEWSYM bg3yaddval,  dd 0
NEWSYM bg4yaddval,  dd 0
NEWSYM bg1xposloc,  dd 0
NEWSYM bg2xposloc,  dd 0
NEWSYM bg3xposloc,  dd 0
NEWSYM bg4xposloc,  dd 0
NEWSYM alreadydrawn, db 0

NEWSYM fillwithnothing
    push edi
    xor eax,eax
    mov ecx,16
.loop
    mov [edi],eax
    add edi,4
    dec ecx
    jnz .loop
    pop edi
    ret

NEWSYM bg3draw, db 0
NEWSYM maxbr,   db 0
NEWSYM blanker
    ; calculate current video offset
    push ebx
    push esi
    xor ebx,ebx
    mov bx,[curypos]
    mov esi,ebx
    shl esi,8
    shl ebx,5
    add esi,ebx
    add esi,16
    add esi,[vidbuffer]
    mov bl,64
.next
    mov dword[esi],0
    add esi,4
    dec bl
    jnz .next
    pop esi
    pop ebx
    ret

ALIGN32
NEWSYM bg3high2, dd 0
NEWSYM newengen, dd 0
NEWSYM cwinenabm, dd 0

NEWSYM drawline
    mov al,[winenabs]
    mov [cwinenabm],al

    mov byte[bg3high2],0
    cmp byte[bgmode],1
    jne .nohigh
    mov al,[bg3highst]
    mov [bg3high2],al
.nohigh
    cmp byte[cbitmode],1
    je near drawline16b
    mov al,[vidbright]
    cmp al,[maxbr]
    jbe .nochange
    mov [maxbr],al
.nochange
    cmp byte[ForceNewGfxOff],0
    jne .nonewgfx
    cmp byte[newengen],1
    je near newengine8b
.nonewgfx
    cmp byte[forceblnk],0
    jne near blanker
    mov byte[alreadydrawn],0
;    cmp byte[curypos],70
;    jne .no
;    push ebx
;    mov bl,[winlogica]
;    mov [bg1sx],bl
;    pop ebx
;.no
    push ebx
    xor ebx,ebx
    mov bl,[bgmode]
    shl bl,2
    add ebx,colormodedef
    mov [colormodeofs],ebx
    pop ebx

    cmp byte[bgmode],7
    je near processmode7

    mov al,[scrnon]
    test [scrnon+1],al
    jz .nomainsub
    test byte[scrnon],10h
    jnz .nomainsub
    test byte[scrnon+1],10h
    jz .nomainsub
    mov al,[scrnon+1]
    xor al,0FFh
    and [scrnon],al
.nomainsub

    push esi
    push edi
    push ebx
    push edx
    push ebp
    ; calculate current video offset
    xor ebx,ebx
    mov bx,[curypos]
    mov esi,ebx
    shl esi,8
    shl ebx,5
    add esi,ebx
    add esi,16
    add esi,[vidbuffer]
    mov [curvidoffset],esi
    ; clear video buffer
    mov edi,esi
    mov ecx,64
    xor eax,eax
    rep stosd
    ; do sprite windowing
    call makewindowsp
    ; get current sprite table
    xor ebx,ebx
    mov bl,[curypos]
    shl ebx,9
    add ebx,[spritetablea]
    mov [currentobjptr],ebx
    mov dword[cursprloc],sprleftpr
    ; setup priorities
    cmp byte[sprprifix],0
    je .nosprprio
    mov dword[cursprloc],sprlefttot
    call preparesprpr
.nosprprio
    ; clear registers
    xor eax,eax
    xor ecx,ecx
; process backgrounds
; do background 2
    mov byte[curbgnum],02h
    mov ebp,01h
    call procbackgrnd
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call procbackgrnd
; do background 4
    mov byte[curbgnum],08h
    mov ebp,03h
    call procbackgrnd
; do background 3
    mov byte[curbgnum],04h
    mov ebp,02h
    call procbackgrnd

    cmp byte[bgmode],1
    ja near priority2
    test byte[scaddset],02h
    jz near .nosubsc
; draw backgrounds
    mov byte[curbgpr],0h
; do background 4
    mov byte[curbgnum],08h
    mov ebp,03h
    call drawbackgrndsub
; do background 3
    mov byte[curbgnum],04h
    mov ebp,02h
    call drawbackgrndsub
    mov ebp,0
    call procspritessub
    mov byte[curbgpr],20h
; do background 4
    mov byte[curbgnum],08h
    mov ebp,03h
    call drawbackgrndsub
; do background 3
    cmp byte[bg3high2],1
    je .bg3nothigh
    mov byte[curbgnum],04h
    mov ebp,02h
    call drawbackgrndsub
.bg3nothigh
    mov ebp,1
    call procspritessub
; do background 2
    mov byte[curbgpr],0h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndsub
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndsub
    mov ebp,2
    call procspritessub
; do background 2
    mov byte[curbgpr],20h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndsub
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndsub
    mov ebp,3
    call procspritessub
    cmp byte[bg3high2],1
    jne .bg3high
; do background 3
    mov byte[curbgpr],20h
    mov byte[curbgnum],04h
    mov ebp,02h
    call drawbackgrndsub
.bg3high

.nosubsc
    mov al,[winenabm]
    mov [cwinenabm],al
    mov byte[curbgpr],0h

; do background 4
    mov byte[curbgnum],08h
    mov ebp,03h
    call drawbackgrndmain
; do background 3
    mov byte[curbgnum],04h
    mov ebp,02h
    call drawbackgrndmain
    mov ebp,0
    call procspritesmain
    mov byte[curbgpr],20h
; do background 4
    mov byte[curbgnum],08h
    mov ebp,03h
    call drawbackgrndmain
; do background 3
    cmp byte[bg3high2],1
    je .bg3nothighb
    mov byte[curbgnum],04h
    mov ebp,02h
    call drawbackgrndmain
.bg3nothighb
    mov ebp,1
    call procspritesmain
; do background 2
    mov byte[curbgpr],0h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndmain
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndmain
    mov ebp,2
    call procspritesmain
; do background 2
    mov byte[curbgpr],20h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndmain
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndmain
    mov ebp,3
    call procspritesmain
    cmp byte[bg3high2],1
    jne .bg3highb
; do background 3
    mov byte[curbgpr],20h
    mov byte[curbgnum],04h
    mov ebp,02h
    call drawbackgrndmain
.bg3highb
    pop ebp
    pop edx
    pop ebx
    pop edi
    pop esi
    xor eax,eax
    xor ecx,ecx
NEWSYM nodrawline
    ret

NEWSYM priority2
    test byte[scaddset],02h
    jz near .nosubsc
; do background 2
    mov byte[curbgpr],0h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndsub
    mov ebp,0
    call procspritessub
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndsub
    mov ebp,1
    call procspritessub
; do background 2
    mov byte[curbgpr],20h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndsub
    mov ebp,2
    call procspritessub
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndsub
    mov ebp,3
    call procspritessub
.nosubsc
    mov al,[winenabm]
    mov [cwinenabm],al
; do background 2
    mov byte[curbgpr],0h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndmain
    mov ebp,0
    call procspritesmain
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndmain
    mov ebp,1
    call procspritesmain
; do background 2
    mov byte[curbgpr],20h
    mov byte[curbgnum],02h
    mov ebp,01h
    call drawbackgrndmain
    mov ebp,2
    call procspritesmain
; do background 1
    mov byte[curbgnum],01h
    mov ebp,00h
    call drawbackgrndmain
    mov ebp,3
    call procspritesmain
    pop ebp
    pop edx
    pop ebx
    pop edi
    pop esi
    xor eax,eax
    xor ecx,ecx
    ret

ALIGN32
NEWSYM tempbuffer, times 33 dd 0
NEWSYM currentobjptr, dd 0
NEWSYM curmosaicsz,   dd 0
NEWSYM extbgdone, db 0


NEWSYM processmode7
    mov al,[winenabm]
    mov [cwinenabm],al
    push esi
    push edi
    push ebx
    push edx
    push ebp
    ; get current sprite table
    xor ebx,ebx
    mov bl,[curypos]
    shl ebx,9
    add ebx,[spritetablea]
    mov [currentobjptr],ebx
    ; setup priorities
    cmp byte[sprprifix],0
    je .nosprprio
    mov dword[cursprloc],sprlefttot
    call preparesprpr
.nosprprio
    ; calculate current video offset
    xor ebx,ebx
    mov bx,[curypos]
    mov esi,ebx
    shl esi,8
    shl ebx,5
    add esi,ebx
    add esi,16
    add esi,[vidbuffer]
    mov [curvidoffset],esi
    ; clear video buffer
    mov edi,esi
    mov ecx,64
    xor eax,eax
    rep stosd
    ; do sprite windowing
    call makewindowsp
    ; clear registers
    xor eax,eax
    xor ecx,ecx

    mov byte[extbgdone],0

    test byte[interlval],40h
    jz near .noback0
    test byte[scrndis],02h
    jnz near .noback0
    ; do background 1, extbg pr 0
    test word[scrnon],0202h
    jz near .noback0
    mov byte[winon],0
    test word[winenabm],0001h
    jz near .nobackwin0
    test word[winenabm],0100h
    jnz near .nobackwin0
    mov ebp,0
    mov al,[winbg1en]
    call makewindow
    cmp byte[winon],0FFh
    je near .noback0
.nobackwin0
    mov byte[extbgdone],1
    procmode7extbg [bg1scroly],[bg1scrolx],1
.noback0

    ; do objects
    test byte[scrndis],10h
    jnz near .nosprites1
    test word[scrnon],1010h
    jz near .nosprites1
    cmp byte[winonsp],0FFh
    je .nosprites1
    xor ebx,ebx
    mov bl,[curypos]
    mov cl,[sprleftpr+ebx]
    cmp byte[sprprifix],0
    je .nosprprio2
    mov cl,[sprlefttot+ebx]
.nosprprio2
    cmp cl,0
    je .nosprites1
    mov ebp,0
    call drawsprites
.nosprites1

    ; display mode7
    test byte[interlval],40h
    jnz near .noback1
    test byte[scrndis],01h
    jnz near .noback1
    ; do background 1
    test word[scrnon],0101h
    jz near .noback1
    mov byte[winon],0
    test word[winenabm],0001h
    jz near .nobackwin1
    test word[winenabm],0100h
    jnz near .nobackwin1
    mov ebp,0
    mov al,[winbg1en]
    call makewindow
    cmp byte[winon],0FFh
    je near .noback1
.nobackwin1
    procmode7 [bg1scroly],[bg1scrolx],1
.noback1

    ; do objects
    test byte[scrndis],10h
    jnz near .nosprites2
    test word[scrnon],1010h
    jz near .nosprites2
    cmp byte[winonsp],0FFh
    je .nosprites2
    xor ebx,ebx
    mov bl,[curypos]
    mov cl,[sprleftpr1+ebx]
    cmp byte[sprprifix],0
    je .nosprprio3
    mov cl,[sprlefttot+ebx]
.nosprprio3
    cmp cl,0
    je .nosprites2
    mov ebp,1
    call drawsprites
.nosprites2

    test byte[interlval],40h
    jz near .noback0b
    cmp byte[extbgdone],0
    jne near .noback0b
    test byte[scrndis],02h
    jnz near .noback0b
    ; do background 1, extbg pr 0
    test word[scrnon],0101h
    jz near .noback0b
    mov byte[winon],0
    test word[winenabm],0001h
    jz near .nobackwin0b
    test word[winenabm],0100h
    jnz near .nobackwin0b
    mov ebp,0
    mov al,[winbg1en]
    call makewindow
    cmp byte[winon],0FFh
    je near .noback0b
.nobackwin0b
    mov byte[extbgdone],1
    procmode7extbg [bg1scroly],[bg1scrolx],1
.noback0b

    test byte[interlval],40h
    jz near .noback2
    cmp byte[extbgdone],1
    jne near .noback2
    mov byte[winon],0
    test word[winenabm],0001h
    jz near .nobackwin2
    test word[winenabm],0100h
    jnz near .nobackwin2
    mov ebp,0
    mov al,[winbg1en]
    call makewindow
    cmp byte[winon],0FFh
    je near .noback2
.nobackwin2
    procmode7extbg2 [bg1scroly],[bg1scrolx],1
.noback2

    ; do objects
    test byte[scrndis],10h
    jnz near .nosprites3
    test word[scrnon],1010h
    jz near .nosprites3
    cmp byte[winonsp],0FFh
    je .nosprites3
    xor ebx,ebx
    mov bl,[curypos]
    mov cl,[sprleftpr2+ebx]
    cmp byte[sprprifix],0
    je .nosprprio4
    mov cl,[sprlefttot+ebx]
.nosprprio4
    cmp cl,0
    je .nosprites3
    mov ebp,2
    call drawsprites
.nosprites3
    ; do objects
    test byte[scrndis],10h
    jnz near .nosprites4
    test word[scrnon],1010h
    jz near .nosprites4
    cmp byte[winonsp],0FFh
    je .nosprites4
    xor ebx,ebx
    mov bl,[curypos]
    mov cl,[sprleftpr3+ebx]
    cmp byte[sprprifix],0
    je .nosprprio5
    mov cl,[sprlefttot+ebx]
.nosprprio5
    cmp cl,0
    je .nosprites4
    mov ebp,3
    call drawsprites
.nosprites4
    pop ebp
    pop edx
    pop ebx
    pop edi
    pop esi
    ret

;*******************************************************
; Processes & Draws 4-bit sprites
;*******************************************************

NEWSYM drawsprites
    cmp byte[sprprifix],1
    je near drawspritesprio
.returnfrompr
    test byte[cwinenabm],10h
    jz .drawnowin
    cmp byte[winonsp],0
    jne near drawspriteswinon
.drawnowin
    mov esi,[currentobjptr]
    mov edi,[curvidoffset]
    mov edx,esi
    xor ebx,ebx
.loopobj
    test byte[esi+7],20h
    jnz near .drawspriteflipx
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    mov eax,[esi]
    test al,0Fh
    jz .skipa
    add al,ch
    mov [edi+ebx-8],al
.skipa
    test ah,0Fh
    jz .skipb
    add ah,ch
    mov [edi+ebx-7],ah
.skipb
    shr eax,16
    test al,0Fh
    jz .skipc
    add al,ch
    mov [edi+ebx-6],al
.skipc
    test ah,0Fh
    jz .skipd
    add ah,ch
    mov [edi+ebx-5],ah
.skipd
    mov eax,[esi+4]
    test al,0Fh
    jz .skipe
    add al,ch
    mov [edi+ebx-4],al
.skipe
    test ah,0Fh
    jz .skipf
    add ah,ch
    mov [edi+ebx-3],ah
.skipf
    shr eax,16
    test al,0Fh
    jz .skipg
    add al,ch
    mov [edi+ebx-2],al
.skipg
    test ah,0Fh
    jz .skiph
    add ah,ch
    mov [edi+ebx-1],ah
.skiph
    add edx,8
    mov esi,edx
    dec cl
    jnz .loopobj
    mov [currentobjptr],esi
    ret

.drawspriteflipx
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    mov eax,[esi]
    test al,0Fh
    jz .skipa2
    add al,ch
    mov [edi+ebx-1],al
.skipa2
    test ah,0Fh
    jz .skipb2
    add ah,ch
    mov [edi+ebx-2],ah
.skipb2
    shr eax,16
    test al,0Fh
    jz .skipc2
    add al,ch
    mov [edi+ebx-3],al
.skipc2
    test ah,0Fh
    jz .skipd2
    add ah,ch
    mov [edi+ebx-4],ah
.skipd2
    mov eax,[esi+4]
    test al,0Fh
    jz .skipe2
    add al,ch
    mov [edi+ebx-5],al
.skipe2
    test ah,0Fh
    jz .skipf2
    add ah,ch
    mov [edi+ebx-6],ah
.skipf2
    shr eax,16
    test al,0Fh
    jz .skipg2
    add al,ch
    mov [edi+ebx-7],al
.skipg2
    test ah,0Fh
    jz .skiph2
    add ah,ch
    mov [edi+ebx-8],ah
.skiph2
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    mov [currentobjptr],esi
    ret

NEWSYM drawspriteswinon
    mov esi,[currentobjptr]
    mov edi,[curvidoffset]
    mov edx,esi
    xor ebx,ebx
.loopobj
    test byte[esi+7],20h
    jnz near .drawspriteflipx
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    mov eax,[esi]
    test al,0Fh
    jz .skipa
    cmp byte[winspdata+ebx-8+16],0
    jne .skipa
    add al,ch
    mov [edi+ebx-8],al
.skipa
    test ah,0Fh
    jz .skipb
    cmp byte[winspdata+ebx-7+16],0
    jne .skipb
    add ah,ch
    mov [edi+ebx-7],ah
.skipb
    shr eax,16
    test al,0Fh
    jz .skipc
    cmp byte[winspdata+ebx-6+16],0
    jne .skipc
    add al,ch
    mov [edi+ebx-6],al
.skipc
    test ah,0Fh
    jz .skipd
    cmp byte[winspdata+ebx-5+16],0
    jne .skipd
    add ah,ch
    mov [edi+ebx-5],ah
.skipd
    mov eax,[esi+4]
    test al,0Fh
    jz .skipe
    cmp byte[winspdata+ebx-4+16],0
    jne .skipe
    add al,ch
    mov [edi+ebx-4],al
.skipe
    test ah,0Fh
    jz .skipf
    cmp byte[winspdata+ebx-3+16],0
    jne .skipf
    add ah,ch
    mov [edi+ebx-3],ah
.skipf
    shr eax,16
    test al,0Fh
    jz .skipg
    cmp byte[winspdata+ebx-2+16],0
    jne .skipg
    add al,ch
    mov [edi+ebx-2],al
.skipg
    test ah,0Fh
    jz .skiph
    cmp byte[winspdata+ebx-1+16],0
    jne .skiph
    add ah,ch
    mov [edi+ebx-1],ah
.skiph
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    mov [currentobjptr],esi
    ret

.drawspriteflipx
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    mov eax,[esi]
    test al,0Fh
    jz .skipa2
    cmp byte[winspdata+ebx-1+16],0
    jne .skipa2
    add al,ch
    mov [edi+ebx-1],al
.skipa2
    test ah,0Fh
    jz .skipb2
    cmp byte[winspdata+ebx-2+16],0
    jne .skipb2
    add ah,ch
    mov [edi+ebx-2],ah
.skipb2
    shr eax,16
    test al,0Fh
    jz .skipc2
    cmp byte[winspdata+ebx-3+16],0
    jne .skipc2
    add al,ch
    mov [edi+ebx-3],al
.skipc2
    test ah,0Fh
    jz .skipd2
    cmp byte[winspdata+ebx-4+16],0
    jne .skipd2
    add ah,ch
    mov [edi+ebx-4],ah
.skipd2
    mov eax,[esi+4]
    test al,0Fh
    jz .skipe2
    cmp byte[winspdata+ebx-5+16],0
    jne .skipe2
    add al,ch
    mov [edi+ebx-5],al
.skipe2
    test ah,0Fh
    jz .skipf2
    cmp byte[winspdata+ebx-6+16],0
    jne .skipf2
    add ah,ch
    mov [edi+ebx-6],ah
.skipf2
    shr eax,16
    test al,0Fh
    jz .skipg2
    cmp byte[winspdata+ebx-7+16],0
    jne .skipg2
    add al,ch
    mov [edi+ebx-7],al
.skipg2
    test ah,0Fh
    jz .skiph2
    cmp byte[winspdata+ebx-8+16],0
    jne .skiph2
    add ah,ch
    mov [edi+ebx-8],ah
.skiph2
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    mov [currentobjptr],esi
    ret

NEWSYM drawspritesprio
    cmp byte[sprclprio+ebp],0
    je near .endobj
    test byte[cwinenabm],10h
    jz .drawnowin
    cmp byte[winonsp],0
    jne near drawspritespriowinon
.drawnowin
    cmp dword[sprsingle],1
    je near .drawsingle
    mov esi,[currentobjptr]
    mov edi,[curvidoffset]
    mov edx,esi
    xor ebx,ebx
.loopobj
    test byte[esi+7],20h
    jnz near .drawspriteflipx
    mov bx,[esi]
    push edx
    mov ch,[esi+6]
    mov dl,[esi+7]
    and edx,03h
    cmp edx,ebp
    jne near .notprio
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawa sprdrawpra
    pop edx
.nodrawspr
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
    ret
.notprio
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawa sprdrawpra2
    pop edx
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
    ret
.drawspriteflipx
    mov bx,[esi]
    push edx
    mov ch,[esi+6]
    mov dl,[esi+7]
    and edx,03h
    cmp edx,ebp
    jne near .notpriof
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawaf sprdrawpra
    pop edx
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
.endobj
    ret
.notpriof
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawaf sprdrawpra2
    pop edx
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
    ret
.clearcsprmem
    xor eax,eax
    mov ecx,64
    mov edi,sprpriodata+16
    rep stosd
    ret
.drawsingle
    mov esi,[currentobjptr]
    mov edi,[curvidoffset]
    mov edx,ecx
    and edx,0FFh
    shl edx,3
    sub edx,8
    add edx,esi
    mov esi,edx
    xor ebx,ebx
.loopobj2
    test byte[esi+7],20h
    jnz near .drawspriteflipx2
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    sprdrawa sprdrawprb
    sub edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj2
    ret
.drawspriteflipx2
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    sprdrawaf sprdrawprb
    sub edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj2
    ret

NEWSYM drawspritespriowinon
    cmp dword[sprsingle],1
    je near .drawsingle
    mov esi,[currentobjptr]
    mov edi,[curvidoffset]
    mov edx,esi
    xor ebx,ebx
.loopobj
    test byte[esi+7],20h
    jnz near .drawspriteflipx
    mov bx,[esi]
    push edx
    mov ch,[esi+6]
    mov dl,[esi+7]
    and edx,03h
    cmp edx,ebp
    jne near .notprio
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawa sprdrawpraw
    pop edx
.nodrawspr
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
    ret
.notprio
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawa sprdrawpra2
    pop edx
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
    ret
.drawspriteflipx
    mov bx,[esi]
    push edx
    mov ch,[esi+6]
    mov dl,[esi+7]
    and edx,03h
    cmp edx,ebp
    jne near .notpriof
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawaf sprdrawpraw
    pop edx
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
.endobj
    ret
.notpriof
    mov esi,[esi+2]
    mov dl,[csprbit]
    sprdrawaf sprdrawpra2
    pop edx
    add edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj
    rol byte[csprbit],1
    cmp byte[csprbit],1
    je near .clearcsprmem
    ret
.clearcsprmem
    xor eax,eax
    mov ecx,64
    mov edi,sprpriodata+16
    rep stosd
    ret
.drawsingle
    mov esi,[currentobjptr]
    mov edi,[curvidoffset]
    mov edx,ecx
    and edx,0FFh
    shl edx,3
    sub edx,8
    add edx,esi
    mov esi,edx
    xor ebx,ebx
.loopobj2
    test byte[esi+7],20h
    jnz near .drawspriteflipx2
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    sprdrawa sprdrawprbw
    sub edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj2
    ret
.drawspriteflipx2
    mov bx,[esi]
    mov ch,[esi+6]
    mov esi,[esi+2]
    sprdrawaf sprdrawprbw
    sub edx,8
    mov esi,edx
    dec cl
    jnz near .loopobj2
    ret

NEWSYM prfixobjl, db 0
NEWSYM csprbit, db 1
NEWSYM csprprlft, db 0
;*******************************************************
; Processes & Draws 8x8 tiles in 2, 4, & 8 bit mode
;*******************************************************
NEWSYM proc8x8
    cmp byte[bgmode],5
    je near proc16x8
    ; ax = # of rows down
    mov ebx,eax
    shr eax,3
    and eax,63
    and ebx,07h
    cmp byte[CacheCheckSkip],1
    je .docache
    cmp byte[edi+eax],0
    jne .nocachereq
.docache
;    cmp byte[ccud],0
;    jne .nocachereq
    mov byte[edi+eax],1
    cmp byte[curcolor],2
    jne .no4b
    ; cache 4-bit
    call cachetile4b
    jmp .nocachereq
.no4b
    cmp byte[curcolor],1
    je .2b
    ; cache 8-bit
    call cachetile8b
    jmp .nocachereq
.2b
    ; cache 2-bit
    call cachetile2b
.nocachereq
    test edx,0100h
    jz .tilexa
    test al,20h
    jz .tileya
    ; bgptrd/bgptrc
    mov ecx,[bgptrd]
    mov [bgptrx1],ecx
    mov ecx,[bgptrc]
    mov [bgptrx2],ecx
    jmp .skiptile
.tileya
    ; bgptrb/bgptra
    mov ecx,[bgptrb]
    mov [bgptrx1],ecx
    mov ecx,[bgptr]
    mov [bgptrx2],ecx
    jmp .skiptile
.tilexa
    test al,20h
    jz .tileya2
    ; bgptrc/bgptrd
    mov ecx,[bgptrc]
    mov [bgptrx1],ecx
    mov ecx,[bgptrd]
    mov [bgptrx2],ecx
    jmp .skiptile
.tileya2
    ; bgptra/bgptrb
    mov ecx,[bgptr]
    mov [bgptrx1],ecx
    mov ecx,[bgptrb]
    mov [bgptrx2],ecx
.skiptile
    ; set up edi & yadder to point to tile data
    shl ebx,3
    mov [yadder],ebx
    and al,1Fh
    mov edi,[vram]
    mov ebx,eax
    shl ebx,6
    mov eax,[bgptrx1]
    add edi,ebx
    mov [temptile],edi
    add edi,eax
    ; dx = # of columns right
    ; cx = bgxlim
    mov eax,edx
    shr edx,3
    mov bl,[curypos]
    and edx,1Fh
    mov [temp],dl
    and eax,07h
    add dl,dl
    add edi,edx

    mov esi,eax
    mov ebx,[tempcach]
    mov edx,[temptile]
    mov eax,[bgptrx2]
    and eax,0FFFFh
    add edx,eax
    mov al,[temp]
    mov ecx,[yadder]
    mov ah,[bshifter]
    ; fill up tempbuffer with pointer #s that point to cached video mem
    ; to calculate pointer, get first byte
    ; esi = pointer to video buffer
    ; edi = pointer to tile data
    ; ebx = cached memory
    ; ecx = y adder
    ; edx = secondary tile pointer
    ; al = current x position
    ret

NEWSYM proc16x8
    ; ax = # of rows down
    mov ebx,eax
    shr eax,3
    and ebx,07h
    and eax,63
    cmp byte[edi+eax],0
    jne .nocachereq
;    cmp byte[ccud],0
;    jne .nocachereq
    mov byte[edi+eax],1
    cmp byte[curcolor],2
    jne .no4b
    ; cache 4-bit
    call cachetile4b16x16
    jmp .nocachereq
.no4b
    cmp byte[curcolor],1
    je .2b
    ; cache 8-bit
    call cachetile8b16x16
    jmp .nocachereq
.2b
    ; cache 2-bit
    call cachetile2b16x16
.nocachereq
    test edx,0100h
    jz .tilexa
    test al,20h
    jz .tileya
    ; bgptrd/bgptrc
    mov ecx,[bgptrd]
    mov [bgptrx1],ecx
    mov ecx,[bgptrc]
    mov [bgptrx2],ecx
    jmp .skiptile
.tileya
    ; bgptrb/bgptra
    mov ecx,[bgptrb]
    mov [bgptrx1],ecx
    mov ecx,[bgptr]
    mov [bgptrx2],ecx
    jmp .skiptile
.tilexa
    test al,20h
    jz .tileya2
    ; bgptrc/bgptrd
    mov ecx,[bgptrc]
    mov [bgptrx1],ecx
    mov ecx,[bgptrd]
    mov [bgptrx2],ecx
    jmp .skiptile
.tileya2
    ; bgptra/bgptrb
    mov ecx,[bgptr]
    mov [bgptrx1],ecx
    mov ecx,[bgptrb]
    mov [bgptrx2],ecx
.skiptile
    ; set up edi & yadder to point to tile data
    shl ebx,3
    mov [yadder],ebx
    and al,1Fh
    mov edi,[vram]
    mov ebx,eax
    shl ebx,6
    mov eax,[bgptrx1]
    add edi,ebx
    mov [temptile],edi
    add edi,eax
    ; dx = # of columns right
    ; cx = bgxlim
    mov eax,edx
    shr edx,3
    mov bl,[curypos]
    and edx,1Fh
    mov [temp],dl
    and eax,07h
    add dl,dl
    add edi,edx

    mov esi,eax
    mov ebx,[tempcach]
    mov edx,[temptile]
    mov eax,[bgptrx2]
    and eax,0FFFFh
    add edx,eax
    mov al,[temp]
    mov ecx,[yadder]
    mov ah,[bshifter]
    ; fill up tempbuffer with pointer #s that point to cached video mem
    ; to calculate pointer, get first byte
    ; esi = pointer to video buffer
    ; edi = pointer to tile data
    ; ebx = cached memory
    ; ecx = y adder
    ; edx = secondary tile pointer
    ; al = current x position
    ret

NEWSYM drawn, db 0
NEWSYM curbgpr, db 0    ; 00h = low priority, 20h = high priority

%macro drawpixel8b8x8 3
    or %1,%1
    jz %2
    add %1,dh
    mov [esi+%3],%1
%2
%endmacro

%macro drawpixel8b8x8win 3
    or %1,%1
    jz %2
    test byte[ebp+%3],0FFh
    jnz %2
    add %1,dh
    mov [esi+%3],%1
%2
%endmacro

NEWSYM winptrref, dd 0

NEWSYM draw8x8
    cmp byte[osm2dis],1
    je .osm2dis
    cmp byte[bgmode],2
    je near draw8x8offset
.osm2dis
    cmp byte[bgmode],5
    jae near draw16x8
    mov [temp],al
    mov [bshifter],ah
    mov eax,esi
    mov [yadder],ecx
    mov [tempcach],ebx
    mov ebx,56
    sub ebx,ecx
    mov [yrevadder],ebx
.retfromoffset
    ; esi = pointer to video buffer
    mov esi,[cwinptr]
    sub esi,eax
    mov [winptrref],esi
    mov esi,[curvidoffset]
    sub esi,eax           ; esi = [vidbuffer] + curypos * 288 + 16 - HOfs
    cmp byte[curmosaicsz],1
    je .nomosaic
    mov esi,xtravbuf+16
    mov ecx,64
.clearnext
    mov dword[esi],0
    add esi,4
    dec ecx
    jnz .clearnext
    mov esi,xtravbuf+16
    sub esi,eax
.nomosaic
    mov [temptile],edx
    mov dword[bgofwptr],vcache2ba+262144
    mov dword[bgsubby],262144
    cmp dword[tempcach],vcache2ba+262144
    jb .nobit
    mov dword[bgofwptr],vcache4ba+131072
    mov dword[bgsubby],131072
    cmp dword[tempcach],vcache4ba+131072
    jb .nobit
    mov dword[bgofwptr],vcache8ba+65536
    mov dword[bgsubby],65536
.nobit
; tile value : bit 15 = flipy, bit 14 = flipx, bit 13 = priority value
;              bit 10-12 = palette, 0-9=tile#
    cmp byte[curmosaicsz],1
    jne .domosaic
    cmp byte[winon],0
    jne near draw8x8winon
.domosaic
    mov ch,33
    mov byte[drawn],0
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1
    drawpixel8b8x8 al, .loopd1, 0
    drawpixel8b8x8 ah, .loopd2, 1
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd3, 2
    drawpixel8b8x8 ah, .loopd4, 3
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8 al, .loopd5, 4
    drawpixel8b8x8 ah, .loopd6, 5
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7, 6
    drawpixel8b8x8 ah, .loopd8, 7
.skiploop2
.hprior
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc2
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    cmp byte[drawn],0
    je .nodraw
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
.nodraw
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8 al, .loopd1b, 7
    drawpixel8b8x8 ah, .loopd2b, 6
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd3b, 5
    drawpixel8b8x8 ah, .loopd4b, 4
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8 al, .loopd5b, 3
    drawpixel8b8x8 ah, .loopd6b, 2
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7b, 1
    drawpixel8b8x8 ah, .loopd8b, 0
.skiploop2b
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    cmp byte[drawn],0
    je .nodraw2
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
.nodraw2
    ret

NEWSYM draw8x8winon
    mov ch,33
    mov byte[drawn],0
    mov ebp,[winptrref]
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1
    drawpixel8b8x8win al, .loopd1, 0
    drawpixel8b8x8win ah, .loopd2, 1
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd3, 2
    drawpixel8b8x8win ah, .loopd4, 3
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8win al, .loopd5, 4
    drawpixel8b8x8win ah, .loopd6, 5
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7, 6
    drawpixel8b8x8win ah, .loopd8, 7
.skiploop2
.hprior
    add esi,8
    add ebp,8
    inc dl
    cmp dl,20h
    jne .loopc2
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8win al, .loopd1b, 7
    drawpixel8b8x8win ah, .loopd2b, 6
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd3b, 5
    drawpixel8b8x8win ah, .loopd4b, 4
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8win al, .loopd5b, 3
    drawpixel8b8x8win ah, .loopd6b, 2
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7b, 1
    drawpixel8b8x8win ah, .loopd8b, 0
.skiploop2b
    add esi,8
    add ebp,8
    inc dl
    cmp dl,20h
    jne .loopc
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    ret

NEWSYM alttile, db 0
NEWSYM hirestiledat, times 256 db 0

NEWSYM draw16x8
    push eax
    xor eax,eax
    mov al,[curypos]
    mov byte[hirestiledat+eax],1
    pop eax
    mov [temp],al
    mov [bshifter],ah
    mov eax,esi
    mov [yadder],ecx
    mov [tempcach],ebx
    mov ebx,56
    sub ebx,ecx
    mov [yrevadder],ebx
    ; esi = pointer to video buffer
    mov esi,[cwinptr]
    sub esi,eax
    mov [winptrref],esi
    mov esi,[curvidoffset]
    sub esi,eax           ; esi = [vidbuffer] + curypos * 288 + 16 - HOfs
    cmp byte[curmosaicsz],1
    je .nomosaic
    mov esi,xtravbuf+16
    mov ecx,64
.clearnext
    mov dword[esi],0
    add esi,4
    dec ecx
    jnz .clearnext
    mov esi,xtravbuf+16
    sub esi,eax
.nomosaic
    mov [temptile],edx
    mov dword[bgofwptr],vcache2ba+262144
    mov dword[bgsubby],262144
    cmp dword[tempcach],vcache2ba+262144
    jb .nobit
    mov dword[bgofwptr],vcache4ba+131072
    mov dword[bgsubby],131072
    cmp dword[tempcach],vcache4ba+131072
    jb .nobit
    mov dword[bgofwptr],vcache8ba+65536
    mov dword[bgsubby],65536
.nobit
; tile value : bit 15 = flipy, bit 14 = flipx, bit 13 = priority value
;              bit 10-12 = palette, 0-9=tile#
    cmp byte[curmosaicsz],1
    jne .domosaic
    cmp byte[winon],0
    jne near draw16x8winon
.domosaic
    cmp byte[res512switch],0
    jne near draw16x8b
    mov ch,33
    mov byte[drawn],0
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1
    drawpixel8b8x8 al, .loopd1, 0
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd3, 1
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8 al, .loopd5, 2
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7, 3
.skiploop2
    add ebx,64
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1c
    drawpixel8b8x8 al, .loopd1c, 4
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd3c, 5
.skiploop1c
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2c
    drawpixel8b8x8 al, .loopd5c, 6
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7c, 7
.skiploop2c
.hprior
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc2
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    cmp byte[drawn],0
    je .nodraw
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
.nodraw
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8 ah, .loopd1b, 7
    mov eax,[ebx+2]
    drawpixel8b8x8 ah, .loopd3b, 6
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8 ah, .loopd5b, 5
    mov eax,[ebx+6]
    drawpixel8b8x8 ah, .loopd7b, 4
.skiploop2b
    add ebx,64
    mov eax,[ebx]
    or eax,eax
    je .skiploop1d
    drawpixel8b8x8 ah, .loopd1d, 3
    mov eax,[ebx+2]
    drawpixel8b8x8 ah, .loopd3d, 2
.skiploop1d 
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2d
    drawpixel8b8x8 ah, .loopd5d, 1
    mov eax,[ebx+6]
    drawpixel8b8x8 ah, .loopd7d, 0
.skiploop2d
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    cmp byte[drawn],0
    je .nodraw2
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
    cmp byte[winon],0
    jne near dowindow
.nodraw2
    ret

NEWSYM draw16x8b
    mov ch,33
    mov byte[drawn],0
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1
    drawpixel8b8x8 ah, .loopd1, 0
    mov eax,[ebx+2]
    drawpixel8b8x8 ah, .loopd3, 1
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8 ah, .loopd5, 2
    mov eax,[ebx+6]
    drawpixel8b8x8 ah, .loopd7, 3
.skiploop2
    add ebx,64
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1c
    drawpixel8b8x8 ah, .loopd1c, 4
    mov eax,[ebx+2]
    drawpixel8b8x8 ah, .loopd3c, 5
.skiploop1c
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2c
    drawpixel8b8x8 ah, .loopd5c, 6
    mov eax,[ebx+6]
    drawpixel8b8x8 ah, .loopd7c, 7
.skiploop2c
.hprior
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc2
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    cmp byte[drawn],0
    je .nodraw
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
.nodraw
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8 al, .loopd2b, 7
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd4b, 6
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8 al, .loopd5b, 5
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7b, 4
.skiploop2b
    add ebx,64
    mov eax,[ebx]
    or eax,eax
    je .skiploop1d
    drawpixel8b8x8 al, .loopd1d, 3
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd3d, 2
.skiploop1d 
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2d
    drawpixel8b8x8 al, .loopd5d, 1
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7d, 0
.skiploop2d
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    cmp byte[drawn],0
    je .nodraw2
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
.nodraw2
    ret

NEWSYM draw16x8winon
    cmp byte[res512switch],0
    jne near draw16x8bwinon
    mov ch,33
    mov ebp,[winptrref]
    mov byte[drawn],0
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1
    drawpixel8b8x8win al, .loopd1, 0
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd3, 1
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8win al, .loopd5, 2
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7, 3
.skiploop2
    add ebx,64
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1c
    drawpixel8b8x8win al, .loopd1c, 4
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd3c, 5
.skiploop1c
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2c
    drawpixel8b8x8win al, .loopd5c, 6
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7c, 7
.skiploop2c
.hprior
    add ebp,8
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc2
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8win ah, .loopd1b, 7
    mov eax,[ebx+2]
    drawpixel8b8x8win ah, .loopd3b, 6
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8win ah, .loopd5b, 5
    mov eax,[ebx+6]
    drawpixel8b8x8win ah, .loopd7b, 4
.skiploop2b
    add ebx,64
    mov eax,[ebx]
    or eax,eax
    je .skiploop1d
    drawpixel8b8x8win ah, .loopd1d, 3
    mov eax,[ebx+2]
    drawpixel8b8x8win ah, .loopd3d, 2
.skiploop1d 
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2d
    drawpixel8b8x8win ah, .loopd5d, 1
    mov eax,[ebx+6]
    drawpixel8b8x8win ah, .loopd7d, 0
.skiploop2d
    add ebp,8
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    ret

NEWSYM draw16x8bwinon
    mov ch,33
    mov ebp,[winptrref]
    mov byte[drawn],0
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1
    drawpixel8b8x8win ah, .loopd1, 0
    mov eax,[ebx+2]
    drawpixel8b8x8win ah, .loopd3, 1
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8win ah, .loopd5, 2
    mov eax,[ebx+6]
    drawpixel8b8x8win ah, .loopd7, 3
.skiploop2
    add ebx,64
    ; Start loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1c
    drawpixel8b8x8win ah, .loopd1c, 4
    mov eax,[ebx+2]
    drawpixel8b8x8win ah, .loopd3c, 5
.skiploop1c
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2c
    drawpixel8b8x8win ah, .loopd5c, 6
    mov eax,[ebx+6]
    drawpixel8b8x8win ah, .loopd7c, 7
.skiploop2c
.hprior
    add ebp,8
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc2
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    mov eax,[ebx]
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8win al, .loopd2b, 7
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd4b, 6
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8win al, .loopd5b, 5
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7b, 4
.skiploop2b
    add ebx,64
    mov eax,[ebx]
    or eax,eax
    je .skiploop1d
    drawpixel8b8x8win al, .loopd1d, 3
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd3d, 2
.skiploop1d 
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2d
    drawpixel8b8x8win al, .loopd5d, 1
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7d, 0
.skiploop2d
    add ebp,8
    add esi,8
    inc dl
    cmp dl,20h
    jne .loopc
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    ret

NEWSYM extraleft, db 0,0,0,1,0,1,2,2,0,2,3,1,2,4,2,1

NEWSYM domosaic
    mov esi,xtravbuf+16
    mov edi,[curvidoffset]
    xor ecx,ecx
    mov cl,dh
    mov dl,dh
    sub dl,[extraleft+ecx]
    mov ecx,256
    mov al,[esi]
    cmp byte[winon],0
    jne near domosaicwin
    test al,0FFh
    jz .zeroloop
.loopm
    mov [edi],al
    inc esi
    inc edi
    dec ecx
    jz .doneloop
    dec dl
    jnz .loopm
    mov al,[esi]
    mov dl,dh
    test al,0FFh
    jnz .loopm
.zeroloop
    inc esi
    inc edi
    dec ecx
    jz .doneloop
    dec dl
    jnz .zeroloop
    mov al,[esi]
    mov dl,dh
    test al,0FFh
    jnz .loopm
    jmp .zeroloop
.doneloop
    ret

NEWSYM domosaicwin
    mov ebp,[winptrref]
    test al,0FFh
    jz .zeroloop
.loopm
    cmp byte[ebp],0
    jne .nozero2
    mov [edi],al
.nozero2
    inc esi
    inc edi
    inc ebp
    dec ecx
    jz .doneloop
    dec dl
    jnz .loopm
    mov al,[esi]
    mov dl,dh
    test al,0FFh
    jnz .loopm
.zeroloop
    inc esi
    inc edi
    inc ebp
    dec ecx
    jz .doneloop
    dec dl
    jnz .zeroloop
    mov al,[esi]
    mov dl,dh
    test al,0FFh
    jnz .loopm
    jmp .zeroloop
.doneloop
    ret

;windowdata times 16 db 0
;numwin db 0

NEWSYM dowindow
    mov ebx,windowdata
    mov esi,xtravbuf+16
    mov edi,[curvidoffset]
    xor edx,edx
    xor ch,ch
.getnext
    mov cl,[ebx]
    cmp dl,cl
    je .procnext
.dorest
    sub cl,dl
    cmp ch,0
    ja .nodraw
.loopa
    mov eax,[esi+edx]
    test al,0FFh
    jz .nocopy
    mov [edi+edx],al
.nocopy
    inc dl
    dec cl
    jz .procnext
    test ah,0FFh
    jz .nocopyb
    mov [edi+edx],ah
.nocopyb
    inc dl
    dec cl
    jz .procnext
    shr eax,16
    test al,0FFh
    jz .nocopyc
    mov [edi+edx],al
.nocopyc
    inc dl
    dec cl
    jz .procnext
    test ah,0FFh
    jz .nocopyd
    mov [edi+edx],ah
.nocopyd
    inc dl
    dec cl
    jnz .loopa
.procnext
    add ch,[ebx+1]
    add ebx,2
    test byte[numwin],0FFh
    jz .finishwin
    dec byte[numwin]
    jnz .getnext
    xor cl,cl
    jmp .dorest
.nodraw
    add dl,cl
    jmp .procnext
.finishwin
    xor eax,eax
    ret

;xtravbuf   times 576 db 0
; bytes to add to match y coordinates

ALIGN32

NEWSYM yadder,     dd 0
NEWSYM yrevadder,  dd 0
NEWSYM tempcach,   dd 0          ; points to cached memory
NEWSYM temptile,   dd 0          ; points to the secondary video pointer
NEWSYM bgptr,      dd 0
NEWSYM bgptrb,     dd 0
NEWSYM bgptrc,     dd 0
NEWSYM bgptrd,     dd 0
NEWSYM bgptrx1,    dd 0
NEWSYM bgptrx2,    dd 0
NEWSYM curvidoffset, dd 0
NEWSYM winon,      dd 0
NEWSYM bgofwptr,   dd 0
NEWSYM bgsubby,    dd 0


NEWSYM draw8x8offset
    mov [temp],al
    mov [bshifter],ah
    mov eax,esi
    mov [yadder],ecx
    mov [tempcach],ebx
    mov ebx,56
    sub ebx,ecx
    mov [yrevadder],ebx
    initoffsetmode
    ; esi = pointer to video buffer
    mov esi,[cwinptr]
    sub esi,eax
    mov [winptrref],esi
    mov esi,[curvidoffset]
    sub esi,eax           ; esi = [vidbuffer] + curypos * 288 + 16 - HOfs
    cmp byte[curmosaicsz],1
    je .nomosaic
    mov esi,xtravbuf+16
    mov ecx,64
.clearnext
    mov dword[esi],0
    add esi,4
    dec ecx
    jnz .clearnext
    mov esi,xtravbuf+16
    sub esi,eax
.nomosaic
    mov [temptile],edx
    mov dword[bgofwptr],vcache2ba+262144
    mov dword[bgsubby],262144
    cmp dword[tempcach],vcache2ba+262144
    jb .nobit
    mov dword[bgofwptr],vcache4ba+131072
    mov dword[bgsubby],131072
    cmp dword[tempcach],vcache4ba+131072
    jb .nobit
    mov dword[bgofwptr],vcache8ba+65536
    mov dword[bgsubby],65536
.nobit
; tile value : bit 15 = flipy, bit 14 = flipx, bit 13 = priority value
;              bit 10-12 = palette, 0-9=tile#
    cmp byte[curmosaicsz],1
    jne .domosaic
    cmp byte[winon],0
    jne near draw8x8winon
.domosaic
    mov byte[offsettilel],33
    mov byte[drawn],0
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
;    add dword[offsetptrb],2
;    add dword[offsetcedi],2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    offsetmcachechk
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1
    drawpixel8b8x8 al, .loopd1, 0
    drawpixel8b8x8 ah, .loopd2, 1
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd3, 2
    drawpixel8b8x8 ah, .loopd4, 3
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8 al, .loopd5, 4
    drawpixel8b8x8 ah, .loopd6, 5
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7, 6
    drawpixel8b8x8 ah, .loopd8, 7
.skiploop2
.hprior
    procoffsetmode
    add esi,8
    dec byte[offsettilel]
    jnz near .loopa
    cmp byte[drawn],0
    je .nodraw
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
.nodraw
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8 al, .loopd1b, 7
    drawpixel8b8x8 ah, .loopd2b, 6
    mov eax,[ebx+2]
    drawpixel8b8x8 al, .loopd3b, 5
    drawpixel8b8x8 ah, .loopd4b, 4
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8 al, .loopd5b, 3
    drawpixel8b8x8 ah, .loopd6b, 2
    mov eax,[ebx+6]
    drawpixel8b8x8 al, .loopd7b, 1
    drawpixel8b8x8 ah, .loopd8b, 0
.skiploop2b
    procoffsetmode
    add esi,8
    dec byte[offsettilel]
    jnz near .loopa
    xor eax,eax
    cmp byte[drawn],0
    je .nodraw2
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
.nodraw2
    ret

NEWSYM draw8x8winonoffset
    mov ch,33
    mov byte[drawn],0
    mov ebp,[winptrref]
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    add edi,2
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]
    and eax,03FFh                ; filter out tile #
    offsetmcachechk
    mov ebx,[tempcach]
    shl eax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1
    drawpixel8b8x8win al, .loopd1, 0
    drawpixel8b8x8win ah, .loopd2, 1
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd3, 2
    drawpixel8b8x8win ah, .loopd4, 3
.skiploop1
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2
    drawpixel8b8x8win al, .loopd5, 4
    drawpixel8b8x8win ah, .loopd6, 5
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7, 6
    drawpixel8b8x8win ah, .loopd8, 7
.skiploop2
.hprior
    procoffsetmode
    add esi,8
    add ebp,8
    dec ch
    jnz near .loopa
    xor eax,eax
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    or eax,eax
    je .skiploop1b
    drawpixel8b8x8win al, .loopd1b, 7
    drawpixel8b8x8win ah, .loopd2b, 6
    mov eax,[ebx+2]
    drawpixel8b8x8win al, .loopd3b, 5
    drawpixel8b8x8win ah, .loopd4b, 4
.skiploop1b
    mov eax,[ebx+4]
    or eax,eax
    je .skiploop2b
    drawpixel8b8x8win al, .loopd5b, 3
    drawpixel8b8x8win ah, .loopd6b, 2
    mov eax,[ebx+6]
    drawpixel8b8x8win al, .loopd7b, 1
    drawpixel8b8x8win ah, .loopd8b, 0
.skiploop2b
    procoffsetmode
    add esi,8
    add ebp,8
    dec ch
    jnz near .loopa
    xor eax,eax
    ret

ALIGN32

NEWSYM offsetmodeptr, dd 0
NEWSYM offsetptra,    dd 0
NEWSYM offsetptrb,    dd 0
NEWSYM prevtempcache, dd 0
NEWSYM prevoffsetdat, dd 0
NEWSYM offsetenab,    dd 0
NEWSYM offsettilel,   dd 0
NEWSYM offsetrevval,  dd 0
NEWSYM posyscroll,    dd 0
NEWSYM offsetmcol,    dd 0
NEWSYM offsetmshl,    dd 0
NEWSYM offsetmptr,    dd 0
NEWSYM offsetmtst,    dd 0
NEWSYM offsetmclr,    dd 0
NEWSYM offsetcedi,    dd 0

;*******************************************************
; Processes & Draws 16x16 tiles in 2, 4, & 8 bit mode
;*******************************************************

NEWSYM proc16x16
    ; ax = # of rows down
    xor ebx,ebx
    mov ebx,eax
    and ebx,07h
    mov byte[a16x16yinc],0
    test eax,08h
    jz .noincb
    mov byte[a16x16yinc],1
.noincb
    shr eax,4
    and eax,63
    cmp byte[edi+eax],0
    jne .nocachereq
    mov byte[edi+eax],1
    cmp byte[curcolor],2
    jne .no4b
    ; cache 4-bit
    call cachetile4b16x16
    jmp .nocachereq
.no4b
    cmp byte[curcolor],1
    je .2b
    ; cache 8-bit
    call cachetile8b16x16
    jmp .nocachereq
.2b
    ; cache 2-bit
    call cachetile2b16x16
.nocachereq
    test edx,0200h
    jz .tilexa
    test eax,20h
    jz .tileya
    ; bgptrd/bgptrc
    mov ecx,[bgptrd]
    mov [bgptrx1],ecx
    mov ecx,[bgptrc]
    mov [bgptrx2],ecx
    jmp .skiptile
.tileya
    ; bgptrb/bgptra
    mov ecx,[bgptrb]
    mov [bgptrx1],ecx
    mov ecx,[bgptr]
    mov [bgptrx2],ecx
    jmp .skiptile
.tilexa
    test ax,20h
    jz .tileya2
    ; bgptrc/bgptrd
    mov ecx,[bgptrc]
    mov [bgptrx1],ecx
    mov ecx,[bgptrd]
    mov [bgptrx2],ecx
    jmp .skiptile
.tileya2
    ; bgptra/bgptrb
    mov ecx,[bgptr]
    mov [bgptrx1],ecx
    mov ecx,[bgptrb]
    mov [bgptrx2],ecx
.skiptile
    and eax,1Fh
    shl ebx,3
    mov [yadder],ebx
    ; set up edi to point to tile data
    mov edi,[vram]
    mov ebx,eax
    shl ebx,6
    mov ax,[bgptrx1]
    add edi,ebx
    mov [temptile],edi
    add edi,eax
    ; dx = # of columns right
    ; cx = bgxlim
    mov eax,edx
    mov byte[a16x16xinc],0
    test edx,08h
    jz .noincd
    mov byte[a16x16xinc],1
.noincd
    shr edx,4
    and edx,1Fh
    mov [temp],dl
    and eax,07h
    shl dl,1
    xor ebx,ebx
    add edi,edx

    mov esi,eax
    mov ebx,[tempcach]
    xor eax,eax
    mov edx,[temptile]
    mov ax,[bgptrx2]
    add edx,eax
    mov ecx,[yadder]
    mov eax,[temp]
    ; fill up tempbuffer with pointer #s that point to cached video mem
    ; to calculate pointer, get first byte
    ; esi = pointer to video buffer
    ; edi = pointer to tile data
    ; ebx = cached memory
    ; ecx = y adder
    ; edx = secondary tile pointer
    ; al = current x position
    ret

NEWSYM draw16x16
    mov byte[drawn],0
    mov [temp],eax
    mov eax,esi
    mov [yadder],ecx
    mov [tempcach],ebx
    mov ebx,56
    sub ebx,ecx
    mov [yrevadder],ebx
    xor ebx,ebx
    mov bl,[curypos]
    mov [temptile],edx
    mov dword[bgofwptr],vcache2ba+262144
    mov dword[bgsubby],262144
    cmp dword[tempcach],vcache2ba+262144
    jb .nobit
    mov dword[bgofwptr],vcache4ba+131072
    mov dword[bgsubby],131072
    cmp dword[tempcach],vcache4ba+131072
    jb .nobit
    mov dword[bgofwptr],vcache8ba+65536
    mov dword[bgsubby],65536
.nobit
    ; set up y adders
    test byte[a16x16yinc],01h
    jz .noincrc
    mov word[.yadd],16
    mov word[.yflipadd],0
    jmp .yesincrc
.noincrc
    mov word[.yadd],0
    mov word[.yflipadd],16
.yesincrc
    ; esi = pointer to video buffer
    mov esi,[cwinptr]
    sub esi,eax
    mov [winptrref],esi
    mov esi,[curvidoffset]
    sub esi,eax           ; esi = [vidbuffer] + curypos * 288 + 16 - HOfs
    cmp byte[curmosaicsz],1
    je .nomosaic
    mov esi,xtravbuf+16
    mov ecx,64
.clearnext
    mov dword[esi],0
    add esi,4
    dec ecx
    jnz .clearnext
    mov esi,xtravbuf+16
    sub esi,eax
.nomosaic
    cmp byte[curmosaicsz],1
    jne .domosaic
    cmp byte[winon],0
    jne near draw16x16winon
.domosaic
    mov ch,33
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    xor byte[a16x16xinc],1

    test dh,40h
    jnz .noxflip
    test byte[a16x16xinc],01h
    jnz .noincr2
    inc ax
    add edi,2
.noincr2
    jmp .yesxflip
.noxflip
    test byte[a16x16xinc],01h
    jnz .noincr
    add edi,2
    jmp .yesincr
.noincr
    inc ax
.yesincr
.yesxflip
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]

    test dh,80h
    jnz .noyflip
    add ax,word[.yadd]
    jmp .yesyflip
.noyflip
    add ax,word[.yflipadd]
.yesyflip

    and ax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl ax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    cmp eax,0
    je .skiploop1
    drawpixel8b8x8 al, .loopd1, 0
    drawpixel8b8x8 ah, .loopd2, 1
    shr eax,16
    drawpixel8b8x8 al, .loopd3, 2
    drawpixel8b8x8 ah, .loopd4, 3
.skiploop1
    mov eax,[ebx+4]
    cmp eax,0
    je .skiploop2
    drawpixel8b8x8 al, .loopd5, 4
    drawpixel8b8x8 ah, .loopd6, 5
    shr eax,16
    drawpixel8b8x8 al, .loopd7, 6
    drawpixel8b8x8 ah, .loopd8, 7
.skiploop2
.hprior
    add esi,8
    test byte[a16x16xinc],01h
    jnz .noincrb2
    inc dl
.noincrb2
    cmp dl,20h
    jne .loopc2
    xor dl,dl
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    cmp eax,0
    je .skiploop1b
    drawpixel8b8x8 al, .loopd1b, 7
    drawpixel8b8x8 ah, .loopd2b, 6
    shr eax,16
    drawpixel8b8x8 al, .loopd3b, 5
    drawpixel8b8x8 ah, .loopd4b, 4
.skiploop1b
    mov eax,[ebx+4]
    cmp eax,0
    je .skiploop2b
    drawpixel8b8x8 al, .loopd5b, 3
    drawpixel8b8x8 ah, .loopd6b, 2
    shr eax,16
    drawpixel8b8x8 al, .loopd7b, 1
    drawpixel8b8x8 ah, .loopd8b, 0
.skiploop2b
    add esi,8
    test byte[a16x16xinc],01h
    jnz .noincrb
    inc dl
.noincrb
    cmp dl,20h
    jne .loopc
    xor dl,dl
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    mov dh,byte[curmosaicsz]
    cmp dh,1
    jne near domosaic
    ret

.yadd      dw 0
.yflipadd  dw 0

NEWSYM draw16x16winon
.domosaic
    mov ch,33
    mov ebp,[winptrref]
    mov dl,[temp]
.loopa
    mov ax,[edi]
    mov dh,ah
    xor byte[a16x16xinc],1

    test dh,40h
    jnz .noxflip
    test byte[a16x16xinc],01h
    jnz .noincr2
    inc ax
    add edi,2
.noincr2
    jmp .yesxflip
.noxflip
    test byte[a16x16xinc],01h
    jnz .noincr
    add edi,2
    jmp .yesincr
.noincr
    inc ax
.yesincr
.yesxflip
    xor dh,[curbgpr]
    test dh,20h
    jnz near .hprior
    inc byte[drawn]

    test dh,80h
    jnz .noyflip
    add ax,word[draw16x16.yadd]
    jmp .yesyflip
.noyflip
    add ax,word[draw16x16.yflipadd]
.yesyflip

    and ax,03FFh                ; filter out tile #
    mov ebx,[tempcach]
    shl ax,6
    add ebx,eax
    cmp ebx,[bgofwptr]
    jb .noclip
    sub ebx,[bgsubby]
.noclip
    test dh,80h
    jz .normadd
    add ebx,[yrevadder]
    jmp .skipadd
.normadd
    add ebx,[yadder]
.skipadd
    test dh,40h
    jnz near .rloop

    ; Begin Normal Loop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    cmp eax,0
    je .skiploop1
    drawpixel8b8x8win al, .loopd1, 0
    drawpixel8b8x8win ah, .loopd2, 1
    shr eax,16
    drawpixel8b8x8win al, .loopd3, 2
    drawpixel8b8x8win ah, .loopd4, 3
.skiploop1
    mov eax,[ebx+4]
    cmp eax,0
    je .skiploop2
    drawpixel8b8x8win al, .loopd5, 4
    drawpixel8b8x8win ah, .loopd6, 5
    shr eax,16
    drawpixel8b8x8win al, .loopd7, 6
    drawpixel8b8x8win ah, .loopd8, 7
.skiploop2
.hprior
    add ebp,8
    add esi,8
    test byte[a16x16xinc],01h
    jnz .noincrb2
    inc dl
.noincrb2
    cmp dl,20h
    jne .loopc2
    xor dl,dl
    mov edi,[temptile]
.loopc2
    dec ch
    jnz near .loopa
    ret

    ; reversed loop
.rloop
    mov cl,[bshifter]
    and dh,1Ch
    mov eax,[ebx]
    shl dh,cl                    ; process palette # (bits 10-12)
    add dh,[bgcoloradder]
    ; Start fast loop
    cmp eax,0
    je .skiploop1b
    drawpixel8b8x8win al, .loopd1b, 7
    drawpixel8b8x8win ah, .loopd2b, 6
    shr eax,16
    drawpixel8b8x8win al, .loopd3b, 5
    drawpixel8b8x8win ah, .loopd4b, 4
.skiploop1b
    mov eax,[ebx+4]
    cmp eax,0
    je .skiploop2b
    drawpixel8b8x8win al, .loopd5b, 3
    drawpixel8b8x8win ah, .loopd6b, 2
    shr eax,16
    drawpixel8b8x8win al, .loopd7b, 1
    drawpixel8b8x8win ah, .loopd8b, 0
.skiploop2b
    add ebp,8
    add esi,8
    test byte[a16x16xinc],01h
    jnz .noincrb
    inc dl
.noincrb
    cmp dl,20h
    jne .loopc
    xor dl,dl
    mov edi,[temptile]
.loopc
    dec ch
    jnz near .loopa
    ret

NEWSYM temp,       db 0
NEWSYM bshifter,   db 0
NEWSYM a16x16xinc, db 0
NEWSYM a16x16yinc, db 0


NEWSYM MakeVidAsmEnd