| /kernel/branches/Kolibri-A/trunk/video/vesa20.inc |
|---|
| 0,0 → 1,1150 |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
| ;; Distributed under terms of the GNU General Public License ;; |
| ;; ;; |
| ;; VESA20.INC ;; |
| ;; ;; |
| ;; Vesa 2.0 functions for MenuetOS ;; |
| ;; ;; |
| ;; Copyright 2002 Ville Turjanmaa ;; |
| ;; Alexey, kgaz@crosswindws.net ;; |
| ;; - Voodoo compatible graphics ;; |
| ;; Juan M. Caravaca ;; |
| ;; - Graphics optimimizations eg. drawline ;; |
| ;; ;; |
| ;; See file COPYING for details ;; |
| ;; ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| $Revision$ |
| ; If you're planning to write your own video driver I suggest |
| ; you replace the VESA12.INC file and see those instructions. |
| ;Screen_Max_X equ 0xfe00 |
| ;Screen_Max_Y equ 0xfe04 |
| ;BytesPerScanLine equ 0xfe08 |
| ;LFBAddress equ 0xfe80 |
| ;ScreenBPP equ 0xfbf1 |
| ;************************************************* |
| ; getpixel |
| ; |
| ; in: |
| ; eax = x coordinate |
| ; ebx = y coordinate |
| ; |
| ; ret: |
| ; ecx = 00 RR GG BB |
| getpixel: |
| push eax ebx edx edi |
| call dword [GETPIXEL] |
| pop edi edx ebx eax |
| ret |
| Vesa20_getpixel24: |
| ; eax = x |
| ; ebx = y |
| imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier |
| lea edi, [eax+eax*2] ; edi = x*3 |
| add edi, ebx ; edi = x*3+(y*y multiplier) |
| mov ecx, [LFB_BASE+edi] |
| and ecx, 0xffffff |
| ret |
| Vesa20_getpixel32: |
| imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier |
| lea edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier) |
| mov ecx, [LFB_BASE+edi] |
| and ecx, 0xffffff |
| ret |
| ;************************************************* |
| virtual at esp |
| putimg: |
| .real_sx dd ? |
| .real_sy dd ? |
| .image_sx dd ? |
| .image_sy dd ? |
| .image_cx dd ? |
| .image_cy dd ? |
| .pti dd ? |
| .abs_cx dd ? |
| .abs_cy dd ? |
| .line_increment dd ? |
| .winmap_newline dd ? |
| .screen_newline dd ? |
| .stack_data = 4*12 |
| .edi dd ? |
| .esi dd ? |
| .ebp dd ? |
| .esp dd ? |
| .ebx dd ? |
| .edx dd ? |
| .ecx dd ? |
| .eax dd ? |
| .ret_addr dd ? |
| .arg_0 dd ? |
| end virtual |
| align 16 |
| ; ebx = pointer |
| ; ecx = size [x|y] |
| ; edx = coordinates [x|y] |
| ; ebp = pointer to 'get' function |
| ; esi = pointer to 'init' function |
| ; edi = parameter for 'get' function |
| vesa20_putimage: |
| pushad |
| call [_display.disable_mouse] |
| sub esp, putimg.stack_data |
| ; save pointer to image |
| mov [putimg.pti], ebx |
| ; unpack the size |
| mov eax, ecx |
| and ecx, 0xFFFF |
| shr eax, 16 |
| mov [putimg.image_sx], eax |
| mov [putimg.image_sy], ecx |
| ; unpack the coordinates |
| mov eax, edx |
| and edx, 0xFFFF |
| shr eax, 16 |
| mov [putimg.image_cx], eax |
| mov [putimg.image_cy], edx |
| ; calculate absolute (i.e. screen) coordinates |
| mov eax, [TASK_BASE] |
| mov ebx, [eax-twdw + WDATA.box.left] |
| add ebx, [putimg.image_cx] |
| mov [putimg.abs_cx], ebx |
| mov ebx, [eax-twdw + WDATA.box.top] |
| add ebx, [putimg.image_cy] |
| mov [putimg.abs_cy], ebx |
| ; real_sx = MIN(wnd_sx-image_cx, image_sx); |
| mov ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx |
| ; \begin{diamond}[20.08.2006] |
| ; note that WDATA.box.width is one pixel less than real window x-size |
| inc ebx |
| ; \end{diamond}[20.08.2006] |
| sub ebx, [putimg.image_cx] |
| ja @f |
| add esp, putimg.stack_data |
| popad |
| ret |
| @@: |
| cmp ebx, [putimg.image_sx] |
| jbe .end_x |
| mov ebx, [putimg.image_sx] |
| .end_x: |
| mov [putimg.real_sx], ebx |
| ; init real_sy |
| mov ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy |
| ; \begin{diamond}[20.08.2006] |
| inc ebx |
| ; \end{diamond}[20.08.2006] |
| sub ebx, [putimg.image_cy] |
| ja @f |
| add esp, putimg.stack_data |
| popad |
| ret |
| @@: |
| cmp ebx, [putimg.image_sy] |
| jbe .end_y |
| mov ebx, [putimg.image_sy] |
| .end_y: |
| mov [putimg.real_sy], ebx |
| ; line increment |
| mov eax, [putimg.image_sx] |
| mov ecx, [putimg.real_sx] |
| sub eax, ecx |
| ;; imul eax, [putimg.source_bpp] |
| ; lea eax, [eax + eax * 2] |
| call esi |
| add eax, [putimg.arg_0] |
| mov [putimg.line_increment], eax |
| ; winmap new line increment |
| mov eax, [Screen_Max_X] |
| inc eax |
| sub eax, [putimg.real_sx] |
| mov [putimg.winmap_newline], eax |
| ; screen new line increment |
| mov eax, [BytesPerScanLine] |
| movzx ebx, byte [ScreenBPP] |
| shr ebx, 3 |
| imul ecx, ebx |
| sub eax, ecx |
| mov [putimg.screen_newline], eax |
| ; pointer to image |
| mov esi, [putimg.pti] |
| ; pointer to screen |
| mov edx, [putimg.abs_cy] |
| imul edx, [BytesPerScanLine] |
| mov eax, [putimg.abs_cx] |
| movzx ebx, byte [ScreenBPP] |
| shr ebx, 3 |
| imul eax, ebx |
| add edx, eax |
| ; pointer to pixel map |
| mov eax, [putimg.abs_cy] |
| imul eax, [Screen_Max_X] |
| add eax, [putimg.abs_cy] |
| add eax, [putimg.abs_cx] |
| add eax, [_WinMapAddress] |
| xchg eax, ebp |
| ; get process number |
| mov ebx, [CURRENT_TASK] |
| cmp byte [ScreenBPP], 32 |
| je put_image_end_32 |
| ;put_image_end_24: |
| mov edi, [putimg.real_sy] |
| align 4 |
| .new_line: |
| mov ecx, [putimg.real_sx] |
| ; push ebp edx |
| align 4 |
| .new_x: |
| push [putimg.edi] |
| mov eax, [putimg.ebp+4] |
| call eax |
| cmp [ebp], bl |
| jne .skip |
| ; mov eax, [esi] ; eax = RRBBGGRR |
| mov [LFB_BASE+edx], ax |
| shr eax, 16 |
| mov [LFB_BASE+edx+2], al |
| .skip: |
| ; add esi, 3 ;[putimg.source_bpp] |
| add edx, 3 |
| inc ebp |
| dec ecx |
| jnz .new_x |
| ; pop edx ebp |
| add esi, [putimg.line_increment] |
| add edx, [putimg.screen_newline] ;[BytesPerScanLine] |
| add ebp, [putimg.winmap_newline] ;[Screen_Max_X] |
| ; inc ebp |
| cmp [putimg.ebp], putimage_get1bpp |
| jz .correct |
| cmp [putimg.ebp], putimage_get2bpp |
| jz .correct |
| cmp [putimg.ebp], putimage_get4bpp |
| jnz @f |
| .correct: |
| mov eax, [putimg.edi] |
| mov byte [eax], 80h |
| @@: |
| dec edi |
| jnz .new_line |
| .finish: |
| add esp, putimg.stack_data |
| popad |
| ret |
| put_image_end_32: |
| mov edi, [putimg.real_sy] |
| align 4 |
| .new_line: |
| mov ecx, [putimg.real_sx] |
| ; push ebp edx |
| align 4 |
| .new_x: |
| push [putimg.edi] |
| mov eax, [putimg.ebp+4] |
| call eax |
| cmp [ebp], bl |
| jne .skip |
| ; mov eax, [esi] ; ecx = RRBBGGRR |
| mov [LFB_BASE+edx], eax |
| .skip: |
| ; add esi, [putimg.source_bpp] |
| add edx, 4 |
| inc ebp |
| dec ecx |
| jnz .new_x |
| ; pop edx ebp |
| add esi, [putimg.line_increment] |
| add edx, [putimg.screen_newline] ;[BytesPerScanLine] |
| add ebp, [putimg.winmap_newline] ;[Screen_Max_X] |
| ; inc ebp |
| cmp [putimg.ebp], putimage_get1bpp |
| jz .correct |
| cmp [putimg.ebp], putimage_get2bpp |
| jz .correct |
| cmp [putimg.ebp], putimage_get4bpp |
| jnz @f |
| .correct: |
| mov eax, [putimg.edi] |
| mov byte [eax], 80h |
| @@: |
| dec edi |
| jnz .new_line |
| .finish: |
| add esp, putimg.stack_data |
| popad |
| call VGA__putimage |
| mov [EGA_counter],1 |
| ret |
| ;************************************************* |
| align 4 |
| __sys_putpixel: |
| ; eax = x coordinate |
| ; ebx = y coordinate |
| ; ecx = ?? RR GG BB ; 0x01000000 negation |
| ; edi = 0x00000001 force |
| ;;; mov [novesachecksum], dword 0 |
| pushad |
| cmp [Screen_Max_X], eax |
| jb .exit |
| cmp [Screen_Max_Y], ebx |
| jb .exit |
| test edi,1 ; force ? |
| jnz .forced |
| ; not forced: |
| push eax |
| mov edx,[_display.width] ; screen x size |
| imul edx, ebx |
| add eax, [_WinMapAddress] |
| movzx edx, byte [eax+edx] |
| cmp edx, [CURRENT_TASK] |
| pop eax |
| jne .exit |
| .forced: |
| ; check if negation |
| test ecx,0x01000000 |
| jz .noneg |
| call getpixel |
| not ecx |
| mov [esp+32-8],ecx |
| .noneg: |
| ; OK to set pixel |
| call dword [PUTPIXEL] ; call the real put_pixel function |
| .exit: |
| popad |
| ret |
| align 4 |
| Vesa20_putpixel24: |
| ; eax = x |
| ; ebx = y |
| imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier |
| lea edi, [eax+eax*2] ; edi = x*3 |
| mov eax, [esp+32-8+4] |
| mov [LFB_BASE+ebx+edi], ax |
| shr eax, 16 |
| mov [LFB_BASE+ebx+edi+2], al |
| ret |
| align 4 |
| 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], eax |
| ret |
| ;************************************************* |
| ;align 4 |
| calculate_edi: |
| mov edi, ebx |
| imul edi, [Screen_Max_X] |
| add edi, ebx |
| add edi, eax |
| ret |
| ;************************************************* |
| ; DRAWLINE |
| align 4 |
| __sys_draw_line: |
| ; inc [mouse_pause] |
| 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 |
| ; dec [mouse_pause] |
| call [draw_pointer] |
| ret |
| hline: |
| ; draw an horizontal line |
| ; eax = x1 |
| ; edx = x2 |
| ; ebx = y |
| ; ecx = color |
| ; edi = force ? |
| push eax edx |
| cmp edx, eax ; make sure x2 is above x1 |
| jge @f |
| xchg eax, edx |
| align 4 |
| @@: |
| call [putpixel] |
| inc eax |
| cmp eax, edx |
| jle @b |
| pop edx eax |
| ret |
| vline: |
| ; draw a vertical line |
| ; eax = x |
| ; ebx = y1 |
| ; edx = y2 |
| ; ecx = color |
| ; edi = force ? |
| push ebx edx |
| cmp edx, ebx ; make sure y2 is above y1 |
| jge @f |
| xchg ebx, edx |
| align 4 |
| @@: |
| call [putpixel] |
| inc ebx |
| cmp ebx, edx |
| jle @b |
| pop edx ebx |
| ret |
| ;************************************************* |
| 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 ;// mike.dld, 2005-01-29 |
| sub ecx, eax |
| jle .exit ;// mike.dld, 2005-01-29 |
| 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 |
| ; \begin{diamond}[20.08.2006] |
| ; note that WDATA.box.width is one pixel less than real window x-size |
| inc ebx |
| ; \end{diamond}[20.08.2006] |
| sub ebx, [drbar.bar_cx] |
| ja @f |
| .exit: ;// mike.dld, 2005-01-29 |
| 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 |
| ; \begin{diamond}[20.08.2006] |
| inc ebx |
| ; \end{diamond} |
| 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 |
| mov [drbar.line_inc_map], eax |
| ; line_inc_scr |
| mov eax, [drbar.real_sx] |
| movzx ebx, byte [ScreenBPP] |
| shr ebx, 3 |
| imul eax, ebx |
| neg eax |
| add eax, [BytesPerScanLine] |
| mov [drbar.line_inc_scr], eax |
| ; pointer to screen |
| mov edx, [drbar.abs_cy] |
| imul edx, [BytesPerScanLine] |
| mov eax, [drbar.abs_cx] |
| ; movzx ebx, byte [ScreenBPP] |
| ; shr ebx, 3 |
| imul eax, ebx |
| add edx, eax |
| ; pointer to pixel map |
| mov eax, [drbar.abs_cy] |
| imul eax, [Screen_Max_X] |
| add eax, [drbar.abs_cy] |
| add eax, [drbar.abs_cx] |
| add eax, [_WinMapAddress] |
| xchg eax, ebp |
| ; get process number |
| mov ebx, [CURRENT_TASK] |
| cmp byte [ScreenBPP], 24 |
| jne draw_bar_end_32 |
| draw_bar_end_24: |
| mov eax, [drbar.color] ;; BBGGRR00 |
| mov bh, al ;; bh = BB |
| shr eax, 8 ;; eax = RRGG |
| ; eax - color high RRGG |
| ; bl - process num |
| ; bh - color low BB |
| ; ecx - temp |
| ; edx - pointer to screen |
| ; esi - counter |
| ; edi - counter |
| mov esi, [drbar.real_sy] |
| align 4 |
| .new_y: |
| mov edi, [drbar.real_sx] |
| align 4 |
| .new_x: |
| cmp byte [ebp], bl |
| jne .skip |
| mov [LFB_BASE+edx], bh |
| mov [LFB_BASE+edx + 1], ax |
| .skip: |
| ; add pixel |
| add edx, 3 |
| inc ebp |
| dec edi |
| jnz .new_x |
| ; add line |
| add edx, [drbar.line_inc_scr] |
| add ebp, [drbar.line_inc_map] |
| ; <Ivan 15.10.04> drawing gradient bars |
| test eax, 0x00800000 |
| jz @f |
| test bh, bh |
| jz @f |
| dec bh |
| @@: |
| ; </Ivan 15.10.04> |
| dec esi |
| jnz .new_y |
| add esp, drbar.stack_data |
| popad |
| xor eax, eax |
| ret |
| draw_bar_end_32: |
| mov eax, [drbar.color] ;; BBGGRR00 |
| mov esi, [drbar.real_sy] |
| align 4 |
| .new_y: |
| mov edi, [drbar.real_sx] |
| align 4 |
| .new_x: |
| cmp byte [ebp], bl |
| jne .skip |
| mov [LFB_BASE+edx], eax |
| .skip: |
| ; add pixel |
| add edx, 4 |
| inc ebp |
| dec edi |
| jnz .new_x |
| ; add line |
| add edx, [drbar.line_inc_scr] |
| add ebp, [drbar.line_inc_map] |
| ; <Ivan 15.10.04> drawing gradient bars |
| test eax, 0x80000000 |
| jz @f |
| test al, al |
| jz @f |
| dec al |
| @@: |
| ; </Ivan 15.10.04> |
| dec esi |
| jnz .new_y |
| add esp, drbar.stack_data |
| popad |
| call VGA_draw_bar |
| xor eax, eax |
| mov [EGA_counter],1 |
| ret |
| align 4 |
| vesa20_drawbackground_tiled: |
| call [_display.disable_mouse] |
| pushad |
| ; External loop for all y from start to end |
| mov ebx, [draw_data+32+RECT.top] ; y start |
| dp2: |
| mov ebp, [draw_data+32+RECT.left] ; x start |
| ; 1) Calculate pointers in WinMapAddress (does pixel belong to OS thread?) [ebp] |
| ; and LFB data (output for our function) [edi] |
| mov eax, [BytesPerScanLine] |
| mul ebx |
| xchg ebp, eax |
| add ebp, eax |
| add ebp, eax |
| add ebp, eax |
| cmp [ScreenBPP], byte 24 ; 24 or 32 bpp ? - x size |
| jz @f |
| add ebp, eax |
| @@: |
| add ebp, LFB_BASE |
| ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB |
| call calculate_edi |
| xchg edi, ebp |
| add ebp, [_WinMapAddress] |
| ; Now eax=x, ebx=y, edi->output, ebp=offset in WinMapAddress |
| ; 2) Calculate offset in background memory block |
| push eax |
| xor edx, edx |
| mov eax, ebx |
| div dword [BgrDataHeight] ; edx := y mod BgrDataHeight |
| pop eax |
| push eax |
| mov ecx, [BgrDataWidth] |
| mov esi, edx |
| imul esi, ecx ; esi := (y mod BgrDataHeight) * BgrDataWidth |
| xor edx, edx |
| div ecx ; edx := x mod BgrDataWidth |
| sub ecx, edx |
| add esi, edx ; esi := (y mod BgrDataHeight)*BgrDataWidth + (x mod BgrDataWidth) |
| pop eax |
| lea esi, [esi*3] |
| add esi, [img_background] |
| xor edx, edx |
| inc edx |
| ; 3) Loop through redraw rectangle and copy background data |
| ; Registers meaning: |
| ; eax = x, ebx = y (screen coordinates) |
| ; ecx = deltax - number of pixels left in current tile block |
| ; edx = 1 |
| ; esi -> bgr memory, edi -> output |
| ; ebp = offset in WinMapAddress |
| dp3: |
| cmp [ebp], dl |
| jnz nbgp |
| movsb |
| movsb |
| movsb |
| jmp @f |
| nbgp: |
| add esi, 3 |
| add edi, 3 |
| @@: |
| cmp [ScreenBPP], byte 25 ; 24 or 32 bpp? |
| sbb edi, -1 ; +1 for 32 bpp |
| ; I do not use 'inc eax' because this is slightly slower then 'add eax,1' |
| add ebp, edx |
| add eax, edx |
| cmp eax, [draw_data+32+RECT.right] |
| ja dp4 |
| sub ecx, edx |
| jnz dp3 |
| ; next tile block on x-axis |
| mov ecx, [BgrDataWidth] |
| sub esi, ecx |
| sub esi, ecx |
| sub esi, ecx |
| jmp dp3 |
| dp4: |
| ; next scan line |
| inc ebx |
| cmp ebx, [draw_data+32+RECT.bottom] |
| jbe dp2 |
| popad |
| mov [EGA_counter], 1 |
| call VGA_drawbackground |
| ret |
| ; ---------- |
| vesa20_drawbackground_stretch: |
| call [_display.disable_mouse] |
| pushad |
| ; Helper variables |
| ; calculate 2^32*(BgrDataWidth-1) mod (ScreenWidth-1) |
| mov eax, [BgrDataWidth] |
| dec eax |
| xor edx, edx |
| div dword [Screen_Max_X] |
| push eax ; high |
| xor eax, eax |
| div dword [Screen_Max_X] |
| push eax ; low |
| ; the same for height |
| mov eax, [BgrDataHeight] |
| dec eax |
| xor edx, edx |
| div dword [Screen_Max_Y] |
| push eax ; high |
| xor eax, eax |
| div dword [Screen_Max_Y] |
| push eax ; low |
| ; External loop for all y from start to end |
| mov ebx, [draw_data+32+RECT.top] ; y start |
| mov ebp, [draw_data+32+RECT.left] ; x start |
| ; 1) Calculate pointers in WinMapAddress (does pixel belong to OS thread?) [ebp] |
| ; and LFB data (output for our function) [edi] |
| mov eax, [BytesPerScanLine] |
| mul ebx |
| xchg ebp, eax |
| add ebp, eax |
| add ebp, eax |
| add ebp, eax |
| cmp [ScreenBPP], byte 24 ; 24 or 32 bpp ? - x size |
| jz @f |
| add ebp, eax |
| @@: |
| ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB |
| call calculate_edi |
| xchg edi, ebp |
| ; Now eax=x, ebx=y, edi->output, ebp=offset in WinMapAddress |
| push ebx |
| push eax |
| ; 2) Calculate offset in background memory block |
| mov eax, ebx |
| imul ebx, dword [esp+12] |
| mul dword [esp+8] |
| add edx, ebx ; edx:eax = y * 2^32*(BgrDataHeight-1)/(ScreenHeight-1) |
| mov esi, edx |
| imul esi, [BgrDataWidth] |
| push edx |
| push eax |
| mov eax, [esp+8] |
| mul dword [esp+28] |
| push eax |
| mov eax, [esp+12] |
| mul dword [esp+28] |
| add [esp], edx |
| pop edx ; edx:eax = x * 2^32*(BgrDataWidth-1)/(ScreenWidth-1) |
| add esi, edx |
| lea esi, [esi*3] |
| add esi, [img_background] |
| push eax |
| push edx |
| push esi |
| ; 3) Smooth horizontal |
| bgr_resmooth0: |
| mov ecx, [esp+8] |
| mov edx, [esp+4] |
| mov esi, [esp] |
| push edi |
| mov edi, bgr_cur_line |
| call smooth_line |
| bgr_resmooth1: |
| mov eax, [esp+16+4] |
| inc eax |
| cmp eax, [BgrDataHeight] |
| jae bgr.no2nd |
| mov ecx, [esp+8+4] |
| mov edx, [esp+4+4] |
| mov esi, [esp+4] |
| add esi, [BgrDataWidth] |
| add esi, [BgrDataWidth] |
| add esi, [BgrDataWidth] |
| mov edi, bgr_next_line |
| call smooth_line |
| bgr.no2nd: |
| pop edi |
| sdp3: |
| xor esi, esi |
| mov ecx, [esp+12] |
| ; 4) Loop through redraw rectangle and copy background data |
| ; Registers meaning: |
| ; esi = offset in current line, edi -> output |
| ; ebp = offset in WinMapAddress |
| ; dword [esp] = offset in bgr data |
| ; qword [esp+4] = x * 2^32 * (BgrDataWidth-1) / (ScreenWidth-1) |
| ; qword [esp+12] = y * 2^32 * (BgrDataHeight-1) / (ScreenHeight-1) |
| ; dword [esp+20] = x |
| ; dword [esp+24] = y |
| ; precalculated constants: |
| ; qword [esp+28] = 2^32*(BgrDataHeight-1)/(ScreenHeight-1) |
| ; qword [esp+36] = 2^32*(BgrDataWidth-1)/(ScreenWidth-1) |
| sdp3a: |
| mov eax, [_WinMapAddress] |
| cmp [ebp+eax], byte 1 |
| jnz snbgp |
| mov eax, [bgr_cur_line+esi] |
| test ecx, ecx |
| jz .novert |
| mov ebx, [bgr_next_line+esi] |
| call [overlapping_of_points_ptr] |
| .novert: |
| mov [LFB_BASE+edi], ax |
| shr eax, 16 |
| mov [LFB_BASE+edi+2], al |
| snbgp: |
| cmp [ScreenBPP], byte 25 |
| sbb edi, -4 |
| add ebp, 1 |
| mov eax, [esp+20] |
| add eax, 1 |
| mov [esp+20], eax |
| add esi, 4 |
| cmp eax, [draw_data+32+RECT.right] |
| jbe sdp3a |
| sdp4: |
| ; next y |
| mov ebx, [esp+24] |
| add ebx, 1 |
| mov [esp+24], ebx |
| cmp ebx, [draw_data+32+RECT.bottom] |
| ja sdpdone |
| ; advance edi, ebp to next scan line |
| sub eax, [draw_data+32+RECT.left] |
| sub ebp, eax |
| add ebp, [Screen_Max_X] |
| add ebp, 1 |
| sub edi, eax |
| sub edi, eax |
| sub edi, eax |
| cmp [ScreenBPP], byte 24 |
| jz @f |
| sub edi, eax |
| @@: |
| add edi, [BytesPerScanLine] |
| ; restore ecx,edx; advance esi to next background line |
| mov eax, [esp+28] |
| mov ebx, [esp+32] |
| add [esp+12], eax |
| mov eax, [esp+16] |
| adc [esp+16], ebx |
| sub eax, [esp+16] |
| mov ebx, eax |
| lea eax, [eax*3] |
| imul eax, [BgrDataWidth] |
| sub [esp], eax |
| mov eax, [draw_data+32+RECT.left] |
| mov [esp+20], eax |
| test ebx, ebx |
| jz sdp3 |
| cmp ebx, -1 |
| jnz bgr_resmooth0 |
| push edi |
| mov esi, bgr_next_line |
| mov edi, bgr_cur_line |
| mov ecx, [Screen_Max_X] |
| inc ecx |
| rep movsd |
| jmp bgr_resmooth1 |
| sdpdone: |
| add esp, 44 |
| popad |
| mov [EGA_counter],1 |
| call VGA_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] |
| add eax, 1 |
| 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: |
| if 0 |
| ; this version of procedure works, but is slower than next version |
| push ecx edx |
| mov edx, eax |
| push esi |
| shr ecx, 24 |
| mov esi, ecx |
| mov ecx, ebx |
| movzx ebx, dl |
| movzx eax, cl |
| sub eax, ebx |
| movzx ebx, dh |
| imul eax, esi |
| add dl, ah |
| movzx eax, ch |
| sub eax, ebx |
| imul eax, esi |
| add dh, ah |
| ror ecx, 16 |
| ror edx, 16 |
| movzx eax, cl |
| movzx ebx, dl |
| sub eax, ebx |
| imul eax, esi |
| pop esi |
| add dl, ah |
| mov eax, edx |
| pop edx |
| ror eax, 16 |
| pop ecx |
| ret |
| else |
| 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 |
| end if |
| 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 |
| Property changes: |
| Added: svn:keywords |
| +Rev |
| \ No newline at end of property |
| /kernel/branches/Kolibri-A/trunk/video/vesa12.inc |
|---|
| 0,0 → 1,1004 |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
| ;; Distributed under terms of the GNU General Public License ;; |
| ;; ;; |
| ;; VESA12.INC ;; |
| ;; ;; |
| ;; Vesa 1.2 functions for MenuetOS ;; |
| ;; ;; |
| ;; Copyright 2002 Ville Turjanmaa ;; |
| ;; ;; |
| ;; quickcode@mail.ru - bankswitch for S3 cards ;; |
| ;; ;; |
| ;; See file COPYING for details ;; |
| ;; ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| $Revision$ |
| TRIDENT equ 0 |
| S3_VIDEO equ 0 |
| INTEL_VIDEO equ 0 |
| if TRIDENT |
| if S3_VIDEO or INTEL_VIDEO |
| stop |
| end if |
| end if |
| if S3_VIDEO |
| if TRIDENT or INTEL_VIDEO |
| stop |
| end if |
| end if |
| if INTEL_VIDEO |
| if S3_VIDEO or TRIDENT |
| stop |
| end if |
| end if |
| ; A complete video driver should include the following types of function |
| ; |
| ; Putpixel |
| ; Getpixel |
| ; |
| ; Drawimage |
| ; Drawbar |
| ; |
| ; Drawbackground |
| ; |
| ; |
| ; Modifying the set_bank -function is mostly enough |
| ; for different Vesa 1.2 setups. |
| ;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
| ; set_bank for Trident videocards, work on Trident 9440 |
| ; modified by Mario79 |
| if TRIDENT |
| set_bank: |
| pushfd |
| cli |
| cmp al,[BANK_RW] |
| je .retsb |
| mov [BANK_RW],al |
| push dx |
| mov dx,3D8h |
| out dx,al |
| pop dx |
| .retsb: |
| popfd |
| ret |
| end if |
| ;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
| ; set_bank for S3 videocards, work on S3 ViRGE PCI (325) |
| ; modified by kmeaw |
| if S3_VIDEO |
| set_bank: |
| pushfd |
| cli |
| cmp al,[BANK_RW] |
| je .retsb |
| mov [BANK_RW],al |
| push ax |
| push dx |
| push cx |
| mov cl, al |
| mov dx, 0x3D4 |
| mov al, 0x38 |
| out dx, al ;CR38 Register Lock 1 ;Note: Traditionally 48h is used to |
| ;unlock and 00h to lock |
| inc dx |
| mov al, 0x48 |
| out dx, al ;3d5 -? |
| dec dx |
| mov al, 0x31 |
| out dx, al ;CR31 Memory Configuration Register |
| ;0 Enable Base Address Offset (CPUA BASE). Enables bank operation if set, ;disables if clear. |
| ;4-5 Bit 16-17 of the Display Start Address. For the 801/5,928 see index 51h, |
| ;for the 864/964 see index 69h. |
| inc dx |
| in al, dx |
| dec dx |
| mov ah, al |
| mov al, 0x31 |
| out dx, ax |
| mov al, ah |
| or al, 9 |
| inc dx |
| out dx, al |
| dec dx |
| mov al, 0x35 |
| out dx, al ;CR35 CRT Register Lock |
| inc dx |
| in al, dx |
| dec dx |
| and al, 0xF0 |
| mov ch, cl |
| and ch, 0x0F |
| or ch, al |
| mov al, 0x35 |
| out dx, al |
| inc dx |
| mov al, ch |
| out dx, ax |
| dec dx |
| mov al, 0x51 ;Extended System Control 2 Register |
| out dx, al |
| inc dx |
| in al, dx |
| dec dx |
| and al, 0xF3 |
| shr cl, 2 |
| and cl, 0x0C |
| or cl, al |
| mov al, 0x51 |
| out dx, al |
| inc dx |
| mov al, cl |
| out dx, al |
| dec dx |
| mov al, 0x38 |
| out dx, al |
| inc dx |
| xor al, al |
| out dx, al |
| dec dx |
| pop cx |
| pop dx |
| pop ax |
| .retsb: |
| popfd |
| ret |
| end if |
| ;Set bank function for Intel 810/815 chipsets |
| ; *****Modified by Protopopius, Russia.***** |
| ; ********* http://menuetos.hut.ru ************** |
| ; ************************************************ |
| if INTEL_VIDEO |
| set_bank: |
| pushfd |
| cli |
| cmp al,[BANK_RW] |
| je .retsb |
| mov [BANK_RW],al |
| push ax |
| push dx |
| mov dx,3CEh |
| mov ah,al ; Save value for later use |
| mov al,10h ; Index GR10 (Address Mapping) |
| out dx,al ; Select GR10 |
| inc dl |
| mov al,3 ; Set bits 0 and 1 (Enable linear page mapping) |
| out dx,al ; Write value |
| dec dl |
| mov al,11h ; Index GR11 (Page Selector) |
| out dx,al ; Select GR11 |
| inc dl |
| mov al,ah ; Write address |
| out dx,al ; Write the value |
| pop dx |
| pop ax |
| .retsb: |
| popfd |
| ret |
| end if |
| ;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!} |
| if (TRIDENT or S3_VIDEO or INTEL_VIDEO) |
| else |
| set_bank: |
| pushfd |
| cli |
| cmp al,[BANK_RW] |
| je .retsb |
| mov [BANK_RW],al |
| push ax |
| push dx |
| mov ah,al |
| mov dx,0x03D4 |
| mov al,0x39 |
| out dx,al |
| inc dl |
| mov al,0xA5 |
| out dx,al |
| dec dl |
| mov al,6Ah |
| out dx,al |
| inc dl |
| mov al,ah |
| out dx,al |
| dec dl |
| mov al,0x39 |
| out dx,al |
| inc dl |
| mov al,0x5A |
| out dx,al |
| dec dl |
| pop dx |
| pop ax |
| .retsb: |
| popfd |
| ret |
| end if |
| vesa12_drawbackground: |
| call [_display.disable_mouse] |
| push eax |
| push ebx |
| push ecx |
| push edx |
| xor edx,edx |
| mov eax,dword[BgrDataWidth] |
| mov ebx,dword[BgrDataHeight] |
| mul ebx |
| mov ebx,3 |
| mul ebx |
| mov [imax],eax |
| mov eax,[draw_data+32+RECT.left] |
| mov ebx,[draw_data+32+RECT.top] |
| xor edi,edi ;no force |
| v12dp3: |
| push eax |
| push ebx |
| cmp [BgrDrawMode],dword 1 ; tiled background |
| jne no_vesa12_tiled_bgr |
| push edx |
| xor edx,edx |
| div dword [BgrDataWidth] |
| push edx |
| mov eax,ebx |
| xor edx,edx |
| div dword [BgrDataHeight] |
| mov ebx,edx |
| pop eax |
| pop edx |
| no_vesa12_tiled_bgr: |
| cmp [BgrDrawMode],dword 2 ; stretched background |
| jne no_vesa12_stretched_bgr |
| push edx |
| mul dword [BgrDataWidth] |
| mov ecx,[Screen_Max_X] |
| inc ecx |
| div ecx |
| push eax |
| mov eax,ebx |
| mul dword [BgrDataHeight] |
| mov ecx,[Screen_Max_Y] |
| inc ecx |
| div ecx |
| mov ebx,eax |
| pop eax |
| pop edx |
| no_vesa12_stretched_bgr: |
| mov esi,ebx |
| imul esi, dword [BgrDataWidth] |
| add esi,eax |
| lea esi,[esi*3] |
| add esi,[img_background] ;IMG_BACKGROUND |
| pop ebx |
| pop eax |
| v12di4: |
| mov cl,[esi+2] |
| shl ecx,16 |
| mov cx,[esi] |
| pusha |
| mov esi,eax |
| mov edi,ebx |
| mov eax,[Screen_Max_X] |
| add eax,1 |
| mul ebx |
| add eax, [_WinMapAddress] |
| cmp [eax+esi],byte 1 |
| jnz v12nbgp |
| mov eax,[BytesPerScanLine] |
| mov ebx,edi |
| mul ebx |
| add eax, esi |
| lea eax, [VGABasePtr+eax+esi*2] |
| cmp [ScreenBPP],byte 24 |
| jz v12bgl3 |
| add eax,esi |
| v12bgl3: |
| push ebx |
| push eax |
| sub eax,VGABasePtr |
| shr eax,16 |
| call set_bank |
| pop eax |
| and eax,65535 |
| add eax,VGABasePtr |
| pop ebx |
| mov [eax],cx |
| add eax,2 |
| shr ecx,16 |
| mov [eax],cl |
| sti |
| v12nbgp: |
| popa |
| add esi,3 |
| inc eax |
| cmp eax,[draw_data+32+RECT.right] |
| jg v12nodp31 |
| jmp v12dp3 |
| v12nodp31: |
| mov eax,[draw_data+32+RECT.left] |
| inc ebx |
| cmp ebx,[draw_data+32+RECT.bottom] |
| jg v12dp4 |
| jmp v12dp3 |
| v12dp4: |
| pop edx |
| pop ecx |
| pop ebx |
| pop eax |
| ret |
| vesa12_drawbar: |
| call [_display.disable_mouse] |
| ;; mov [novesachecksum],dword 0 |
| sub edx,ebx |
| sub ecx,eax |
| push esi |
| push edi |
| push eax |
| push ebx |
| push ecx |
| push edx |
| mov ecx,[TASK_BASE] |
| add eax,[ecx-twdw+WDATA.box.left] |
| add ebx,[ecx-twdw+WDATA.box.top] |
| push eax |
| mov eax,ebx ; y |
| mov ebx,[BytesPerScanLine] |
| mul ebx |
| pop ecx |
| add eax,ecx ; x |
| add eax,ecx |
| add eax,ecx |
| cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x start |
| jz dbpi2412 |
| add eax,ecx |
| dbpi2412: |
| add eax,VGABasePtr |
| mov edi,eax |
| ; x size |
| mov eax,[esp+4] ; [esp+6] |
| mov ecx,eax |
| add ecx,eax |
| add ecx,eax |
| cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size |
| jz dbpi24312 |
| add ecx,eax |
| dbpi24312: |
| mov ebx,[esp+0] |
| ; check limits ? |
| push eax |
| push ecx |
| mov eax,[TASK_BASE] |
| mov ecx,[eax+draw_data-CURRENT_TASK+RECT.left] |
| cmp ecx,0 |
| jnz dbcblimitlset12 |
| mov ecx,[eax+draw_data-CURRENT_TASK+RECT.top] |
| cmp ecx,0 |
| jnz dbcblimitlset12 |
| mov ecx,[eax+draw_data-CURRENT_TASK+RECT.right] |
| cmp ecx,[Screen_Max_X] |
| jnz dbcblimitlset12 |
| mov ecx,[eax+draw_data-CURRENT_TASK+RECT.bottom] |
| cmp ecx,[Screen_Max_Y] |
| jnz dbcblimitlset12 |
| pop ecx |
| pop eax |
| push dword 0 |
| jmp dbcblimitlno12 |
| dbcblimitlset12: |
| pop ecx |
| pop eax |
| push dword 1 |
| dbcblimitlno12: |
| cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? |
| jz dbpi24bit12 |
| jmp dbpi32bit12 |
| ; DRAWBAR 24 BBP |
| dbpi24bit12: |
| push eax |
| push ebx |
| push edx |
| mov eax,ecx |
| mov ebx,3 |
| div ebx |
| mov ecx,eax |
| pop edx |
| pop ebx |
| pop eax |
| cld |
| dbnewpi12: |
| push ebx |
| push edi |
| push ecx |
| xor edx,edx |
| mov eax,edi |
| sub eax,VGABasePtr |
| mov ebx,3 |
| div ebx |
| add eax, [_WinMapAddress] |
| mov ebx,[CURRENT_TASK] |
| cld |
| dbnp2412: |
| mov dl,[eax] |
| push eax |
| push ecx |
| cmp dl,bl |
| jnz dbimp24no12 |
| cmp [esp+5*4],dword 0 |
| jz dbimp24yes12 |
| ; call dbcplimit |
| ; jnz dbimp24no12 |
| dbimp24yes12: |
| push edi |
| mov eax,edi |
| sub eax,VGABasePtr |
| shr eax,16 |
| call set_bank |
| and edi,0xffff |
| add edi,VGABasePtr |
| mov eax,[esp+8+3*4+16+4+4] |
| stosw |
| shr eax,16 |
| stosb |
| sti |
| pop edi |
| add edi,3 |
| pop ecx |
| pop eax |
| inc eax |
| loop dbnp2412 |
| jmp dbnp24d12 |
| dbimp24no12: |
| pop ecx |
| pop eax |
| cld |
| add edi,3 |
| inc eax |
| loop dbnp2412 |
| dbnp24d12: |
| mov eax,[esp+3*4+16+4] |
| test eax,0x80000000 |
| jz nodbgl2412 |
| cmp al,0 |
| jz nodbgl2412 |
| dec eax |
| mov [esp+3*4+16+4],eax |
| nodbgl2412: |
| pop ecx |
| pop edi |
| pop ebx |
| add edi,[BytesPerScanLine] |
| dec ebx |
| jz dbnonewpi12 |
| jmp dbnewpi12 |
| dbnonewpi12: |
| add esp,7*4 |
| ret |
| ; DRAWBAR 32 BBP |
| dbpi32bit12: |
| cld |
| shr ecx,2 |
| dbnewpi3212: |
| push ebx |
| push edi |
| push ecx |
| mov eax,edi |
| sub eax,VGABasePtr |
| shr eax,2 |
| add eax, [_WinMapAddress] |
| mov ebx,[CURRENT_TASK] |
| cld |
| dbnp3212: |
| mov dl,[eax] |
| push eax |
| push ecx |
| cmp dl,bl |
| jnz dbimp32no12 |
| cmp [esp+5*4],dword 0 |
| jz dbimp32yes12 |
| ; call dbcplimit |
| ; jnz dbimp32no12 |
| dbimp32yes12: |
| push edi |
| mov eax,edi |
| sub eax,VGABasePtr |
| shr eax,16 |
| call set_bank |
| and edi,0xffff |
| add edi,VGABasePtr |
| mov eax,[esp+8+3*4+16+4+4] |
| stosw |
| shr eax,16 |
| stosb |
| sti |
| pop edi |
| add edi,4 |
| inc ebp |
| pop ecx |
| pop eax |
| inc eax |
| loop dbnp3212 |
| jmp dbnp32d12 |
| dbimp32no12: |
| pop ecx |
| pop eax |
| inc eax |
| add edi,4 |
| inc ebp |
| loop dbnp3212 |
| dbnp32d12: |
| mov eax,[esp+12+16+4] |
| test eax,0x80000000 |
| jz nodbgl3212 |
| cmp al,0 |
| jz nodbgl3212 |
| dec eax |
| mov [esp+12+16+4],eax |
| nodbgl3212: |
| pop ecx |
| pop edi |
| pop ebx |
| add edi,[BytesPerScanLine] |
| dec ebx |
| jz nodbnewpi3212 |
| jmp dbnewpi3212 |
| nodbnewpi3212: |
| add esp,7*4 |
| ret |
| Vesa12_putpixel24: |
| mov edi,eax ; x |
| mov eax,ebx ; y |
| lea edi,[edi+edi*2] |
| mov ebx,[BytesPerScanLine] |
| mul ebx |
| add edi,eax |
| mov eax,edi |
| shr eax,16 |
| call set_bank |
| and edi,65535 |
| add edi,VGABasePtr |
| mov eax,[esp+28] |
| stosw |
| shr eax,16 |
| mov [edi],al |
| sti |
| ret |
| Vesa12_putpixel32: |
| mov edi,eax ; x |
| mov eax,ebx ; y |
| shl edi,2 |
| mov ebx,[BytesPerScanLine] |
| mul ebx |
| add edi,eax |
| mov eax,edi |
| shr eax,16 |
| call set_bank |
| and edi,65535 |
| add edi,VGABasePtr |
| mov ecx,[esp+28] |
| mov [edi],ecx |
| sti |
| ret |
| Vesa12_getpixel24: |
| mov edi,eax ; x |
| mov eax,ebx ; y |
| lea edi,[edi+edi*2] |
| mov ebx,[BytesPerScanLine] |
| mul ebx |
| add edi,eax |
| mov eax,edi |
| shr eax,16 |
| call set_bank |
| and edi,65535 |
| add edi,VGABasePtr |
| mov ecx,[edi] |
| and ecx,255*256*256+255*256+255 |
| sti |
| ret |
| Vesa12_getpixel32: |
| mov edi,eax ; x |
| mov eax,ebx ; y |
| shl edi,2 |
| mov ebx,[BytesPerScanLine] |
| xor edx,edx |
| mul ebx |
| add edi,eax |
| mov eax,edi |
| shr eax,16 |
| call set_bank |
| and edi,65535 |
| add edi,VGABasePtr |
| mov ecx,[edi] |
| and ecx,255*256*256+255*256+255 |
| sti |
| ret |
| vesa12_putimage: |
| ; ebx = pointer to image |
| ; ecx = size [x|y] |
| ; edx = coordinates [x|y] |
| ; ebp = pointer to 'get' function |
| ; esi = pointer to 'init' function |
| ; edi = parameter for 'get' function |
| ; mov ebx,image |
| ; mov ecx,320*65536+240 |
| ; mov edx,20*65536+20 |
| call [_display.disable_mouse] |
| mov [novesachecksum],dword 0 |
| push esi |
| push edi |
| push eax |
| push ebx |
| push ecx |
| push edx |
| movzx eax,word [esp+2] |
| movzx ebx,word [esp+0] |
| mov ecx,[TASK_BASE] |
| add eax,[ecx-twdw+WDATA.box.left] |
| add ebx,[ecx-twdw+WDATA.box.top] |
| push eax |
| mov eax,ebx ; y |
| mul dword [BytesPerScanLine] |
| pop ecx |
| add eax,ecx ; x |
| add eax,ecx |
| add eax,ecx |
| cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x start |
| jz pi2412 |
| add eax,ecx |
| pi2412: |
| add eax,VGABasePtr |
| mov edi,eax |
| ; x size |
| movzx ecx,word [esp+6] |
| mov esi,[esp+8] |
| movzx ebx,word [esp+4] |
| ; check limits while draw ? |
| push ecx |
| mov eax,[TASK_BASE] |
| cmp dword [eax+draw_data-CURRENT_TASK+RECT.left], 0 |
| jnz dbcblimitlset212 |
| cmp dword [eax+draw_data-CURRENT_TASK+RECT.top], 0 |
| jnz dbcblimitlset212 |
| mov ecx,[eax+draw_data-CURRENT_TASK+RECT.right] |
| cmp ecx,[Screen_Max_X] |
| jnz dbcblimitlset212 |
| mov ecx,[eax+draw_data-CURRENT_TASK+RECT.bottom] |
| cmp ecx,[Screen_Max_Y] |
| jnz dbcblimitlset212 |
| pop ecx |
| push 0 |
| jmp dbcblimitlno212 |
| dbcblimitlset212: |
| pop ecx |
| push 1 |
| dbcblimitlno212: |
| cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? |
| jnz pi32bit12 |
| pi24bit12: |
| newpi12: |
| push edi |
| push ecx |
| push ebx |
| mov edx,edi |
| sub edx,VGABasePtr |
| mov ebx,3 |
| div ebx |
| add edx, [_WinMapAddress] |
| mov ebx,[CURRENT_TASK] |
| mov bh,[esp+4*3] |
| np2412: |
| cmp bl,[edx] |
| jnz imp24no12 |
| ; mov eax,[esi] |
| push dword [esp+4*3+20] |
| call ebp |
| ; cmp bh,0 |
| ; jz imp24yes12 |
| ; call dbcplimit |
| ; jnz imp24no12 |
| imp24yes12: |
| push edi |
| push eax |
| mov eax,edi |
| sub eax,VGABasePtr |
| shr eax,16 |
| call set_bank |
| pop eax |
| and edi,0xffff |
| add edi,VGABasePtr |
| mov [edi],ax |
| shr eax,16 |
| mov [edi+2],al |
| pop edi |
| imp24no12: |
| inc edx |
| ; add esi,3 |
| add edi,3 |
| dec ecx |
| jnz np2412 |
| np24d12: |
| pop ebx |
| pop ecx |
| pop edi |
| add edi,[BytesPerScanLine] |
| add esi,[esp+32] |
| cmp ebp,putimage_get1bpp |
| jz .correct |
| cmp ebp,putimage_get2bpp |
| jz .correct |
| cmp ebp,putimage_get4bpp |
| jnz @f |
| .correct: |
| mov eax,[esp+20] |
| mov byte[eax],80h |
| @@: |
| dec ebx |
| jnz newpi12 |
| nonewpi12: |
| pop eax edx ecx ebx eax edi esi |
| xor eax, eax |
| ret |
| pi32bit12: |
| newpi3212: |
| push edi |
| push ecx |
| push ebx |
| mov edx,edi |
| sub edx,VGABasePtr |
| shr edx,2 |
| add edx, [_WinMapAddress] |
| mov ebx,[CURRENT_TASK] |
| mov bh,[esp+4*3] |
| np3212: |
| cmp bl,[edx] |
| jnz imp32no12 |
| ; mov eax,[esi] |
| push dword [esp+4*3+20] |
| call ebp |
| ; cmp bh,0 |
| ; jz imp32yes12 |
| ; call dbcplimit |
| ; jnz imp32no12 |
| imp32yes12: |
| push edi |
| push eax |
| mov eax,edi |
| sub eax,VGABasePtr |
| shr eax,16 |
| call set_bank |
| pop eax |
| and edi,0xffff |
| mov [edi+VGABasePtr],eax |
| pop edi |
| imp32no12: |
| inc edx |
| ; add esi,3 |
| add edi,4 |
| dec ecx |
| jnz np3212 |
| np32d12: |
| pop ebx |
| pop ecx |
| pop edi |
| add edi,[BytesPerScanLine] |
| cmp ebp,putimage_get1bpp |
| jz .correct |
| cmp ebp,putimage_get2bpp |
| jz .correct |
| cmp ebp,putimage_get4bpp |
| jnz @f |
| .correct: |
| mov eax,[esp+20] |
| mov byte[eax],80h |
| @@: |
| dec ebx |
| jnz newpi3212 |
| nonewpi3212: |
| pop eax edx ecx ebx eax edi esi |
| xor eax, eax |
| ret |
| vesa12_read_screen_pixel: |
| and eax,0x3FFFFF |
| cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? |
| jz v12rsp24 |
| mov edi,eax |
| shl edi,2 |
| mov eax,edi |
| shr eax,16 |
| call set_bank |
| and edi,65535 |
| add edi,VGABasePtr |
| mov eax,[edi] |
| and eax,0x00ffffff |
| ret |
| v12rsp24: |
| imul eax,3 |
| mov edi,eax |
| shr eax,16 |
| call set_bank |
| and edi,65535 |
| add edi,VGABasePtr |
| mov eax,[edi] |
| and eax,0x00ffffff |
| ret |
| Property changes: |
| Added: svn:keywords |
| +Rev |
| \ No newline at end of property |
| /kernel/branches/Kolibri-A/trunk/video/cursors.inc |
|---|
| 0,0 → 1,806 |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
| ;; Distributed under terms of the GNU General Public License ;; |
| ;; ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| $Revision$ |
| LOAD_FROM_FILE equ 0 |
| LOAD_FROM_MEM equ 1 |
| LOAD_INDIRECT equ 2 |
| LOAD_SYSTEM equ 3 |
| struc BITMAPINFOHEADER { |
| .biSize dd ? ; DWORD |
| .biWidth dd ? ; LONG |
| .biHeight dd ? ; LONG |
| .biPlanes dw ? ; WORD |
| .biBitCount dw ? ; WORD |
| .biCompression dd ? ; DWORD |
| .biSizeImage dd ? ; DWORD |
| .biXPelsPerMeter dd ? ; LONG |
| .biYPelsPerMeter dd ? ; LONG |
| .biClrUsed dd ? ; DWORD |
| .biClrImportant dd ? ; DWORD |
| } |
| virtual at 0 |
| BI BITMAPINFOHEADER |
| end virtual |
| align 4 |
| proc init_cursor stdcall, dst:dword, src:dword |
| locals |
| rBase dd ? |
| pQuad dd ? |
| pBits dd ? |
| pAnd dd ? |
| width dd ? |
| height dd ? |
| counter dd ? |
| endl |
| mov esi, [src] |
| add esi,[esi+18] |
| mov eax,esi |
| cmp [esi+BI.biBitCount], 24 |
| je .img_24 |
| cmp [esi+BI.biBitCount], 8 |
| je .img_8 |
| cmp [esi+BI.biBitCount], 4 |
| je .img_4 |
| .img_2: |
| add eax, [esi] |
| mov [pQuad],eax |
| add eax,8 |
| mov [pBits],eax |
| add eax, 128 |
| mov [pAnd],eax |
| mov eax,[esi+4] |
| mov [width],eax |
| mov ebx,[esi+8] |
| shr ebx,1 |
| mov [height],ebx |
| mov edi, [dst] |
| add edi, 32*31*4 |
| mov [rBase],edi |
| mov esi,[pQuad] |
| .l21: |
| mov ebx, [pBits] |
| mov ebx, [ebx] |
| bswap ebx |
| mov eax, [pAnd] |
| mov eax, [eax] |
| bswap eax |
| mov [counter], 32 |
| @@: |
| xor edx, edx |
| shl eax,1 |
| setc dl |
| dec edx |
| xor ecx, ecx |
| shl ebx,1 |
| setc cl |
| mov ecx, [esi+ecx*4] |
| and ecx, edx |
| and edx, 0xFF000000 |
| or edx, ecx |
| mov [edi], edx |
| add edi, 4 |
| dec [counter] |
| jnz @B |
| add [pBits], 4 |
| add [pAnd], 4 |
| mov edi,[rBase] |
| sub edi,128 |
| mov [rBase],edi |
| sub [height],1 |
| jnz .l21 |
| ret |
| .img_4: |
| add eax, [esi] |
| mov [pQuad],eax |
| add eax,64 |
| mov [pBits],eax |
| add eax, 0x200 |
| mov [pAnd],eax |
| mov eax,[esi+4] |
| mov [width],eax |
| mov ebx,[esi+8] |
| shr ebx,1 |
| mov [height],ebx |
| mov edi, [dst] |
| add edi, 32*31*4 |
| mov [rBase],edi |
| mov esi,[pQuad] |
| mov ebx, [pBits] |
| .l4: |
| mov eax, [pAnd] |
| mov eax, [eax] |
| bswap eax |
| mov [counter], 16 |
| @@: |
| xor edx, edx |
| shl eax,1 |
| setc dl |
| dec edx |
| movzx ecx, byte [ebx] |
| and cl, 0xF0 |
| shr ecx, 2 |
| mov ecx, [esi+ecx] |
| and ecx, edx |
| and edx, 0xFF000000 |
| or edx, ecx |
| mov [edi], edx |
| xor edx, edx |
| shl eax,1 |
| setc dl |
| dec edx |
| movzx ecx, byte [ebx] |
| and cl, 0x0F |
| mov ecx, [esi+ecx*4] |
| and ecx, edx |
| and edx, 0xFF000000 |
| or edx, ecx |
| mov [edi+4], edx |
| inc ebx |
| add edi, 8 |
| dec [counter] |
| jnz @B |
| add [pAnd], 4 |
| mov edi,[rBase] |
| sub edi,128 |
| mov [rBase],edi |
| sub [height],1 |
| jnz .l4 |
| ret |
| .img_8: |
| add eax, [esi] |
| mov [pQuad],eax |
| add eax,1024 |
| mov [pBits],eax |
| add eax, 1024 |
| mov [pAnd],eax |
| mov eax,[esi+4] |
| mov [width],eax |
| mov ebx,[esi+8] |
| shr ebx,1 |
| mov [height],ebx |
| mov edi, [dst] |
| add edi, 32*31*4 |
| mov [rBase],edi |
| mov esi,[pQuad] |
| mov ebx, [pBits] |
| .l81: |
| mov eax, [pAnd] |
| mov eax, [eax] |
| bswap eax |
| mov [counter], 32 |
| @@: |
| xor edx, edx |
| shl eax,1 |
| setc dl |
| dec edx |
| movzx ecx, byte [ebx] |
| mov ecx, [esi+ecx*4] |
| and ecx, edx |
| and edx, 0xFF000000 |
| or edx, ecx |
| mov [edi], edx |
| inc ebx |
| add edi, 4 |
| dec [counter] |
| jnz @B |
| add [pAnd], 4 |
| mov edi,[rBase] |
| sub edi,128 |
| mov [rBase],edi |
| sub [height],1 |
| jnz .l81 |
| ret |
| .img_24: |
| add eax, [esi] |
| mov [pQuad],eax |
| add eax, 0xC00 |
| mov [pAnd],eax |
| mov eax,[esi+BI.biWidth] |
| mov [width],eax |
| mov ebx,[esi+BI.biHeight] |
| shr ebx,1 |
| mov [height],ebx |
| mov edi, [dst] |
| add edi, 32*31*4 |
| mov [rBase],edi |
| mov esi,[pAnd] |
| mov ebx, [pQuad] |
| .row_24: |
| mov eax, [esi] |
| bswap eax |
| mov [counter], 32 |
| @@: |
| xor edx, edx |
| shl eax,1 |
| setc dl |
| dec edx |
| mov ecx, [ebx] |
| and ecx, 0x00FFFFFF |
| and ecx, edx |
| and edx, 0xFF000000 |
| or edx, ecx |
| mov [edi], edx |
| add ebx, 3 |
| add edi, 4 |
| dec [counter] |
| jnz @B |
| add esi, 4 |
| mov edi,[rBase] |
| sub edi,128 |
| mov [rBase],edi |
| sub [height],1 |
| jnz .row_24 |
| ret |
| endp |
| align 4 |
| proc set_cursor stdcall, hcursor:dword |
| mov eax, [hcursor] |
| cmp [eax+CURSOR.magic], 'CURS' |
| jne .fail |
| ; cmp [eax+CURSOR.size], CURSOR_SIZE |
| ; jne .fail |
| mov ebx, [current_slot] |
| xchg eax, [ebx+APPDATA.cursor] |
| ret |
| .fail: |
| mov eax, [def_cursor] |
| mov ebx, [current_slot] |
| xchg eax, [ebx+APPDATA.cursor] |
| ret |
| endp |
| ; param |
| ; eax= pid |
| ; ebx= src |
| ; ecx= flags |
| create_cursor: |
| .src equ esp |
| .flags equ esp+4 |
| .hcursor equ esp+8 |
| sub esp, 4 ;space for .hcursor |
| push ecx |
| push ebx |
| mov ebx, eax |
| mov eax, CURSOR.sizeof |
| call create_kernel_object |
| test eax, eax |
| jz .fail |
| mov [.hcursor],eax |
| xor ebx, ebx |
| mov [eax+CURSOR.magic], 'CURS' |
| mov [eax+CURSOR.destroy], destroy_cursor |
| mov [eax+CURSOR.hot_x], ebx |
| mov [eax+CURSOR.hot_y], ebx |
| stdcall kernel_alloc, 0x1000 |
| test eax, eax |
| jz .fail |
| mov edi, [.hcursor] |
| mov [edi+CURSOR.base], eax |
| mov esi, [.src] |
| mov ebx, [.flags] |
| cmp bx, LOAD_INDIRECT |
| je .indirect |
| movzx ecx, word [esi+10] |
| movzx edx, word [esi+12] |
| mov [edi+CURSOR.hot_x], ecx |
| mov [edi+CURSOR.hot_y], edx |
| stdcall init_cursor, eax, esi |
| mov eax, [.hcursor] |
| lea eax, [eax+CURSOR.list_next] |
| lea edx, [_display.cr_list.next] |
| pushfd |
| cli |
| mov ecx, [edx] |
| mov [eax], ecx |
| mov [eax+4], edx |
| mov [ecx+4], eax |
| mov [edx], eax |
| popfd |
| mov eax, [.hcursor] |
| .check_hw: |
| cmp [_display.init_cursor], 0 |
| je .fail |
| push eax |
| call [_display.init_cursor] |
| add esp, 4 |
| mov eax, [.hcursor] |
| .fail: |
| add esp, 12 |
| ret |
| .indirect: |
| shr ebx, 16 |
| movzx ecx, bh |
| movzx edx, bl |
| mov [eax+CURSOR.hot_x], ecx |
| mov [eax+CURSOR.hot_y], edx |
| xchg edi, eax |
| mov ecx, 1024 |
| cld |
| rep movsd |
| jmp .check_hw |
| align 4 |
| proc load_cursor stdcall, src:dword, flags:dword |
| locals |
| handle dd ? |
| endl |
| xor eax, eax |
| cmp [create_cursor], eax |
| je .fail2 |
| mov [handle], eax |
| cmp word [flags], LOAD_FROM_FILE |
| jne @F |
| stdcall load_file, [src] |
| test eax, eax |
| jz .fail |
| mov [src], eax |
| @@: |
| push ebx |
| push esi |
| push edi |
| mov eax, [CURRENT_TASK] |
| shl eax, 5 |
| mov eax, [CURRENT_TASK+eax+4] |
| mov ebx, [src] |
| mov ecx, [flags] |
| call create_cursor ;eax, ebx, ecx |
| mov [handle], eax |
| cmp word [flags], LOAD_FROM_FILE |
| jne .exit |
| stdcall kernel_free, [src] |
| .exit: |
| pop edi |
| pop esi |
| pop ebx |
| .fail: |
| mov eax, [handle] |
| .fail2: |
| ret |
| endp |
| align 4 |
| proc delete_cursor stdcall, hcursor:dword |
| locals |
| hsrv dd ? |
| io_code dd ? |
| input dd ? |
| inp_size dd ? |
| output dd ? |
| out_size dd ? |
| endl |
| mov esi, [hcursor] |
| cmp [esi+CURSOR.magic], 'CURS' |
| jne .fail |
| mov ebx, [CURRENT_TASK] |
| shl ebx, 5 |
| mov ebx, [CURRENT_TASK+ebx+4] |
| cmp ebx, [esi+CURSOR.pid] |
| jne .fail |
| mov ebx, [current_slot] |
| cmp esi, [ebx+APPDATA.cursor] |
| jne @F |
| mov eax, [def_cursor] |
| mov [ebx+APPDATA.cursor], eax |
| @@: |
| mov eax, [hcursor] |
| call [eax+APPOBJ.destroy] |
| .fail: |
| ret |
| endp |
| ; param |
| ; eax= cursor |
| align 4 |
| destroy_cursor: |
| push eax |
| stdcall kernel_free, [eax+CURSOR.base] |
| pop eax |
| call destroy_kernel_object |
| ret |
| align 4 |
| select_cursor: |
| mov eax, [esp+4] |
| mov [_display.cursor], eax |
| ret 4 |
| align 4 |
| proc restore_24 stdcall, x:dword, y:dword |
| push ebx |
| mov ebx, [cur_saved_base] |
| mov edx, [cur.h] |
| test edx, edx |
| jz .ret |
| push esi |
| push edi |
| mov esi, cur_saved_data |
| mov ecx, [cur.w] |
| lea ecx, [ecx+ecx*2] |
| push ecx |
| @@: |
| mov edi, ebx |
| add ebx, [BytesPerScanLine] |
| mov ecx, [esp] |
| rep movsb |
| dec edx |
| jnz @B |
| pop ecx |
| pop edi |
| pop esi |
| .ret: |
| pop ebx |
| ret |
| endp |
| align 4 |
| proc restore_32 stdcall, x:dword, y:dword |
| push ebx |
| mov ebx, [cur_saved_base] |
| mov edx, [cur.h] |
| test edx, edx |
| jz .ret |
| push esi |
| push edi |
| mov esi, cur_saved_data |
| @@: |
| mov edi, ebx |
| add ebx, [BytesPerScanLine] |
| mov ecx, [cur.w] |
| rep movsd |
| dec edx |
| jnz @B |
| pop edi |
| .ret: |
| pop esi |
| pop ebx |
| ret |
| endp |
| align 4 |
| proc move_cursor_24 stdcall, hcursor:dword, x:dword, y:dword |
| locals |
| h dd ? |
| _dx dd ? |
| _dy dd ? |
| endl |
| mov esi, [hcursor] |
| mov ecx, [x] |
| mov eax, [y] |
| mov ebx, [BytesPerScanLine] |
| xor edx, edx |
| sub ecx, [esi+CURSOR.hot_x] |
| lea ebx, [ecx+32-1] |
| mov [x], ecx |
| sets dl |
| dec edx |
| and ecx, edx ;clip x to 0<=x |
| mov [cur.left], ecx |
| mov edi, ecx |
| sub edi, [x] |
| mov [_dx], edi |
| xor edx, edx |
| sub eax, [esi+CURSOR.hot_y] |
| lea edi, [eax+32-1] |
| mov [y], eax |
| sets dl |
| dec edx |
| and eax, edx ;clip y to 0<=y |
| mov [cur.top], eax |
| mov edx, eax |
| sub edx, [y] |
| mov [_dy], edx |
| mul dword [BytesPerScanLine] |
| lea edx, [LFB_BASE+ecx*3] |
| add edx, eax |
| mov [cur_saved_base],edx |
| cmp ebx, [Screen_Max_X] |
| jbe @F |
| mov ebx, [Screen_Max_X] |
| @@: |
| cmp edi, [Screen_Max_Y] |
| jbe @F |
| mov edi, [Screen_Max_Y] |
| @@: |
| mov [cur.right], ebx |
| mov [cur.bottom], edi |
| sub ebx, [x] |
| sub edi, [y] |
| inc ebx |
| inc edi |
| mov [cur.w], ebx |
| mov [cur.h], edi |
| mov [h], edi |
| mov eax, edi |
| mov edi, cur_saved_data |
| @@: |
| mov esi, edx |
| add edx, [BytesPerScanLine] |
| mov ecx, [cur.w] |
| lea ecx, [ecx+ecx*2] |
| rep movsb |
| dec eax |
| jnz @B |
| ;draw cursor |
| mov ebx, [cur_saved_base] |
| mov eax, [_dy] |
| shl eax, 5 |
| add eax, [_dx] |
| mov esi, [hcursor] |
| mov esi, [esi+CURSOR.base] |
| lea edx, [esi+eax*4] |
| .row: |
| mov ecx, [cur.w] |
| mov esi, edx |
| mov edi, ebx |
| add edx, 32*4 |
| add ebx, [BytesPerScanLine] |
| .pix: |
| lodsd |
| test eax, 0xFF000000 |
| jz @F |
| mov [edi], ax |
| shr eax, 16 |
| mov [edi+2],al |
| @@: |
| add edi, 3 |
| dec ecx |
| jnz .pix |
| dec [h] |
| jnz .row |
| ret |
| endp |
| align 4 |
| proc move_cursor_32 stdcall, hcursor:dword, x:dword, y:dword |
| locals |
| h dd ? |
| _dx dd ? |
| _dy dd ? |
| endl |
| mov esi, [hcursor] |
| mov ecx, [x] |
| mov eax, [y] |
| xor edx, edx |
| sub ecx, [esi+CURSOR.hot_x] |
| lea ebx, [ecx+32-1] |
| mov [x], ecx |
| sets dl |
| dec edx |
| and ecx, edx ;clip x to 0<=x |
| mov [cur.left], ecx |
| mov edi, ecx |
| sub edi, [x] |
| mov [_dx], edi |
| xor edx, edx |
| sub eax, [esi+CURSOR.hot_y] |
| lea edi, [eax+32-1] |
| mov [y], eax |
| sets dl |
| dec edx |
| and eax, edx ;clip y to 0<=y |
| mov [cur.top], eax |
| mov edx, eax |
| sub edx, [y] |
| mov [_dy], edx |
| mul dword [BytesPerScanLine] |
| lea edx, [LFB_BASE+eax+ecx*4] |
| mov [cur_saved_base],edx |
| cmp ebx, [Screen_Max_X] |
| jbe @F |
| mov ebx, [Screen_Max_X] |
| @@: |
| cmp edi, [Screen_Max_Y] |
| jbe @F |
| mov edi, [Screen_Max_Y] |
| @@: |
| mov [cur.right], ebx |
| mov [cur.bottom], edi |
| sub ebx, [x] |
| sub edi, [y] |
| inc ebx |
| inc edi |
| mov [cur.w], ebx |
| mov [cur.h], edi |
| mov [h], edi |
| mov eax, edi |
| mov edi, cur_saved_data |
| @@: |
| mov esi, edx |
| add edx, [BytesPerScanLine] |
| mov ecx, [cur.w] |
| rep movsd |
| dec eax |
| jnz @B |
| ;draw cursor |
| mov ebx, [cur_saved_base] |
| mov eax, [_dy] |
| shl eax, 5 |
| add eax, [_dx] |
| mov esi, [hcursor] |
| mov esi, [esi+CURSOR.base] |
| lea edx, [esi+eax*4] |
| .row: |
| mov ecx, [cur.w] |
| mov esi, edx |
| mov edi, ebx |
| add edx, 32*4 |
| add ebx, [BytesPerScanLine] |
| .pix: |
| lodsd |
| test eax, 0xFF000000 |
| jz @F |
| mov [edi], eax |
| @@: |
| add edi, 4 |
| dec ecx |
| jnz .pix |
| dec [h] |
| jnz .row |
| ret |
| endp |
| align 4 |
| get_display: |
| mov eax, _display |
| ret |
| align 4 |
| init_display: |
| xor eax, eax |
| mov edi, _display |
| mov [edi+display_t.init_cursor], eax |
| mov [edi+display_t.select_cursor], eax |
| mov [edi+display_t.show_cursor], eax |
| mov [edi+display_t.move_cursor], eax |
| mov [edi+display_t.restore_cursor], eax |
| lea ecx, [edi+display_t.cr_list.next] |
| mov [edi+display_t.cr_list.next], ecx |
| mov [edi+display_t.cr_list.prev], ecx |
| cmp [SCR_MODE],word 0x13 |
| jbe .fail |
| test word [SCR_MODE], 0x4000 |
| jz .fail |
| mov ebx, restore_32 |
| mov ecx, move_cursor_32 |
| movzx eax, byte [ScreenBPP] |
| cmp eax, 32 |
| je @F |
| mov ebx, restore_24 |
| mov ecx, move_cursor_24 |
| cmp eax, 24 |
| jne .fail |
| @@: |
| mov [_display.select_cursor], select_cursor |
| mov [_display.move_cursor], ecx |
| mov [_display.restore_cursor], ebx |
| stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM |
| mov [def_cursor], eax |
| ret |
| .fail: |
| xor eax, eax |
| mov [_display.select_cursor], eax |
| mov [_display.move_cursor], eax |
| ret |
| align 4 |
| def_arrow: |
| file 'arrow.cur' |
| Property changes: |
| Added: svn:keywords |
| +Rev |
| \ No newline at end of property |
| /kernel/branches/Kolibri-A/trunk/video/vga.inc |
|---|
| 0,0 → 1,450 |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;; |
| ;; Distributed under terms of the GNU General Public License ;; |
| ;; ;; |
| ;; VGA.INC ;; |
| ;; ;; |
| ;; 640x480 mode 0x12 VGA functions for MenuetOS ;; |
| ;; ;; |
| ;; Paul Butcher, paul.butcher@asa.co.uk ;; |
| ;; ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| $Revision$ |
| paletteVGA: |
| ;16 colour palette |
| mov dx,0x3c8 |
| mov al,0 |
| out dx,al |
| mov ecx,16 |
| mov dx,0x3c9 |
| xor eax,eax |
| palvganew: |
| mov al,0 |
| test ah,4 |
| jz palvgalbl1 |
| add al,31 |
| test ah,8 |
| jz palvgalbl1 |
| add al,32 |
| palvgalbl1: |
| out dx,al ; red 0,31 or 63 |
| mov al,0 |
| test ah,2 |
| jz palvgalbl2 |
| add al,31 |
| test ah,8 |
| jz palvgalbl2 |
| add al,32 |
| palvgalbl2: |
| out dx,al ; blue 0,31 or 63 |
| mov al,0 |
| test ah,1 |
| jz palvgalbl3 |
| add al,31 |
| test ah,8 |
| jz palvgalbl3 |
| add al,32 |
| palvgalbl3: |
| out dx,al ; green 0,31 or 63 |
| add ah,1 |
| loop palvganew |
| ; mov dx, 3ceh |
| ; mov ax, 0005h |
| ; out dx, ax |
| ret |
| palette320x200: |
| mov edx,0x3c8 |
| xor eax, eax |
| out dx,al |
| mov ecx,256 |
| mov edx,0x3c9 |
| xor eax,eax |
| palnew: |
| mov al,0 |
| test ah,64 |
| jz pallbl1 |
| add al,21 |
| pallbl1: |
| test ah,128 |
| jz pallbl2 |
| add al,42 |
| pallbl2: |
| out dx,al |
| mov al,0 |
| test ah,8 |
| jz pallbl3 |
| add al,8 |
| pallbl3: |
| test ah,16 |
| jz pallbl4 |
| add al,15 |
| pallbl4: |
| test ah,32 |
| jz pallbl5 |
| add al,40 |
| pallbl5: |
| out dx,al |
| mov al,0 |
| test ah,1 |
| jz pallbl6 |
| add al,8 |
| pallbl6: |
| test ah,2 |
| jz pallbl7 |
| add al,15 |
| pallbl7: |
| test ah,4 |
| jz pallbl8 |
| add al,40 |
| pallbl8: |
| out dx,al |
| add ah,1 |
| loop palnew |
| ret |
| align 4 |
| uglobal |
| novesachecksum dd 0x0 |
| EGA_counter db 0 |
| VGA_drawing_screen db 0 |
| VGA_8_pixels: |
| rb 16 |
| temp: |
| .cx dd 0 |
| endg |
| align 4 |
| checkVga_N13: |
| cmp [SCR_MODE],dword 0x13 |
| jne @f |
| ; cnvl: |
| pushad |
| cmp [EGA_counter],1 |
| je novesal |
| mov ecx,[MOUSE_X] |
| cmp ecx,[novesachecksum] |
| jne novesal |
| popad |
| @@: |
| ret |
| novesal: |
| mov [novesachecksum],ecx |
| mov ecx,0 |
| movzx eax,word [MOUSE_Y] |
| cmp eax,100 |
| jge m13l3 |
| mov eax,100 |
| m13l3: |
| cmp eax,480-100 |
| jbe m13l4 |
| mov eax,480-100 |
| m13l4: |
| sub eax,100 |
| imul eax,640*4 |
| add ecx,eax |
| movzx eax,word [MOUSE_X] |
| cmp eax,160 |
| jge m13l1 |
| mov eax,160 |
| m13l1: |
| cmp eax,640-160 |
| jbe m13l2 |
| mov eax,640-160 |
| m13l2: |
| sub eax,160 |
| shl eax,2 |
| add ecx,eax |
| mov esi,[LFBAddress] |
| add esi,ecx |
| mov edi,VGABasePtr |
| mov edx,200 |
| mov ecx,320 |
| cld |
| m13pix: |
| lodsd |
| test eax,eax |
| jz .save_pixel |
| push eax |
| mov ebx,eax |
| and eax,(128+64+32) ; blue |
| shr eax,5 |
| and ebx,(128+64+32)*256 ; green |
| shr ebx,8+2 |
| add eax,ebx |
| pop ebx |
| and ebx,(128+64)*256*256 ; red |
| shr ebx,8+8 |
| add eax,ebx |
| .save_pixel: |
| stosb |
| loop m13pix |
| mov ecx,320 |
| add esi,4*(640-320) |
| dec edx |
| jnz m13pix |
| mov [EGA_counter],0 |
| popad |
| ret |
| VGA_drawbackground: |
| ; draw all |
| cmp [SCR_MODE],dword 0x12 |
| jne .end |
| pushad |
| mov esi,[LFBAddress] |
| mov edi,VGABasePtr |
| mov ebx,640/32 ; 640*480/(8*4) |
| mov edx,480 |
| @@: |
| push ebx edx esi edi |
| shl edx,9 |
| lea edx,[edx+edx*4] |
| add esi,edx |
| shr edx,5 |
| add edi,edx |
| call VGA_draw_long_line |
| pop edi esi edx ebx |
| dec edx |
| jnz @r |
| call VGA_draw_long_line_1 |
| popad |
| .end: |
| ret |
| VGA_draw_long_line: |
| mov dx,3ceh |
| mov ax,0ff08h |
| cli |
| out dx, ax |
| mov ax,0005h |
| out dx, ax |
| m12pix: |
| call VGA_draw_32_pixels |
| dec ebx |
| jnz m12pix |
| mov dx,3c4h |
| mov ax,0ff02h |
| out dx,ax |
| mov dx,3ceh |
| mov ax,0205h |
| out dx,ax |
| mov dx,3ceh |
| mov al,08h |
| out dx,al |
| sti |
| ret |
| VGA_draw_32_pixels: |
| xor eax,eax |
| mov ebp,VGA_8_pixels |
| mov [ebp],eax |
| mov [ebp+4],eax |
| mov [ebp+8],eax |
| mov [ebp+12],eax |
| mov ch,4 |
| .main_loop: |
| mov cl,8 |
| .convert_pixels_to_VGA: |
| lodsd ; eax = 24bit colour |
| test eax,eax |
| jz .end |
| rol eax,8 |
| mov al,ch |
| ror eax,8 |
| mov ch,1 |
| dec cl |
| shl ch,cl |
| cmp al,85 |
| jbe .p13green |
| or [ebp],ch |
| cmp al,170 |
| jbe .p13green |
| or [ebp+12],ch |
| .p13green: |
| cmp ah,85 |
| jbe .p13red |
| or [ebp+4],ch |
| cmp ah,170 |
| jbe .p13red |
| or [ebp+12],ch |
| .p13red: |
| shr eax,8 |
| cmp ah,85 |
| jbe .p13cont |
| or [ebp+8],ch |
| cmp ah,170 |
| jbe .p13cont |
| or [ebp+12],ch |
| .p13cont: |
| ror eax,8 |
| mov ch,ah |
| inc cl |
| .end: |
| dec cl |
| jnz .convert_pixels_to_VGA |
| inc ebp |
| dec ch |
| jnz .main_loop |
| push esi |
| sub ebp,4 |
| mov esi,ebp |
| mov dx, 3c4h |
| mov ah, 1h |
| @@: |
| mov al, 02h |
| out dx,ax |
| xchg ax,bp |
| lodsd |
| mov [edi],eax |
| xchg ax,bp |
| shl ah, 1 |
| cmp ah, 10h |
| jnz @r |
| add edi,4 |
| pop esi |
| ret |
| VGA_putpixel: |
| ; eax = x |
| ; ebx = y |
| mov ecx,eax |
| mov eax, [esp+32-8+4] ; color |
| shl ebx,9 |
| lea ebx,[ebx+ebx*4] ; óìíîæåíèå íà 5 |
| lea edx, [ebx+ecx*4] ; + x*BytesPerPixel (Vesa2.0 32) |
| mov edi,edx |
| add edi, [LFBAddress] ; + LFB address |
| mov [edi], eax ; write to LFB for Vesa2.0 |
| shr edx,5 ; change BytesPerPixel to 1/8 |
| mov edi,edx |
| add edi, VGABasePtr ; address of pixel in VGA area |
| and ecx,0x07 ; bit no. (modulo 8) |
| pushfd |
| ; edi = address, eax = 24bit colour, ecx = bit no. (modulo 8) |
| xor edx,edx |
| test eax,eax |
| jz .p13cont |
| cmp al,85 |
| jbe .p13green |
| or dl,0x01 |
| cmp al,170 |
| jbe .p13green |
| or dl,0x08 |
| .p13green: |
| cmp ah,85 |
| jbe .p13red |
| or dl,0x02 |
| cmp ah,170 |
| jbe .p13red |
| or dl,0x08 |
| .p13red: |
| shr eax,8 |
| cmp ah,85 |
| jbe .p13cont |
| or dl,0x04 |
| cmp ah,170 |
| jbe .p13cont |
| or dl,0x08 |
| .p13cont: |
| ror edx,8 |
| inc cl |
| xor eax,eax |
| inc ah |
| shr ax,cl |
| mov dx,3cfh |
| cli |
| out dx,al |
| mov al,[edi] ; dummy read |
| rol edx,8 |
| mov [edi],dl |
| popfd |
| ;.end: |
| ret |
| VGA__putimage: |
| ; ecx = size [x|y] |
| ; edx = coordinates [x|y] |
| cmp [SCR_MODE],dword 0x12 |
| jne @f |
| pushad |
| rol edx,16 |
| movzx eax,dx |
| rol edx,16 |
| movzx ebx,dx |
| movzx edx,cx |
| rol ecx,16 |
| movzx ecx,cx |
| call VGA_draw_bar_1 |
| popad |
| @@: |
| ret |
| VGA_draw_bar: |
| ; eax cx |
| ; ebx cy |
| ; ecx xe |
| ; edx ye |
| cmp [SCR_MODE],dword 0x12 |
| jne @f |
| pushad |
| sub ecx,eax |
| sub edx,ebx |
| and eax,0xffff |
| and ebx,0xffff |
| and ecx,0xffff |
| and edx,0xffff |
| call VGA_draw_bar_1 |
| popad |
| @@: |
| ret |
| VGA_draw_bar_1: |
| mov [temp.cx],eax |
| mov eax, [TASK_BASE] |
| add ebx, [eax-twdw + 4] |
| mov eax, [eax-twdw + 0] |
| add eax, [temp.cx] |
| and eax,0xfff8 |
| shl ebx,9 |
| lea ebx,[ebx+ebx*4] ; óìíîæåíèå íà 5 |
| lea ebx, [ebx+eax*4] ; + x*BytesPerPixel (Vesa2.0 32) |
| mov esi,ebx |
| add esi, [LFBAddress] ; + LFB address |
| shr ebx,5 ; change BytesPerPixel to 1/8 |
| mov edi,ebx |
| add edi, VGABasePtr ; address of pixel in VGA area |
| mov ebx,ecx |
| shr ebx,5 |
| inc ebx |
| .main_loop: |
| call VGA_draw_long_line_1 |
| dec edx |
| jnz .main_loop |
| call VGA_draw_long_line_1 |
| ret |
| VGA_draw_long_line_1: |
| push ebx edx esi edi |
| shl edx,9 |
| lea edx,[edx+edx*4] |
| add esi,edx |
| shr edx,5 |
| add edi,edx |
| call VGA_draw_long_line |
| pop edi esi edx ebx |
| ret |
| Property changes: |
| Added: svn:keywords |
| +Rev |
| \ No newline at end of property |
| /kernel/branches/Kolibri-A/trunk/video/arrow.cur |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /kernel/branches/Kolibri-A/trunk/video/. |
|---|
| Property changes: |
| Added: svn:ignore |
| +*.mnt |
| +lang.inc |
| +*.bat |
| +out.txt |
| +scin* |
| +*.obj |