;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  GRAPH32.INC                                                 ;;
;;                                                              ;;
;;            32bpp graph engine for Kolibri-A                  ;;
;;                                                              ;;
;;  art_zh (kolibri@jerdev.co.uk) Dec. 2010 :                   ;;
;;      - 4x2 granularity & tiled winmap structure              ;;
;;      - speed-optimized line/box graphics                     ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 1708 $


;*************************************************
; getpixel
;
; in:
; eax = x coordinate
; ebx = y coordinate
;
; ret:
; ecx = 00 RR GG BB


get_pixel:
     mov     ecx, [BytesPerScanLine]
     imul    ecx, ebx
     lea     ecx, [ecx+eax*4]		; ecx = x*4+(y*y multiplier)
     mov     ecx, [ecx+LFB_BASE]
     and     ecx, 0xffffff
     ret

;-----------------------------------------------------------------------------------
; esi : Buffer origin
; edi : Screen origin
; ebp : Map origin
; ecx : block height (pix)
; ebx : bit[24] = odd line; bh = temp; bl = current task

align 4
draw_aligned_box:
        pushad
        xor     edx, edx
.new_line:
        btr     ebx, 26
        mov     eax, [img_map_x]
        xor     ecx, ecx
        cmp	bl, byte[ebp]		        ; check the left tile first
        jz      .new_tile
        bts     ebx, 26                         ; ebx[26] = 1 if edi/esi already pushed
        jc      .seek_visible
        push    edi
        push    esi
        jmp     .seek_visible
.new_tile:
        inc     ecx			        ; visible - scan the open space
        cmp     ecx, eax      
        jz      .end_of_line
        cmp     bl, byte[ebp+ecx]               ; overlapped? draw the visible segment if so
        je      .new_tile

        call    [img_draw_core_fn]	        ; bpp-specific helper (see below)

.seek_visible:
        inc     ecx
        cmp     ecx, eax	
        je      .next_line
        cmp     bl, byte[ebp+ecx]
        jne     .seek_visible
.got_visible:
        sub     eax, ecx
	shl     ecx, 4
        add	edi, ecx                        ; shift the left edge 
        shr     ecx, 2
        imul    ecx, [img_bytes_per_pix]
        add     esi, ecx
        xor     ecx, ecx
        jmp     .new_tile

.end_of_line:
        call    [img_draw_core_fn]

.next_line:  
        bt      ebx, 26
        jnc     @f
        pop     esi
        pop     edi                                   
@@:	inc	edx
	cmp	edx, [esp+24]                   ; stacked ecx = image height 
	je	.finish
	add	edi, [BytesPerScanLine]
        add     esi, [img_buf_line_size]
	btc	ebx, 24			        ; odd line?
	jnc	.new_line
        add     ebp, [_WinMapWidth]
	jmp     .new_line

.finish:
        popad
        ret

;--------------------------------
; ebx : bit[24] = odd line; bh = reserved; bl = current task
; ecx : column height (pix)
; edx : max tile offset: 0, 4, 8, or 12 bytes (1,2,3 or 4 pix to draw)
; ebp : map origin
; esi : buffer image origin 
; edi : LFB-origin (4byte-aligned)

align 4
draw_unaligned_edge:
        pushad
        mov     eax, [img_buf_line_size]
        mov     bh, dl                  ; store the 1st tile offset
        bt      ebx, 24                 ; check if the 1st line odd
        jnc     .new_tile           
        cmp     bl, byte[ebp]
        jne     @f
        call    [img_draw_edge_fn]      ; bpp-specific helper (see below)
@@:     
        dec     ecx
        jz      .exit
        add     edi, [BytesPerScanLine]
        add     ebp, [_WinMapWidth]
        add     esi, eax
        btr     ebx, 24                 
.new_tile:
        cmp     bl, byte[ebp]
        jne     .skip_tile
        call    [img_draw_edge_fn]      
        dec     ecx
        jz      .exit
        add     edi, [BytesPerScanLine]
        add     esi, eax
        call    [img_draw_edge_fn]      
        dec     ecx
        jz      .exit
        add     edi, [BytesPerScanLine]
        add     ebp, [_WinMapWidth]
        add     esi, eax
        jmp     .new_tile
.skip_tile:
        sub     cx, 2
        jbe     .exit
        add     edi, [BytesPerScanLine]
        add     edi, [BytesPerScanLine]
        add     esi, eax
        add     esi, eax
        add     ebp, [_WinMapWidth]
        jmp     .new_tile
.exit:
        popad
        ret               

              

;-------------
; unaligned edge helpers
; esi -> left point of the image edge 
; edi -> left point of the screen edge
; bh = edx = tile offset (0, 4, 8 or 12 bytes)

