;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; 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,$