| 0,0 → 1,1237 |
|---|
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; 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,$ |
| |
| |