align 4
draw_edge_32bpp:
        push    eax 
.putpix:
        mov     eax, [esi+edx]
        mov     [edi+edx], eax
        sub     dl,  4
        jae     .putpix
.exit:
	mov	dl, bh
        pop     eax
        ret
align 4
draw_edge_24bpp:
        push    eax esi
	xor	dl, dl
.putpix:
        mov     eax, [esi]
        and     eax, 0x00FFFFFF
        mov     [edi+edx], eax
        test    dl, bh
        jz      .exit
        add     dl,  4
        add     esi, 3
        jmp     .putpix
.exit:
        pop     esi eax
        ret
align 4
draw_edge_8bpp:
        push    eax esi ebp
	xor	dl, dl
        mov     ebp, [img_palette]
.putpix:
        movzx   eax, byte[esi]
        mov     eax, [ebp+eax*4]
        mov     [edi+edx], eax
        test    dl, bh
        jz      .exit
        add     dl,  4
        inc     esi
        jmp     .putpix
.exit:
        pop     ebp esi eax
        ret
align 4
draw_edge_1bpp:
        push    eax ecx ebx ebp
        mov     ebp, [img_palette]
        mov     ebx, [ebp+4]            ; forecolor
        mov     ebp, [ebp]              ; backcolor
        mov     ecx, [img_edgeoffset]    ; cl = 1 << left_edge_pix_num
        mov     ebp, [esi]     
        xor     dl, dl
.testbit:
        test    ebp, ecx
        jnz     @f
        mov     eax, ebp 
        jmp     .putpix
@@:     mov     eax, ebx
.putpix:
        mov     [edi+edx], eax
        test    dl, bh
        jz      .exit
        add     dl, 4
        shl     ecx, 1
        jmp     .testbit
.exit:
        pop     ebp ebx ecx eax
        ret

draw_edge_16bpp:
draw_core_16bpp:
        ret

;-------------
; aligned core helpers
; esi -> left point address (image) 
; edi -> left point address (screen)
; cx  =  number of tiles to draw
align 4
draw_core_32bpp:
        push    ecx 
        shl     ecx, 1
        dec     ecx
.putpix:
        fld     qword[esi+ecx*8]        ; 2 qwords = 1 tile
        fstp    qword[edi+ecx*8]
        dec     cx
        jnb     .putpix
        pop     ecx 
        ret
align 4
draw_core_24bpp:
        push    eax ecx 
        shl     ecx, 2
        dec     ecx
        lea     eax, [ecx*2+ecx]
.putpix:
        mov     eax, [esi+eax]
        and     eax, 0x00FFFFFF
        mov     [edi+ecx*4], eax
        sub     dx, 3
        dec     cx
        jnb     .putpix
        pop     ecx eax
        ret
align 4
draw_core_8bpp:
        pushad 
        mov     ebp, [img_palette]
.putpix:
        xor     edx, edx
        mov     eax, dword[esi]         ; block of 4 pixels
.putone:
        movzx   ebx, al
        mov     ebx, [ebp+ebx*4]
        mov     [edi+edx*4], ebx
        shr     eax, 8
        inc     dl
        cmp     dl, 4
        jnz     .putone
        add     esi, edx        ;-)
        add     edi, 16
        dec     cx
        jnz     .putpix
.exit:
        popad
        ret
align 4
draw_core_1bpp:
        pushad   
        mov     ebp, [img_palette]      
        mov     edx, [ebp+4]            ; foreground color
        mov     ebp, [ebp]              ; background color
        mov     ebx, [img_bitoffset]
        shl     ecx, 2                  ; 1 tyle = 4 pix
        dec     ecx
        jb      .exit
.newblock:
        mov     eax, [esi]
.putpix:
        test    ebx, eax
        jz      .bkcolor
        mov     [edi], edx
        jmp     .nextpix
.bkcolor:
        mov     [edi], ebp
.nextpix:
        dec     cx
        jb      .exit  
        rol     ebx, 1
        jc      .nextblock
        add     edi, 4
        jmp     .putpix
.nextblock:
        add     esi, 4
        jmp     .newblock
.exit:
        popad     
        ret

;-----------------------------------------
virtual at esp
 putimg:
   .image_sx	   dd ?		; X-size (pix)
   .image_sy	   dd ?		; Y-size 
   .stack_data = 2*4
end virtual

align 4
; ebx -> Buffer origin
; ecx = packed size [x|y]
; edx = packed coordinates [x|y]

_putimage:
;     	call    [_display.disable_mouse]
	pushad
     	sub     esp, putimg.stack_data
     	mov     [img_buf_origin], ebx		; save pointer to image buffer
     	mov     esi, ebx		        ; pointer to image
.unpack_coords:
     	mov     eax, ecx
    	and     ecx, 0xFFFF			; Ysize
     	shr     eax, 16	                        ; Xsize
     	mov     [putimg.image_sy], ecx
     	mov     [putimg.image_sx], eax
    	mov     eax, edx
     	and     edx, 0xFFFF			; Ytop
     	shr     eax, 16			        ; Xleft
.calculate_abs_coords:
     	mov     ebx, [TASK_BASE-twdw + WDATA.box.left]
     	mov     ecx, [TASK_BASE-twdw + WDATA.box.top]
        add     ebx, eax
     	add     ecx, edx
     	mov     [img_screen_x], ebx		; abs Xleft
;     	mov     [img_screen_y], ecx		; ecx = abs Ytop        ; hold it !
.check_x_size:
     	mov     ebx, [TASK_BASE-twdw + WDATA.box.width] 
     	inc     ebx				; ebx = window Xsize
     	sub     ebx, eax                        ; eax = rel Xleft
     	jbe     .finish				; image is out of the window
        mov     eax, [putimg.image_sx]
     	cmp     ebx, eax		        ; real_sx = MIN(wnd_sx-image_cx, image_sx);
     	jae     @f
        mov     eax, ebx
@@:    	dec     eax
        mov     [img_pix_x], eax
.check_y_size:
     	mov     ebx, [TASK_BASE-twdw + WDATA.box.height] 
     	inc     ebx				; ebx = real window y-size
     	sub     ebx, edx                        ; edx = rel Ytop
     	jbe     .finish				; image isn't visible
        mov     edx, [putimg.image_sy]
        cmp     ebx, edx
        jae     @f
        mov     edx, ebx
@@:     mov     [img_pix_y], edx

.calculate_lfb_origin:
     	mov     edi, ecx                        ; ecx = absY
     	imul    edi, [BytesPerScanLine]
     	mov     eax, [img_screen_x]             ; eax = absX
     	lea     edi, [edi+eax*4]		
     	add     edi, LFB_BASE			; edi -> Screen origin
	mov	[img_lfb_origin], edi
.calculate_map_origin:
	xor	ebx, ebx
        mov     bl,  byte [img_bytes_per_pix]
        or      bl,  bl
        jnz     @f
        bts     ebx, 25
@@:    	mov     bl,  byte [CURRENT_TASK]	; get process number 
    	mov     ebp, ecx                        ; ecx = absY
	shr	ebp, 1				; CF= odd line
	jnc	@f
	bts	ebx, 24				; ebx[24] = odd start line
@@:    	imul    ebp, [_WinMapWidth]	
	add	ebp, [_WinMapAddress]
     	mov     ecx, eax                        ; eax = absX
	shr	ecx, 2                 
	add     eax, [img_pix_x]
        shr     eax, 2
        add     eax, ebp	
        mov     [img_map_right], eax		; right edge tile
     	add     ebp, ecx			; left edge Map origin
        mov	ecx, [img_pix_y]
        sub     eax, ebp
        jz      .thin_bar                       ; special case: all image is 1 tile  thick
        mov     [img_map_x], eax                ; tiles in row (excluding the right one) 

; ----- at this point:
; esi = [img_buf_origin] -> buffered image
; edi = [img_lfb_origin] -> LFB image (corner point, 0RGB format) 
; ebp -> corner tile position
; ecx = [img_pix_y] =  image height
;  bl = task #
; ebx[24] = 1 if the core Y is odd
; ebx[25] = 1bpp image

.start:
        bt      ebx, 25 
        jnc     @f
        xor     eax, eax
        inc     al
	mov	[img_bitoffset], eax		; 1bpp image must be byte-aligned
	mov	[img_edgeoffset], eax		
@@:
	mov	edx, edi
	and	edx, 0x0C       
        jz      .go_right                       ; left edge already aligned
.left_edge:
        mov     dh, 0x0C
        sub     dh, dl
        movzx   edx, dh
	call	draw_unaligned_edge
        dec     [img_map_x]
	shr	edi, 4
        inc     edi                             ; align edi to the next 16-byte tile
	shl	edi, 4
	mov	[img_lfb_origin], edi           ; core Screen origin
        shr     edx, 2
        inc     edx
        sub     [img_pix_x], edx                ; shrink image width      
        bt      ebx, 25
        jnc     @f  
        xchg    dl, cl
        mov     eax, [img_edgeoffset]           ; that's for 1bpp images only
        shl     eax, cl
        mov     [img_edgeoffset], eax
        mov     [img_bitoffset],  eax
        xchg    dl, cl
@@:     mov     eax, edx
        imul    eax, [img_bytes_per_pix]        ; 0 for 1bbp bitmaps
        add     esi, eax
        mov     [img_buf_origin], esi           ; core Buffer origin
        inc     ebp                             ; core Map origin
.go_right:
        mov     eax, [img_map_x]
        mov     edx, eax
        bt      ebx, 25                         ; 1bpp image ?
        jc      .shift_mono
        shl     eax, 2
        imul    eax, [img_bytes_per_pix]
        jmp     .get_right
.shift_mono:
        shr     eax, 1                          ; 2 tiles = 1 byte Buffer offset
        jnc     .get_right
        rol     byte [img_edgeoffset], 4        ; odd number of tiles: shift 4bits
.get_right:
        add     esi, eax                        ; rightEdge Buffer origin
        push    ebp
        add     ebp, edx                        ; rightEdge Map origin 
        mov     eax, [img_pix_x]
        shl     eax, 2                          ; 1 pix = 4 bytes
        add     eax, edi                        ; rightEdge last pix (LFB addr)
        movzx   edx, al 
        and     dl, 0x0C
        jz      .core_block             	; rightEdge is already tile-aligned
        and     al, 0xF0
        mov     edi, eax                        ; rightEdge Screen origin
.right_edge:
        call    draw_unaligned_edge
        dec     [img_map_x]             
.core_block:
        pop     ebp
        mov     eax, [img_map_x]
	or      eax, eax                        ; empty central core?
        jz      .finish
    	mov	edi, [img_lfb_origin]
	mov	esi, [img_buf_origin]
	
	call	draw_aligned_box
	
.finish:
     	add     esp, putimg.stack_data
;	call	[_display.enable_mouse]
	popad
	ret

.thin_bar:                                      ; < a special case > :  one-tile-wide image
        mov     edx, [img_pix_x]
        shl     edx, 2                          ; edx = rightmost tile offset (0, 4, 8, or 12 bytes)
        call    draw_unaligned_edge
        jmp     .finish


align 64
img_test_struct:
        dd      0x00112233, 0x00223344, 0x00334455, 0x00445566
        dd      0x00223344, 0x00334455, 0x00445566, 0x00334455
        dd      0x00334455, 0x00445566, 0x00334455, 0x00223344
        dd      0x00445566, 0x00334455, 0x00223344, 0x00112233

;**************************************************************************************
align 4
__sys_putpixel:
_putpixel:

; eax = x coordinate
; ebx = y coordinate
; ecx = ?? RR GG BB    ; 0x01000000 negation
; edi = 0x00000001 force

     	cmp   [Screen_Max_X], eax
     	jb    .exit0
     	cmp   [Screen_Max_Y], ebx
     	jb    .exit0
.check_forced:
     	test    edi,1		 ; force ?
     	jnz     .checked

.not_forced:
     	push    ebx eax
	shr	eax, 1
	shr	eax, 1
     	shr  	ebx, 1
     	imul    ebx, [_WinMapWidth]	  ; win_map (X size)/2
	add	ebx, eax
	mov	al, byte [CURRENT_TASK]
     	mov   	bl, byte [_WinMapAddress+ebx]
     	cmp     bl, al
     	pop     eax ebx
     	jne     .exit0
.checked:
	push	ebx
     	imul    ebx, [BytesPerScanLine]
     	lea     ebx, [ebx+eax*4]
     	bt      ecx, 24
     	jnc     .noneg
     	mov     ecx, [LFB_BASE+ebx]
	xor     ecx, 0x00FFFFFF
.noneg:
     	mov     [LFB_BASE+ebx], ecx
	pop	ebx
.exit0:
     ret



align 4
put_pixel:	; left for compatibility with Vesa20_putpixel32
; eax = x
; ebx = y
     imul    ebx, [BytesPerScanLine]	 ; ebx = y * y multiplier
     lea     edi, [ebx+eax*4]  ; edi = x*4+(y*y multiplier)
;     mov     eax, [esp+32-8+4] ; eax = color
     mov     [LFB_BASE+edi], ecx
     ret


; DRAWLINE

align 4
__sys_draw_line:
     call    [_display.disable_mouse]

; draw a line
; eax = HIWORD = x1
;       LOWORD = x2
; ebx = HIWORD = y1
;       LOWORD = y2
; ecx = color
; edi = force ?
	pusha

dl_x1 equ esp+20
dl_y1 equ esp+16
dl_x2 equ esp+12
dl_y2 equ esp+8
dl_dx equ esp+4
dl_dy equ esp+0

     xor     edx, edx	   ; clear edx
     xor     esi, esi	   ; unpack arguments
     xor     ebp, ebp
     mov     si, ax	   ; esi = x2
     mov     bp, bx	   ; ebp = y2
     shr     eax, 16	   ; eax = x1
     shr     ebx, 16	   ; ebx = y1
     push    eax	   ; save x1
     push    ebx	   ; save y1
     push    esi	   ; save x2
     push    ebp	   ; save y2

; checking x-axis...
     sub     esi, eax	   ; esi = x2-x1
     push    esi	   ; save y2-y1
     jl      .x2lx1	   ; is x2 less than x1 ?
     jg      .no_vline	   ; x1 > x2 ?
     mov     edx, ebp	   ; else (if x1=x2)
     call    vline
     push    edx    ; necessary to rightly restore stack frame at .exit
     jmp     .exit
.x2lx1:
     neg     esi	    ; get esi absolute value
.no_vline:
; checking y-axis...
     sub     ebp, ebx	    ; ebp = y2-y1
     push    ebp	    ; save y2-y1
     jl      .y2ly1	    ; is y2 less than y1 ?
     jg      .no_hline	    ; y1 > y2 ?
     mov     edx, [dl_x2]   ; else (if y1=y2)
     call    hline
     jmp     .exit

.y2ly1:
     neg     ebp	    ; get ebp absolute value
.no_hline:
     cmp     ebp, esi
     jle     .x_rules	    ; |y2-y1| < |x2-x1|  ?
     cmp     [dl_y2], ebx   ; make sure y1 is at the begining
     jge     .no_reverse1
     neg     dword [dl_dx]
     mov     edx, [dl_x2]
     mov     [dl_x2], eax
     mov     [dl_x1], edx
     mov     edx, [dl_y2]
     mov     [dl_y2], ebx
     mov     [dl_y1], edx
.no_reverse1:
     mov     eax, [dl_dx]
     cdq		    ; extend eax sing to edx
     shl     eax, 16	    ; using 16bit fix-point maths
     idiv    ebp	    ; eax = ((x2-x1)*65536)/(y2-y1)
     mov     edx, ebp	    ; edx = counter (number of pixels to draw)
     mov     ebp, 1 *65536  ; <<16   ; ebp = dy = 1.0
     mov     esi, eax	    ; esi = dx
     jmp     .y_rules

.x_rules:
     cmp     [dl_x2], eax    ; make sure x1 is at the begining
     jge     .no_reverse2
     neg     dword [dl_dy]
     mov     edx, [dl_x2]
     mov     [dl_x2], eax
     mov     [dl_x1], edx
     mov     edx, [dl_y2]
     mov     [dl_y2], ebx
     mov     [dl_y1], edx
.no_reverse2:
     xor     edx, edx
     mov     eax, [dl_dy]
     cdq		    ; extend eax sing to edx
     shl     eax, 16	    ; using 16bit fix-point maths
     idiv    esi	    ; eax = ((y2-y1)*65536)/(x2-x1)
     mov     edx, esi	    ; edx = counter (number of pixels to draw)
     mov     esi, 1 *65536  ;<< 16   ; esi = dx = 1.0
     mov     ebp, eax	    ; ebp = dy
.y_rules:
     mov     eax, [dl_x1]
     mov     ebx, [dl_y1]
     shl     eax, 16
     shl     ebx, 16
align 4
.draw:
     push    eax ebx
     shr     eax, 16
     shr     ebx, 16
     call    _putpixel
     pop     ebx eax
     add     ebx, ebp	     ; y = y+dy
     add     eax, esi	     ; x = x+dx
     dec     edx
     jnz     .draw
; force last drawn pixel to be at (x2,y2)
     mov     eax, [dl_x2]
     mov     ebx, [dl_y2]
     call    _putpixel
.exit:
     add     esp, 6*4
     popa
     call   [draw_pointer]	; mouse 
     ret

align 4
hline:
; ------------  draw a horizontal line -------------
; eax = x1
; edx = x2
; ebx = y
; ecx = color
; edi = force ?
     cmp     ebx, [Screen_Max_Y]
     jge     .out
     pushad

     bt      ecx, 24			; color inversion check
     rcl     edi,1			; forced graphics check

     mov     ebp, ebx
     shr     ebp, 1
     imul    ebp, [_WinMapWidth]	; ebp = screen map base
     add     ebp, [_WinMapAddress]

     cmp     edx, eax			; to make sure x2 > x1
     jge     @f
     xchg    eax, edx
@@:
     cmp     eax, [Screen_Max_X]
     jge     .exit

     mov     esi, eax
     shr     esi, 4
     add     ebp, esi			; ebp -> win_map element

     imul    ebx, [BytesPerScanLine]	; ebx -> LFB pix_line
     add     ebx, LFB_BASE

     cmp     edx, [Screen_Max_X]	; last check
     jb      @f
     mov     edx, [Screen_Max_X]

@@:  mov     esi, ecx			; store color here
     mov     cl, byte [CURRENT_TASK]	;
     mov     ch, cl
     mov     [CURRENT_TASK+2], cx
     mov     [CURRENT_TASK+1], cl	; replicate byte to dword

.newsegment:
     mov     ecx, [ebp] 		; check the line segment (16 pixels!)
     xor     ecx, [CURRENT_TASK]
; -- the line ---
     jmp     dword [hline.drawtable + edi*4]	; a coolhack (C) Serge


align 4 				; internal loop
.invert_color:
     mov     esi, [ebx+eax*4]
     xor     esi, 0x00FFFFFF
align 4
.check_overlap:
     or      cl, cl
     jz      .putpixel
     jmp     .nextpixel
align 4
.invert_force:
     mov     esi, [ebx+eax*4]
     xor     esi, 0x00FFFFFF
align 4
.putpixel:
     mov     [ebx+eax*4], esi
align 4
.nextpixel:
     inc     eax
     cmp     eax, edx
     ja      .exit				; line drawn -- exit all loops
     test    al, 3
     jz     .newtile
.newpixel:
     jmp     dword [hline.drawtable + edi*4]	; the internal loop
.newtile:
     inc     ebp
     test    ebp, 3
     jz     .newsegment				; the external loop
     shr     ecx, 8
     jmp     dword [hline.drawtable + edi*4]

.exit:
     mov    eax, 0x0FF
     and    [CURRENT_TASK], eax
     popad
.out:
     ret
align 4
.drawtable:
dd	.check_overlap	; general case
dd	.invert_color
dd	.putpixel	; force to draw it
dd	.invert_force


align 4
vline:
; ---------  draw a vertical line  ------------
; eax = x
; ebx = y1
; edx = y2
; ecx = color
; edi = force ?
     cmp     eax, [Screen_Max_X]
     jge     .out
     pushad
     bt      ecx, 24			; color inversion check
     rcl     edi, 1			; forced graphics check

     cmp     edx, ebx			; to make sure y2 > y1
     jge     @f
     xchg    ebx, edx
@@:
     cmp     ebx, [Screen_Max_Y]
     jge     .exit
     mov     ebp, ebx
     shr     ebp, 1
     imul    ebp, [_WinMapWidth]
     add     ebp, [_WinMapAddress]
     mov     esi, eax
     shr     esi, 1
     shr     esi, 1
     add     ebp, esi			; ebp = screen map at (x, y1)
     push    ebx

     imul    ebx, [BytesPerScanLine]
     shl     eax, 1
     shl     eax, 1
     add     eax, ebx
     add     eax, LFB_BASE
     pop     ebx			; restore ebx = y1
     cmp     edx, [Screen_Max_Y]	; the last check
     jb     .draw
     mov     edx, [Screen_Max_Y]	; to prevent off-screen drawing

.draw:
     jmp     dword [vline.drawtable + edi*4]
align 4
.invert_color:
     mov     ecx, [eax]
     xor     ecx, 0x00FFFFFF
align 4
.check_overlap:
     movzx   esi, byte [ebp]
     cmp     esi, [CURRENT_TASK]
     je      .putpixel
     jmp     .nextpixel

align 4
.invert_force:
     mov     ecx, [eax]
     xor     ecx, 0x00FFFFFF
align 4
.putpixel:
     mov     [eax], ecx
align 4
.nextpixel:
     add     eax, [BytesPerScanLine]
     inc     ebx
     test    bl, 1
     jnz     @f
     add     ebp, [_WinMapWidth]	
@@:     
     cmp     ebx, edx
     ja     .exit
     jmp     dword [vline.drawtable + edi*4]
.exit:
     shr     edi, 1
     popad

.out:
     ret
align 4
.drawtable:
dd	.check_overlap	; general case
dd	.invert_color
dd	.putpixel	; force to draw it
dd	.invert_force


;*************************************************


virtual at esp
drbar:
     .bar_sx	   dd ?
     .bar_sy	   dd ?
     .bar_cx	   dd ?
     .bar_cy	   dd ?
     .abs_cx	   dd ?
     .abs_cy	   dd ?
     .real_sx	   dd ?
     .real_sy	   dd ?
     .color	   dd ?
     .line_inc_scr dd ?
     .line_inc_map dd ?
     .stack_data = 4*11
end virtual

align 4
; eax   cx
; ebx   cy
; ecx   xe
; edx   ye
; edi   color
vesa20_drawbar:
     pushad
     call    [_display.disable_mouse]
     sub     esp, drbar.stack_data
     mov     [drbar.color], edi
     sub     edx, ebx
     jle     .exit
     sub     ecx, eax
     jle     .exit
     mov     [drbar.bar_sy], edx
     mov     [drbar.bar_sx], ecx
     mov     [drbar.bar_cx], eax
     mov     [drbar.bar_cy], ebx
     mov     edi, [TASK_BASE]
     add     eax, [edi-twdw + WDATA.box.left] ; win_cx
     add     ebx, [edi-twdw + WDATA.box.top] ; win_cy
     mov     [drbar.abs_cx], eax
     mov     [drbar.abs_cy], ebx
; real_sx = MIN(wnd_sx-bar_cx, bar_sx);
     mov     ebx, [edi-twdw + WDATA.box.width] ; ebx = wnd_sx
; note that WDATA.box.width is one pixel less than real window x-size
     inc     ebx
     sub     ebx, [drbar.bar_cx]
     ja      @f
.exit:
     add     esp, drbar.stack_data
     popad
     xor     eax, eax
     inc     eax
     ret
@@:
     cmp     ebx, [drbar.bar_sx]
     jbe     .end_x
     mov     ebx, [drbar.bar_sx]
.end_x:
     mov     [drbar.real_sx], ebx
; real_sy = MIN(wnd_sy-bar_cy, bar_sy);
     mov     ebx, [edi-twdw + WDATA.box.height] ; ebx = wnd_sy
     inc     ebx
     sub     ebx, [drbar.bar_cy]
     ja      @f
     add     esp, drbar.stack_data
     popad
     xor     eax, eax
     inc     eax
     ret
@@:
     cmp     ebx, [drbar.bar_sy]
     jbe     .end_y
     mov     ebx, [drbar.bar_sy]
.end_y:
     mov     [drbar.real_sy], ebx
; line_inc_map
     mov     eax, [Screen_Max_X]
     sub     eax, [drbar.real_sx]
     inc     eax
     shr     eax, 1			; <<<<<<
     shr     eax, 1
     mov     [drbar.line_inc_map], eax	; vertical increment: map
; line_inc_scr
     mov     eax, [drbar.real_sx]
     shl     eax, 1
     shl     eax, 1
     neg     eax
     add     eax, [BytesPerScanLine]
     mov     [drbar.line_inc_scr], eax	; vertical increment: screen
; pointer to screen
     mov     edx, [drbar.abs_cy]
     mov     ebx, edx
     imul    edx, [BytesPerScanLine]    ; edx = LFB line offset
     mov     eax, [drbar.abs_cx]
     shl     eax, 1
     shl     eax, 1
     add     edx, eax			; edx = LFB corner offset
; pointer to pixel map
     shr     ebx, 1
     imul    ebx, [_WinMapWidth]	; eax = Wmap corner pos
     mov     eax, [drbar.abs_cx]
     shr     eax, 1
     shr     eax, 1
     add     eax, ebx
     add     eax, [_WinMapAddress]
     xchg    eax, ebp			; ebp = Wmap corner
; get process number
     mov     ebx, [CURRENT_TASK]

; eax - RGB-color   
; bl - process num
; ecx - pix counter (in a tile)
; edx - pointer to screen
; esi - counter
; edi - counter

     	mov     eax, [drbar.color]    ;; BBGGRR00
     	mov     esi, 0
align	4
.new_y:
     	mov     edi, [drbar.real_sx]
     	movzx   ecx, dl
     	shr	cl, 2		; pix# = edx/4
	and     cl, 3   	; pix position in a tile
.new_tile:
	cmp     byte [ebp], bl
	jne     .skip
.new_x:
	mov     [LFB_BASE+edx], eax
	add     edx, 4
	dec     edi
	jz      .add_line
	inc	cl
	and	cl, 3
	jnz	.new_x
	jmp	.new_tile	
.skip:
     	add     edx, 4*4
     	and     dl, 0xF0	; LFB align 16
     	inc     ebp
     	sub     edi, 4     	; <<<<< 
	add	edi, ecx	; left tile may be 1,2 or 3px only 
     	jae     .new_tile

.add_line:
     	add     edx, [drbar.line_inc_scr] 
; gradient-filled bars
     test    eax, 0x80000000
     jz      @f
     test    al, al
     jz      @f
     dec     al
@@:
     	inc     esi
     	test    esi, 1
  	jne 	@f
     	add     ebp, [drbar.line_inc_map]
@@:	
     	cmp     esi, [drbar.real_sy]
     	jbe     .new_y
     	add     esp, drbar.stack_data
     	popad
     	xor     eax, eax
     ret


align 4
;drawbackground:
	call	[_display.disable_mouse]
	pushad
; External loop for all y from start to end
	mov	ebx, [draw_data+32+RECT.top]	; y start
.fill_line:
	mov	edi, [draw_data+32+RECT.left]	; x start
	shl  	edi, 1
	shl	edi, 1
	mov	eax, [BytesPerScanLine]
	mul	ebx
	xchg	edi, eax
	add	edi, eax
	add	edi, LFB_BASE

	mov	ebp, ebx
	shr	ebp, 1
	imul	ebp, [_WinMapWidth]
	mov	edx, eax
	shr	edx, 1
	shr	edx, 1
	add	ebp, edx
	add 	ebp, [_WinMapAddress]
	xor	edx, edx
	inc	edx
	mov	esi, 0x0336677		; <<< RGB
; eax = x, ebx = y (screen coordinates)
; ecx - aux. var 
; edx = 1
; esi = 0RGB, edi -> output
; ebp = offset in WinMapAddress
.fill_tile:
	cmp	[ebp], dl
	jnz	.next_tile
	mov     [edi],   esi
	mov     [edi+4], esi
	mov     [edi+8], esi
	mov     [edi+12],esi
	mov	ecx, [BytesPerScanLine]
	mov     [ecx+edi],   esi
	mov     [ecx+edi+4], esi
	mov     [ecx+edi+8], esi
	mov     [ecx+edi+12],esi
.next_tile:
	add	edi, 4*4
	add	ebp, edx
	add	ax, 4
	mov	ecx, [draw_data+32+RECT.right]
	shr     ecx, 1
        shr     ecx, 1
	cmp	eax, ecx
	jbe	.fill_tile

.next_line:
	inc	ebx
	mov	ecx, [draw_data+32+RECT.bottom]
	shr	ecx, 1
	jbe	.fill_line
	popad
	ret

; ----------


drawbackground_stretch:		; left for future development
	call	drawbackground
	ret
drawbackground_tiled:		; left for future development
	call	drawbackground
	ret

uglobal
align 4
bgr_cur_line	rd	1920	; maximum width of screen
bgr_next_line	rd	1920
endg

smooth_line:
	mov	al, [esi+2]
	shl	eax, 16
	mov	ax, [esi]
	test	ecx, ecx
	jz	@f
	mov	ebx, [esi+2]
	shr	ebx, 8
	call	[overlapping_of_points_ptr]
@@:
	stosd
	mov	eax, [esp+20+8]
	inc	eax
	mov	[esp+20+8], eax
	cmp	eax, [draw_data+32+RECT.right]
	ja	@f
	add	ecx, [esp+36+8]
	mov	eax, edx
	adc	edx, [esp+40+8]
	sub	eax, edx
	lea	eax, [eax*3]
	sub	esi, eax
	jmp	smooth_line
@@:
	mov	eax, [draw_data+32+RECT.left]
	mov	[esp+20+8], eax
	ret

align 16
overlapping_of_points:
	push	ecx edx
	mov	edx, eax
	push	esi
	shr	ecx, 26
	mov	esi, ecx
	mov	ecx, ebx
	shl	esi, 9
	movzx	ebx, dl
	movzx	eax, cl
	sub	eax, ebx
	movzx	ebx, dh
	add	dl, [BgrAuxTable+(eax+0x100)+esi]
	movzx	eax, ch
	sub	eax, ebx
	add	dh, [BgrAuxTable+(eax+0x100)+esi]
	ror	ecx, 16
	ror	edx, 16
	movzx	eax, cl
	movzx	ebx, dl
	sub	eax, ebx
	add	dl, [BgrAuxTable+(eax+0x100)+esi]
	pop	esi
	mov	eax, edx
	pop	edx
	ror	eax, 16
	pop	ecx
	ret

iglobal
align 4
overlapping_of_points_ptr	dd	overlapping_of_points
endg

init_background:
	mov	edi, BgrAuxTable
	xor	edx, edx
.loop2:
	mov	eax, edx
	shl	eax, 8
	neg	eax
	mov	ecx, 0x200
.loop1:
	mov	byte [edi], ah
	inc	edi
	add	eax, edx
	loop	.loop1
	add	dl, 4
	jnz	.loop2
	test	byte [cpu_caps+(CAPS_MMX/8)], 1 shl (CAPS_MMX mod 8)
	jz	@f
	mov	[overlapping_of_points_ptr], overlapping_of_points_mmx
@@:
	ret

align 16
overlapping_of_points_mmx:
	movd	mm0, eax
	movd	mm4, eax
	movd	mm1, ebx
	pxor	mm2, mm2
	punpcklbw mm0, mm2
	punpcklbw mm1, mm2
	psubw	mm1, mm0
	movd	mm3, ecx
	psrld	mm3, 24
	packuswb mm3, mm3
	packuswb mm3, mm3
	pmullw	mm1, mm3
	psrlw	mm1, 8
	packuswb mm1, mm2
	paddb	mm4, mm1
	movd	eax, mm4
	ret
diff16 "GRAPH32 code end ",0,$
diff10 "GRAPH32 code size",get_pixel,$