WebSVN – Kolibri OS – Diff – /kernel/trunk/video/vesa20.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2023. 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: 9930 $
 
uglobal
align 4
        bgr_cur_line    rd MAX_SCREEN_WIDTH
        bgr_next_line   rd MAX_SCREEN_WIDTH
endg
 
iglobal
align 4
        overlapping_of_points_ptr       dd overlapping_of_points
endg
 
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_getpixel16:
 
        ; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        je      @f
        cmp     [_display.select_cursor], 0
        jne     .no_mouseunder
  @@:
 
        ; check mouse area for putpixel
        test    ecx, 0x04000000         ; don't load to mouseunder area
        jnz     .no_mouseunder
        call    [_display.check_m_pixel]
        test    ecx, ecx                ; 0xff000000
        jnz     @f
 
  .no_mouseunder:
;        imul    ebx, [BytesPerScanLine] ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area + ebx*4]
        lea     edi, [eax*2]            ; edi = x*2
        add     edi, ebx                ; edi = x*2+(y*y multiplier)
 
        movzx   ecx, word[LFB_BASE + edi]
        shl     ecx, 3
        ror     ecx, 8
        shl     cx, 2
        ror     ecx, 8
        shl     cl, 3
        rol     ecx, 16
  @@:
        and     ecx, 0x00ffffff
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_getpixel24:
 
        ; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        je      @f
        cmp     [_display.select_cursor], 0
        jne     .no_mouseunder
  @@:
 
        ; check mouse area for putpixel
        test    ecx, 0x04000000         ; don't load to mouseunder area
        jnz     .no_mouseunder
        call    [_display.check_m_pixel]
        test    ecx, ecx                ; 0xff000000
        jnz     @f
 
  .no_mouseunder:
;        imul    ebx, [BytesPerScanLine] ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area + ebx*4]
        lea     edi, [eax + eax*2]        ; edi = x*3
        add     edi, ebx                ; edi = x*3+(y*y multiplier)
 
        mov     ecx, [LFB_BASE + edi]
  @@:
        and     ecx, 0x00ffffff
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_getpixel32:
 
        ; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        je      @f
        cmp     [_display.select_cursor], 0
        jne     .no_mouseunder
  @@:
 
        ; check mouse area for putpixel
        test    ecx, 0x04000000         ; don't load to mouseunder area
        jnz     .no_mouseunder
        call    [_display.check_m_pixel]
        test    ecx, ecx                ; 0xff000000
        jnz     @f
 
  .no_mouseunder:
;        imul    ebx, [BytesPerScanLine] ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area + ebx*4]
        lea     edi, [ebx + eax*4]        ; edi = x*4+(y*y multiplier)
 
        mov     ecx, [LFB_BASE + edi]
  @@:
        and     ecx, 0x00ffffff
        ret
 
;-----------------------------------------------------------------------------
; 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
 
align 16
vesa20_putimage:
 
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 ?
   .real_sx_and_abs_cx dd ?
   .real_sy_and_abs_cy dd ?
   .stack_data = 4*14
   .edi         dd      ?
   .esi         dd      ?
   .ebp         dd      ?
   .esp         dd      ?
   .ebx         dd      ?
   .edx         dd      ?
   .ecx         dd      ?
   .eax         dd      ?
   .ret_addr    dd      ?
   .arg_0       dd      ?
end virtual
 
        pushad
        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, [current_slot_idx]
        shl     eax, BSF sizeof.WDATA
        mov     ebx, [eax + window_data + WDATA.box.left]
        add     ebx, [putimg.image_cx]
        mov     [putimg.abs_cx], ebx
        mov     ebx, [eax +window_data + 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 + window_data + WDATA.box.width]       ; ebx = wnd_sx
        inc     ebx                                     ; WDATA.box.width is one pixel less than real window x-size
        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 + window_data + WDATA.box.height]      ; ebx = wnd_sy
        inc     ebx
        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, [_display.width]
        sub     eax, [putimg.real_sx]
        mov     [putimg.winmap_newline], eax
; screen new line increment
        mov     eax, [_display.lfb_pitch]
        mov     ebx, [_display.bytes_per_pixel]
        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     edx, [BPSLine_calc_area + edx*4]
        mov     eax, [putimg.abs_cx]
        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]
        mov     eax, [d_width_calc_area + eax*4]
 
        add     eax, [putimg.abs_cx]
        add     eax, [_display.win_map]
        xchg    eax, ebp
 
        mov     ecx, [putimg.real_sx]
        add     ecx, [putimg.abs_cx]
        mov     [putimg.real_sx_and_abs_cx], ecx
        mov     ecx, [putimg.real_sy]
        add     ecx, [putimg.abs_cy]
        mov     [putimg.real_sy_and_abs_cy], ecx
 
; get process number
        mov     ebx, [current_slot_idx]
 
        cmp     byte [_display.bits_per_pixel], 16
        je      put_image_end_16
        cmp     byte [_display.bits_per_pixel], 24
        je      put_image_end_24
        cmp     byte [_display.bits_per_pixel], 32
        je      put_image_end_32
 
;------------------------------------------------------------------------------
 
put_image_end_16:
 
        mov     edi, [putimg.real_sy]
 
; check for hardware cursor
        mov     ecx, [_display.select_cursor]
        cmp     ecx, select_cursor
        je      put_image_end_16_new
        cmp     ecx, 0
        je      put_image_end_16_old
  .new_line:
        mov     ecx, [putimg.real_sx]
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
; convert to 16 bpp and store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [LFB_BASE + edx], ax
  .skip:
        add     edx, 2
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_16_old:
 
  .new_line:
        mov     ecx, [putimg.real_sx]
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
 
        push    ecx
        neg     ecx
        add     ecx, [putimg.real_sx_and_abs_cx + 4]
        shl     ecx, 16
        add     ecx, [putimg.real_sy_and_abs_cy + 4]
        sub     ecx, edi
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel
        pop     ecx
 
; convert to 16 bpp and store to LFB
;;        and     eax, 00000000111110001111110011111000b
;;        shr     ah, 2
;;        shr     ax, 3
;;        ror     eax, 8
;;        add     al, ah
;;        rol     eax, 8
        mov     [LFB_BASE + edx], ax
  .skip:
        inc     edx
        inc     edx
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
        jmp     put_image_end_16.finish
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_16_new:
 
  .new_line:
        mov     ecx, [putimg.real_sx]
 
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
 
        cmp     [ebp], bl
        jne     .skip
 
        push    ecx
  .sh:
        neg     ecx
        add     ecx, [putimg.real_sx_and_abs_cx + 4]
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     .no_mouse_area
 
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      .no_mouse_area
 
        shl     ecx, 16
        add     ecx, [putimg.real_sy_and_abs_cy + 4]
        sub     ecx, edi
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     .no_mouse_area
 
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      .no_mouse_area
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel_new.1
        cmp     ecx, -1                 ; SHIT HAPPENS?
        jne     .no_mouse_area
 
        mov     ecx, [esp]
        jmp     .sh
 
  .no_mouse_area:
        pop     ecx
; convert to 16 bpp and store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [LFB_BASE+edx], ax
 
  .skip:
        add     edx, 2
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
        jmp     put_image_end_16.finish
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_24:
 
        mov     edi, [putimg.real_sy]
 
; check for hardware cursor
        mov     ecx, [_display.select_cursor]
        cmp     ecx, select_cursor
        je      put_image_end_24_new
        cmp     ecx, 0
        je      put_image_end_24_old
  .new_line:
        mov     ecx, [putimg.real_sx]
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
 
; store to LFB
        mov     [LFB_BASE + edx], ax
        shr     eax, 16
        mov     [LFB_BASE + edx + 2], al
 
  .skip:
        add     edx, 3
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_24_old:
 
  .new_line:
        mov     ecx, [putimg.real_sx]
;--------------------------------------
align 4
.new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
 
        push    ecx
        neg     ecx
        add     ecx, [putimg.real_sx_and_abs_cx + 4]
        shl     ecx, 16
        add     ecx, [putimg.real_sy_and_abs_cy + 4]
        sub     ecx, edi
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel
        pop     ecx
; store to LFB
        mov     [LFB_BASE + edx], ax
        shr     eax, 16
        mov     [LFB_BASE + edx + 2], al
 
  .skip:
        add     edx, 3
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
        jmp     put_image_end_24.finish
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_24_new:
 
  .new_line:
        mov     ecx, [putimg.real_sx]
 
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
 
        push    ecx
  .sh:
        neg     ecx
        add     ecx, [putimg.real_sx_and_abs_cx + 4]
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     .no_mouse_area
 
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      .no_mouse_area
 
        shl     ecx, 16
 
        add     ecx, [putimg.real_sy_and_abs_cy + 4]
        sub     ecx, edi
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     .no_mouse_area
 
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      .no_mouse_area
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel_new.1
        cmp     ecx, -1         ; SHIT HAPPENS?
        jne     .no_mouse_area
 
        mov     ecx, [esp]
        jmp     .sh
 
  .no_mouse_area:
        pop     ecx
 
; store to LFB
        mov     [LFB_BASE + edx], ax
        shr     eax, 16
        mov     [LFB_BASE + edx + 2], al
 
  .skip:
        add     edx, 3
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
        jmp     put_image_end_24.finish
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_32:
 
        mov     edi, [putimg.real_sy]
 
; check for hardware cursor
        mov     ecx, [_display.select_cursor]
        cmp     ecx, select_cursor
        je      put_image_end_32_new
        cmp     ecx, 0
        je      put_image_end_32_old
 
  .new_line:
        mov     ecx, [putimg.real_sx]
 
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
 
; store to LFB
        mov     [LFB_BASE + edx], eax
 
  .skip:
        add     edx, 4
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
        cmp     [SCR_MODE], 0x12
        jne     @f
        call    VGA__putimage
  @@:
        mov     [EGA_counter], 1
        ret
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_32_old:
 
  .new_line:
        mov     ecx, [putimg.real_sx]
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
 
        push    ecx
        neg     ecx
        add     ecx, [putimg.real_sx_and_abs_cx + 4]
        shl     ecx, 16
        add     ecx, [putimg.real_sy_and_abs_cy + 4]
        sub     ecx, edi
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel
        pop     ecx
; store to LFB
        mov     [LFB_BASE+edx], eax
 
  .skip:
        add     edx, 4
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
        jmp     put_image_end_32.finish
 
;------------------------------------------------------------------------------
 
align 4
put_image_end_32_new:
 
  .new_line:
        mov     ecx, [putimg.real_sx]
 
  .new_x:
        push    [putimg.edi]
        mov     eax, [putimg.ebp + 4]
        call    eax
        cmp     [ebp], bl
        jne     .skip
 
        push    ecx
 
  .sh:
        neg     ecx
        add     ecx, [putimg.real_sx_and_abs_cx + 4]
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     .no_mouse_area
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      .no_mouse_area
        shl     ecx, 16
 
        add     ecx, [putimg.real_sy_and_abs_cy + 4]
        sub     ecx, edi
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     .no_mouse_area
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      .no_mouse_area
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel_new.1
        cmp     ecx, -1         ; SHIT HAPPENS?
        jne     .no_mouse_area
 
        mov     ecx, [esp]
        jmp     .sh
 
  .no_mouse_area:
        pop     ecx
 
; store to LFB
        mov     [LFB_BASE+edx], eax
 
  .skip:
        add     edx, 4
        inc     ebp
        dec     ecx
        jnz     .new_x
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline]
        add     ebp, [putimg.winmap_newline]
 
        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
        jmp     put_image_end_32.finish
 
;------------------------------------------------------------------------------
; eax = x coordinate
; ebx = y coordinate
; ecx = xx RR GG BB
; xx flags:
; 0x01000000 color inversion
; 0x02000000 used for draw_rectangle without top line (for drawwindow_III and drawwindow_IV)
; edi = 0x00000001 force
 
align 4
__sys_putpixel:
 
        pushad
        cmp     eax, [_display.width]
        jge     .exit
        cmp     ebx, [_display.height]
        jge     .exit
        test    edi, 1          ; force ?
        jnz     .forced
 
; not forced
        mov     edx, [d_width_calc_area + ebx*4]
        add     edx, [_display.win_map]
        movzx   edx, byte [eax+edx]
        cmp     edx, [current_slot_idx]
        jne     .exit
 
  .forced:
; check for color inversion
        test    ecx, 0x01000000
        jz      .no_inv
 
        push    eax ebx edx edi
        call    [GETPIXEL]
        pop     edi edx ebx eax
 
        not     ecx
        rol     ecx, 8
        mov     cl, [esp + 32-8+3]
        ror     ecx, 8
        mov     [esp + 32-8], ecx
  .no_inv:
        call    [PUTPIXEL]      ; call the real put_pixel function
  .exit:
        popad
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_putpixel16:
 
        mov     ecx, eax
        shl     ecx, 16
        mov     cx, bx
 
;        imul    ebx, [BytesPerScanLine]  ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area + ebx*4]
        lea     edi, [eax*2]; edi = x*2
        mov     eax, [esp + 32-8+4]
 
; check for hardware cursor
        cmp     [_display.select_cursor], 0
        jne     @f
; check mouse area for putpixel
        test    eax, 0x04000000
        jnz     @f
        call    check_mouse_area_for_putpixel
  @@:
; store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
 
        mov     [LFB_BASE + ebx + edi], ax
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_putpixel16_new:
 
        mov     ecx, eax
        shl     ecx, 16
        mov     cx, bx
 
;        imul    ebx, [BytesPerScanLine]  ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area + ebx*4]
        lea     edi, [eax*2]; edi = x*2
        mov     eax, [esp + 32-8+4]
 
; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        jne     @f
; check mouse area for putpixel
        test    eax, 0x04000000
        jnz     @f
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     @f
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      @f
        rol     ecx, 16
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     @f
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      @f
        ror     ecx, 16
 
        call    check_mouse_area_for_putpixel_new.1
  @@:
; store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
 
        mov     [LFB_BASE + ebx + edi], ax
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_putpixel24:
 
        mov     ecx, eax
        shl     ecx, 16
        mov     cx, bx
 
;        imul    ebx, [BytesPerScanLine]  ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area + ebx*4]
        lea     edi, [eax + eax*2]; edi = x*3
        mov     eax, [esp + 32-8+4]
 
; check for hardware cursor
        cmp     [_display.select_cursor], 0
        jne     @f
; check mouse area for putpixel
        test    eax, 0x04000000
        jnz     @f
        call    check_mouse_area_for_putpixel
  @@:
 
; store to LFB
        mov     [LFB_BASE + ebx + edi], ax
        shr     eax, 16
        mov     [LFB_BASE + ebx + edi + 2], al
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_putpixel24_new:
 
        mov     ecx, eax
        shl     ecx, 16
        mov     cx, bx
 
;        imul    ebx, [BytesPerScanLine]  ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area+ebx*4]
        lea     edi, [eax + eax*2]; edi = x*3
        mov     eax, [esp + 32-8+4]
 
; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        jne     @f
; check mouse area for putpixel
        test    eax, 0x04000000
        jnz     @f
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     @f
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      @f
        rol     ecx, 16
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     @f
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      @f
        ror     ecx, 16
 
        call    check_mouse_area_for_putpixel_new.1
  @@:
; store to LFB
        mov     [LFB_BASE + ebx + edi], ax
        shr     eax, 16
        mov     [LFB_BASE + ebx + edi + 2], al
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_putpixel32:
 
        mov     ecx, eax
        shl     ecx, 16
        mov     cx, bx
 
;        imul    ebx, [BytesPerScanLine]  ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area+ebx*4]
        lea     edi, [ebx + eax*4]        ; edi = x*4+(y*y multiplier)
        mov     eax, [esp + 32-8+4]       ; eax = color
 
; check for hardware cursor
        cmp     [_display.select_cursor], 0
        jne     @f
; check mouse area for putpixel
        test    eax, 0x04000000
        jnz     @f
        call    check_mouse_area_for_putpixel
  @@:
        and     eax, 0xffffff
; store to LFB
        mov     [LFB_BASE + edi], eax
        ret
 
;-----------------------------------------------------------------------------
; eax = x
; ebx = y
 
align 4
Vesa20_putpixel32_new:
 
        mov     ecx, eax
        shl     ecx, 16
        mov     cx, bx
 
;        imul    ebx, [BytesPerScanLine]  ; ebx = y * y multiplier
        mov     ebx, [BPSLine_calc_area+ebx*4]
        lea     edi, [ebx + eax*4]        ; edi = x*4+(y*y multiplier)
        mov     eax, [esp + 32-8+4]       ; eax = color
 
; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        jne     @f
; check mouse area for putpixel
        test    eax, 0x04000000
        jnz     @f
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     @f
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      @f
        rol     ecx, 16
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     @f
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      @f
        ror     ecx, 16
 
        call    check_mouse_area_for_putpixel_new.1
  @@:
        and     eax, 0x00ffffff
; store to LFB
        mov     [LFB_BASE + edi], eax
        ret
 
;-----------------------------------------------------------------------------
 
align 4
calculate_edi:
;        mov     edi, ebx
;        imul    edi, [Screen_Max_X]
;        add     edi, ebx
        mov     edi, [d_width_calc_area + ebx*4]
        add     edi, eax
        ret
 
 
;-----------------------------------------------------------------------------
; DRAWLINE
;-----------------------------------------------------------------------------
; eax = x1 shl 16 + x2
; ebx = y1 shl 16 + y2
; ecx = color
; edi = force ?
 
align 4
__sys_draw_line:
 
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
 
        pusha
 
        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)
 
; correction for the remainder of the division
        shl     edx, 1
        cmp     ebp, edx
        jb      @f
        inc     eax
  @@:
        mov     edx, ebp        ; edx = counter (number of pixels to draw)
        mov     ebp, 1 shl 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)
; correction for the remainder of the division
        shl     edx, 1
        cmp     esi, edx
        jb      @f
        inc     eax
  @@:
        mov     edx, esi        ; edx = counter (number of pixels to draw)
        mov     esi, 1 shl 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
 
        and     ecx, 0xFBFFFFFF ; negate 0x04000000 save to mouseunder area
  .draw:
        push    eax ebx
 
; correction for the remainder of the division
        test    ah, 0x80
        jz      @f
        add     eax, 1 shl 16
  @@:
        shr     eax, 16
; correction for the remainder of the division
        test    bh, 0x80
        jz      @f
        add     ebx, 1 shl 16
  @@:
        shr     ebx, 16
;        and     ecx, 0xFBFFFFFF  ; negate 0x04000000 save to mouseunder area
;        call    [putpixel]
        call    __sys_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]
;        and     ecx, 0xFBFFFFFF ;n egate 0x04000000 save to mouseunder area
;        call    [putpixel]
        call    __sys_putpixel
 
  .exit:
        add     esp, 6*4
        popa
;        call    [draw_pointer]
        ret
 
;------------------------------------------------------------------------------
; draw an horizontal line
; eax = x1
; edx = x2
; ebx = y
; ecx = color
; edi = force ?
 
align 4
hline:
 
        push    eax edx
        cmp     edx, eax   ; make sure x2 is above x1
        jge     @f
        xchg    eax, edx
  @@:
        and     ecx, 0xFBFFFFFF  ;negate 0x04000000 save to mouseunder area
  @@:
;        call    [putpixel]
        call    __sys_putpixel
        inc     eax
        cmp     eax, edx
        jle     @b
        pop     edx eax
        ret
 
;------------------------------------------------------------------------------
; draw a vertical line
; eax = x
; ebx = y1
; edx = y2
; ecx = color
; edi = force ?
 
align 4
vline:
 
        push    ebx edx
        cmp     edx, ebx   ; make sure y2 is above y1
        jge     @f
        xchg    ebx, edx
  @@:
        and     ecx, 0xFBFFFFFF ;negate 0x04000000 save to mouseunder area
  @@:
;        call    [putpixel]
        call    __sys_putpixel
        inc     ebx
        cmp     ebx, edx
        jle     @b
        pop     edx ebx
        ret
 
;------------------------------------------------------------------------------
; eax   cx
; ebx   cy
; ecx   xe
; edx   ye
; edi   color
 
align 4
vesa20_drawbar:
 
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 ?
     .real_sx_and_abs_cx dd ?
     .real_sy_and_abs_cy dd ?
     .stack_data = 4*13
end virtual
 
        pushad
        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, [current_slot_idx]
        shl     edi, BSF sizeof.WDATA
        add     eax, [edi + window_data + WDATA.box.left]        ; win_cx
        add     ebx, [edi + window_data + 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 + window_data + WDATA.box.width]       ; ebx = wnd_sx
        inc     ebx                                     ; WDATA.box.width is one pixel less than real window x-size
        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 + window_data + 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, [_display.width]
        sub     eax, [drbar.real_sx]
        mov     [drbar.line_inc_map], eax
; line_inc_scr
        mov     eax, [drbar.real_sx]
        mov     ebx, [_display.bytes_per_pixel]
        imul    eax, ebx
        neg     eax
        add     eax, [_display.lfb_pitch]
        mov     [drbar.line_inc_scr], eax
; pointer to screen
        mov     edx, [drbar.abs_cy]
;        imul    edx, [BytesPerScanLine]
        mov     edx, [BPSLine_calc_area+edx*4]
        mov     eax, [drbar.abs_cx]
        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]
        mov     eax, [d_width_calc_area + eax*4]
 
        add     eax, [drbar.abs_cx]
        add     eax, [_display.win_map]
        xchg    eax, ebp
 
        mov     ebx, [drbar.real_sx]
        add     ebx, [drbar.abs_cx]
        mov     [drbar.real_sx_and_abs_cx], ebx
        mov     ebx, [drbar.real_sy]
        add     ebx, [drbar.abs_cy]
        mov     [drbar.real_sy_and_abs_cy], ebx
 
        add     edx, LFB_BASE
 
; get process number
        mov     ebx, [current_slot_idx]  ; bl - process num
        mov     esi, [drbar.real_sy]
        mov     eax, [drbar.color] ; BBGGRR00
        rol     eax, 8
        mov     bh, al  ; 0x80 drawing gradient bars
        ror     eax, 8
 
        cmp     byte [_display.bits_per_pixel], 16
        je      draw_bar_end_16
        cmp     byte [_display.bits_per_pixel], 24
        je      draw_bar_end_24
        cmp     byte [_display.bits_per_pixel], 32
        je      draw_bar_end_32
 
;--------------------------------------
; eax - color high   RRGGBB
; bl - process num
; ecx - temp
; edx - pointer to screen
; esi - counter
; edi - counter
 
align 4
draw_bar_end_24:
 
; check for hardware cursor
        mov     ecx, [_display.select_cursor]
        cmp     ecx, select_cursor
        je      draw_bar_end_24_new
        cmp     ecx, 0
        je      draw_bar_end_24_old
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
; store to LFB
        mov     [edx], ax
        shr     eax, 16
        mov     [edx + 2], al
  .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]
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
  .end:
        add     esp, drbar.stack_data
        popad
        xor     eax, eax
        ret
 
;------------------------------------------------------------------------------
 
align 4
draw_bar_end_24_old:
 
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
        mov     ecx, [drbar.real_sx_and_abs_cx]
        sub     ecx, edi
        shl     ecx, 16
        add     ecx, [drbar.real_sy_and_abs_cy]
        sub     ecx, esi
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel
; store to LFB
        mov     [edx], ax
        shr     eax, 16
        mov     [edx + 2], al
        mov     eax, [drbar.color]
  .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]
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
        jmp     draw_bar_end_24.end
 
;------------------------------------------------------------------------------
 
align 4
draw_bar_end_24_new:
 
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
        mov     ecx, [drbar.real_sy_and_abs_cy]
        sub     ecx, esi
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     .no_mouse_area
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      .no_mouse_area
        rol     ecx, 16
        add     ecx, [drbar.real_sx_and_abs_cx]
        sub     ecx, edi
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     .no_mouse_area
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      .no_mouse_area
        ror     ecx, 16
 
; check mouse area for putpixel
        push    eax
        call    check_mouse_area_for_putpixel_new.1
        mov     [edx], ax
        shr     eax, 16
        mov     [edx + 2], al
        pop     eax
        jmp     .skip
 
  .no_mouse_area:
; store to LFB
        mov     [edx], ax
        ror     eax, 16
        mov     [edx + 2], al
        rol     eax, 16
  .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]
 
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
        jmp     draw_bar_end_24.end
 
;------------------------------------------------------------------------------
; eax - color high   RRGGBB
; bl - process num
; ecx - temp
; edx - pointer to screen
; esi - counter
; edi - counter
 
draw_bar_end_32:
 
; check for hardware cursor
        mov     ecx, [_display.select_cursor]
        cmp     ecx, select_cursor
        je      draw_bar_end_32_new
        cmp     ecx, 0
        je      draw_bar_end_32_old
 
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
; store to LFB
        mov     [edx], eax
        mov     eax, [drbar.color]
  .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]
 
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
  .end:
        add     esp, drbar.stack_data
        popad
        cmp     [SCR_MODE], 0x12
        jne     @f
        call    VGA_draw_bar
  @@:
        xor     eax, eax
        mov     [EGA_counter], 1
        ret
 
draw_bar_end_32_old:
 
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
        mov     ecx, [drbar.real_sx_and_abs_cx]
        sub     ecx, edi
        shl     ecx, 16
        add     ecx, [drbar.real_sy_and_abs_cy]
        sub     ecx, esi
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel
; store to LFB
        mov     [edx], eax
        mov     eax, [drbar.color]
  .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]
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
        jmp     draw_bar_end_32.end
 
;------------------------------------------------------------------------------
 
align 4
draw_bar_end_32_new:
 
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
        mov     ecx, [drbar.real_sy_and_abs_cy]
        sub     ecx, esi
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     .no_mouse_area
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      .no_mouse_area
        rol     ecx, 16
        add     ecx, [drbar.real_sx_and_abs_cx]
        sub     ecx, edi
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     .no_mouse_area
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      .no_mouse_area
        ror     ecx, 16
 
; check mouse area for putpixel
        push    eax
        call    check_mouse_area_for_putpixel_new.1
        mov     [edx], eax
        pop     eax
        jmp     .skip
  .no_mouse_area:
 
; store to LFB
        mov     [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]
 
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
        jmp     draw_bar_end_32.end
 
;------------------------------------------------------------------------------
; eax - color high   RRGGBB
; bl - process num
; ecx - temp
; edx - pointer to screen
; esi - counter
; edi - counter
 
align 4
draw_bar_end_16:
 
; check for hardware cursor
        mov     ecx, [_display.select_cursor]
        cmp     ecx, select_cursor
        je      draw_bar_end_16_new
        cmp     ecx, 0
        je      draw_bar_end_16_old
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
; convert to 16 bpp and store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [edx], ax
        mov     eax, [drbar.color]
  .skip:
 
; add pixel
        add     edx, 2
        inc     ebp
        dec     edi
        jnz     .new_x
; add line
        add     edx, [drbar.line_inc_scr]
        add     ebp, [drbar.line_inc_map]
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
  .end:
        add     esp, drbar.stack_data
        popad
        cmp     [SCR_MODE], 0x12
        jne     @f
        call    VGA_draw_bar
  @@:
        xor     eax, eax
        mov     [EGA_counter], 1
        ret
 
;------------------------------------------------------------------------------
 
align 4
draw_bar_end_16_old:
 
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
        mov     ecx, [drbar.real_sx_and_abs_cx]
        sub     ecx, edi
        shl     ecx, 16
        add     ecx, [drbar.real_sy_and_abs_cy]
        sub     ecx, esi
 
; check mouse area for putpixel
        call    check_mouse_area_for_putpixel
; convert to 16 bpp and store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [edx], ax
        mov     eax, [drbar.color]
.skip:
 
; add pixel
        add     edx, 2
        inc     ebp
        dec     edi
        jnz     .new_x
 
; add line
        add     edx, [drbar.line_inc_scr]
        add     ebp, [drbar.line_inc_map]
 
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
        jmp     draw_bar_end_16.end
 
;------------------------------------------------------------------------------
 
align 4
draw_bar_end_16_new:
 
  .new_y:
        mov     edi, [drbar.real_sx]
  .new_x:
        cmp     byte [ebp], bl
        jne     .skip
 
        mov     ecx, [drbar.real_sy_and_abs_cy]
        sub     ecx, esi
 
; check for Y
        cmp     cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
        jae     .no_mouse_area
        sub     cx, [Y_UNDER_subtraction_CUR_hot_y]
        jb      .no_mouse_area
        rol     ecx, 16
        add     ecx, [drbar.real_sx_and_abs_cx]
        sub     ecx, edi
 
; check for X
        cmp     cx, [X_UNDER_sub_CUR_hot_x_add_curh]
        jae     .no_mouse_area
        sub     cx, [X_UNDER_subtraction_CUR_hot_x]
        jb      .no_mouse_area
        ror     ecx, 16
 
; check mouse area for putpixel
        push    eax
        call    check_mouse_area_for_putpixel_new.1
        push    eax
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [edx], ax
        pop     eax
        pop     eax
        jmp     .skip
 
  .no_mouse_area:
; convert to 16 bpp and store to LFB
        push    eax
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [edx], ax
        pop     eax
  .skip:
 
; add pixel
        add     edx, 2
        inc     ebp
        dec     edi
        jnz     .new_x
 
; add line
        add     edx, [drbar.line_inc_scr]
        add     ebp, [drbar.line_inc_map]
 
; drawing gradient bars
        test    bh, 0x80
        jz      @f
        test    al, al
        jz      @f
        dec     al
  @@:
        dec     esi
        jnz     .new_y
        jmp     draw_bar_end_16.end
 
;------------------------------------------------------------------------------
 
align 4
vesa20_drawbackground_tiled:
 
        pushad
; External loop for all y from start to end
        mov     ebx, [background_window + WDATA.draw_data.top]    ; y start
  dp2:
        mov     ebp, [background_window + WDATA.draw_data.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
        mov     eax, [BPSLine_calc_area+ebx*4]
        xchg    ebp, eax
        add     ebp, eax
        add     ebp, eax
        cmp     byte [_display.bytes_per_pixel], 2
        je      @f
        add     ebp, eax
        cmp     byte [_display.bytes_per_pixel], 3
        je      @f
        add     ebp, eax
 
  @@:
        add     ebp, LFB_BASE
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
        call    calculate_edi
        xchg    edi, ebp
        add     ebp, [_display.win_map]
; 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     .next_pix
 
        push    eax ecx
        mov     ecx, eax
        shl     ecx, 16
        add     ecx, ebx
 
        mov     eax, [esi]
 
; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        je      @f
        cmp     [_display.select_cursor], 0
        jne     .no_mouseunder
  @@:
        and     eax, 0xffffff
; check mouse area for putpixel
        call    [_display.check_mouse]
  .no_mouseunder:
 
        cmp     byte [_display.bits_per_pixel], 16
        je      .16bpp
; store to LFB
        mov     [edi], ax
        shr     eax, 16
        mov     [edi+2], al
        pop     ecx eax
        jmp     .next_pix
 
  .16bpp:
; convert to 16 bpp and store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [edi], ax
        pop     ecx eax
 
; Advance to next pixel
  .next_pix:
        add     esi, 3
        add     edi, [_display.bytes_per_pixel]
 
        add     ebp, edx
        add     eax, edx
        cmp     eax, [background_window + WDATA.draw_data.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, [background_window + WDATA.draw_data.bottom]
        jbe     dp2
        popad
        mov     [EGA_counter], 1
        cmp     [SCR_MODE], 0x12
        jne     @f
        call    VGA_drawbackground
  @@:
        ret
 
;------------------------------------------------------------------------------
 
align 4
vesa20_drawbackground_stretch:
 
        pushad
; Helper variables
; calculate 2^32*(BgrDataWidth-1) mod (ScreenWidth-1)
        mov     eax, [BgrDataWidth]
        dec     eax
        xor     edx, edx
        div     dword [_display.width]
        push    eax     ; high
        xor     eax, eax
        div     dword [_display.width]
        push    eax     ; low
 
; the same for height
        mov     eax, [BgrDataHeight]
        dec     eax
        xor     edx, edx
        div     dword [_display.height]
        push    eax     ; high
        xor     eax, eax
        div     dword [_display.height]
        push    eax     ; low
 
; External loop for all y from start to end
        mov     ebx, [background_window + WDATA.draw_data.top]    ; y start
        mov     ebp, [background_window + WDATA.draw_data.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
        mov     eax, [BPSLine_calc_area+ebx*4]
        xchg    ebp, eax
        add     ebp, eax
        add     ebp, eax
        cmp     byte [_display.bytes_per_pixel], 2
        jz      @f
        add     ebp, eax
        cmp     byte [_display.bytes_per_pixel], 3
        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, [_display.win_map]
        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:
        push    ecx
; check for hardware cursor
        cmp     [_display.select_cursor], select_cursor
        je      @f
        cmp     [_display.select_cursor], 0
        jne     .no_mouseunder
  @@:
        mov     ecx, [esp+20+4]        ;x
        shl     ecx, 16
        add     ecx, [esp+24+4]        ;y
; check mouse area for putpixel
        call    [_display.check_mouse]
  .no_mouseunder:
 
        cmp     [_display.bits_per_pixel], 16
        jne     .not_16bpp
; convert to 16 bpp and store to LFB
        and     eax, 00000000111110001111110011111000b
        shr     ah, 2
        shr     ax, 3
        ror     eax, 8
        add     al, ah
        rol     eax, 8
        mov     [LFB_BASE+edi], ax
        pop     ecx
        jmp     snbgp
  .not_16bpp:
 
; store to LFB
        mov     [LFB_BASE+edi], ax
        shr     eax, 16
        mov     [LFB_BASE+edi+2], al
        pop     ecx
 
  snbgp:
        add     edi, [_display.bytes_per_pixel]
        add     ebp, 1
        mov     eax, [esp+20]
        add     eax, 1
        mov     [esp+20], eax
        add     esi, 4
        cmp     eax, [background_window + WDATA.draw_data.right]
        jbe     sdp3a
 
  sdp4:
; next y
        mov     ebx, [esp+24]
        add     ebx, 1
        mov     [esp+24], ebx
        cmp     ebx, [background_window + WDATA.draw_data.bottom]
        ja      sdpdone
 
; advance edi, ebp to next scan line
        sub     eax, [background_window + WDATA.draw_data.left]
        sub     ebp, eax
        add     ebp, [_display.width]
        sub     edi, eax
        sub     edi, eax
        cmp     byte [_display.bytes_per_pixel], 2
        jz      @f
        sub     edi, eax
        cmp     byte [_display.bytes_per_pixel], 3
        jz      @f
        sub     edi, eax
 
  @@:
        add     edi, [_display.lfb_pitch]
; 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, [background_window + WDATA.draw_data.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, [_display.width]
        rep movsd
        jmp     bgr_resmooth1
 
  sdpdone:
        add     esp, 44
        popad
        mov     [EGA_counter], 1
        cmp     [SCR_MODE], 0x12
        jne     @f
        call    VGA_drawbackground
  @@:
        ret
 
;--------------------------------------
 
align 4
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, [background_window + WDATA.draw_data.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, [background_window + WDATA.draw_data.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
 
 
;------------------------------------------------------------------------------
 
align 4
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
 
;------------------------------------------------------------------------------

Rev 9925	Rev 9930
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2023. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2023. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; VESA20.INC ;;	6	;; VESA20.INC ;;
7	;; ;;	7	;; ;;
8	;; Vesa 2.0 functions for MenuetOS ;;	8	;; Vesa 2.0 functions for MenuetOS ;;
9	;; ;;	9	;; ;;
10	;; Copyright 2002 Ville Turjanmaa ;;	10	;; Copyright 2002 Ville Turjanmaa ;;
11	;; Alexey, kgaz@crosswindws.net ;;	11	;; Alexey, kgaz@crosswindws.net ;;
12	;; - Voodoo compatible graphics ;;	12	;; - Voodoo compatible graphics ;;
13	;; Juan M. Caravaca ;;	13	;; Juan M. Caravaca ;;
14	;; - Graphics optimimizations eg. drawline ;;	14	;; - Graphics optimimizations eg. drawline ;;
15	;; ;;	15	;; ;;
16	;; See file COPYING for details ;;	16	;; See file COPYING for details ;;
17	;; ;;	17	;; ;;
18	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	18	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
19		19
20	$Revision: 9925 $	20	$Revision: 9930 $
21		21
22	uglobal	22	uglobal
23	align 4	23	align 4
24	bgr_cur_line rd MAX_SCREEN_WIDTH	24	bgr_cur_line rd MAX_SCREEN_WIDTH
25	bgr_next_line rd MAX_SCREEN_WIDTH	25	bgr_next_line rd MAX_SCREEN_WIDTH
26	endg	26	endg
27		27
28	iglobal	28	iglobal
29	align 4	29	align 4
30	overlapping_of_points_ptr dd overlapping_of_points	30	overlapping_of_points_ptr dd overlapping_of_points
31	endg	31	endg
32		32
33		33
34	;-----------------------------------------------------------------------------	34	;-----------------------------------------------------------------------------
35	; eax = x	35	; eax = x
36	; ebx = y	36	; ebx = y
37		37
38	align 4	38	align 4
39	Vesa20_getpixel16:	39	Vesa20_getpixel16:
40		40
41	; check for hardware cursor	41	; check for hardware cursor
42	cmp [_display.select_cursor], select_cursor	42	cmp [_display.select_cursor], select_cursor
43	je @f	43	je @f
44	cmp [_display.select_cursor], 0	44	cmp [_display.select_cursor], 0
45	jne .no_mouseunder	45	jne .no_mouseunder
46	@@:	46	@@:
47		47
48	; check mouse area for putpixel	48	; check mouse area for putpixel
49	test ecx, 0x04000000 ; don't load to mouseunder area	49	test ecx, 0x04000000 ; don't load to mouseunder area
50	jnz .no_mouseunder	50	jnz .no_mouseunder
51	call [_display.check_m_pixel]	51	call [_display.check_m_pixel]
52	test ecx, ecx ; 0xff000000	52	test ecx, ecx ; 0xff000000
53	jnz @f	53	jnz @f
54		54
55	.no_mouseunder:	55	.no_mouseunder:
56	; imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	56	; imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
57	mov ebx, [BPSLine_calc_area + ebx*4]	57	mov ebx, [BPSLine_calc_area + ebx*4]
58	lea edi, [eax2] ; edi = x2	58	lea edi, [eax2] ; edi = x2
59	add edi, ebx ; edi = x2+(yy multiplier)	59	add edi, ebx ; edi = x2+(yy multiplier)
60		60
61	movzx ecx, word[LFB_BASE + edi]	61	movzx ecx, word[LFB_BASE + edi]
62	shl ecx, 3	62	shl ecx, 3
63	ror ecx, 8	63	ror ecx, 8
64	shl cx, 2	64	shl cx, 2
65	ror ecx, 8	65	ror ecx, 8
66	shl cl, 3	66	shl cl, 3
67	rol ecx, 16	67	rol ecx, 16
68	@@:	68	@@:
69	and ecx, 0x00ffffff	69	and ecx, 0x00ffffff
70	ret	70	ret
71		71
72	;-----------------------------------------------------------------------------	72	;-----------------------------------------------------------------------------
73	; eax = x	73	; eax = x
74	; ebx = y	74	; ebx = y
75		75
76	align 4	76	align 4
77	Vesa20_getpixel24:	77	Vesa20_getpixel24:
78		78
79	; check for hardware cursor	79	; check for hardware cursor
80	cmp [_display.select_cursor], select_cursor	80	cmp [_display.select_cursor], select_cursor
81	je @f	81	je @f
82	cmp [_display.select_cursor], 0	82	cmp [_display.select_cursor], 0
83	jne .no_mouseunder	83	jne .no_mouseunder
84	@@:	84	@@:
85		85
86	; check mouse area for putpixel	86	; check mouse area for putpixel
87	test ecx, 0x04000000 ; don't load to mouseunder area	87	test ecx, 0x04000000 ; don't load to mouseunder area
88	jnz .no_mouseunder	88	jnz .no_mouseunder
89	call [_display.check_m_pixel]	89	call [_display.check_m_pixel]
90	test ecx, ecx ; 0xff000000	90	test ecx, ecx ; 0xff000000
91	jnz @f	91	jnz @f
92		92
93	.no_mouseunder:	93	.no_mouseunder:
94	; imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	94	; imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
95	mov ebx, [BPSLine_calc_area + ebx*4]	95	mov ebx, [BPSLine_calc_area + ebx*4]
96	lea edi, [eax + eax2] ; edi = x3	96	lea edi, [eax + eax2] ; edi = x3
97	add edi, ebx ; edi = x3+(yy multiplier)	97	add edi, ebx ; edi = x3+(yy multiplier)
98		98
99	mov ecx, [LFB_BASE + edi]	99	mov ecx, [LFB_BASE + edi]
100	@@:	100	@@:
101	and ecx, 0x00ffffff	101	and ecx, 0x00ffffff
102	ret	102	ret
103		103
104	;-----------------------------------------------------------------------------	104	;-----------------------------------------------------------------------------
105	; eax = x	105	; eax = x
106	; ebx = y	106	; ebx = y
107		107
108	align 4	108	align 4
109	Vesa20_getpixel32:	109	Vesa20_getpixel32:
110		110
111	; check for hardware cursor	111	; check for hardware cursor
112	cmp [_display.select_cursor], select_cursor	112	cmp [_display.select_cursor], select_cursor
113	je @f	113	je @f
114	cmp [_display.select_cursor], 0	114	cmp [_display.select_cursor], 0
115	jne .no_mouseunder	115	jne .no_mouseunder
116	@@:	116	@@:
117		117
118	; check mouse area for putpixel	118	; check mouse area for putpixel
119	test ecx, 0x04000000 ; don't load to mouseunder area	119	test ecx, 0x04000000 ; don't load to mouseunder area
120	jnz .no_mouseunder	120	jnz .no_mouseunder
121	call [_display.check_m_pixel]	121	call [_display.check_m_pixel]
122	test ecx, ecx ; 0xff000000	122	test ecx, ecx ; 0xff000000
123	jnz @f	123	jnz @f
124		124
125	.no_mouseunder:	125	.no_mouseunder:
126	; imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	126	; imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
127	mov ebx, [BPSLine_calc_area + ebx*4]	127	mov ebx, [BPSLine_calc_area + ebx*4]
128	lea edi, [ebx + eax4] ; edi = x4+(y*y multiplier)	128	lea edi, [ebx + eax4] ; edi = x4+(y*y multiplier)
129		129
130	mov ecx, [LFB_BASE + edi]	130	mov ecx, [LFB_BASE + edi]
131	@@:	131	@@:
132	and ecx, 0x00ffffff	132	and ecx, 0x00ffffff
133	ret	133	ret
134		134
135	;-----------------------------------------------------------------------------	135	;-----------------------------------------------------------------------------
136	; ebx = pointer	136	; ebx = pointer
137	; ecx = size [x\|y]	137	; ecx = size [x\|y]
138	; edx = coordinates [x\|y]	138	; edx = coordinates [x\|y]
139	; ebp = pointer to 'get' function	139	; ebp = pointer to 'get' function
140	; esi = pointer to 'init' function	140	; esi = pointer to 'init' function
141	; edi = parameter for 'get' function	141	; edi = parameter for 'get' function
142		142
143	align 16	143	align 16
144	vesa20_putimage:	144	vesa20_putimage:
145		145
146	virtual at esp	146	virtual at esp
147	putimg:	147	putimg:
148	.real_sx dd ?	148	.real_sx dd ?
149	.real_sy dd ?	149	.real_sy dd ?
150	.image_sx dd ?	150	.image_sx dd ?
151	.image_sy dd ?	151	.image_sy dd ?
152	.image_cx dd ?	152	.image_cx dd ?
153	.image_cy dd ?	153	.image_cy dd ?
154	.pti dd ?	154	.pti dd ?
155	.abs_cx dd ?	155	.abs_cx dd ?
156	.abs_cy dd ?	156	.abs_cy dd ?
157	.line_increment dd ?	157	.line_increment dd ?
158	.winmap_newline dd ?	158	.winmap_newline dd ?
159	.screen_newline dd ?	159	.screen_newline dd ?
160	.real_sx_and_abs_cx dd ?	160	.real_sx_and_abs_cx dd ?
161	.real_sy_and_abs_cy dd ?	161	.real_sy_and_abs_cy dd ?
162	.stack_data = 4*14	162	.stack_data = 4*14
163	.edi dd ?	163	.edi dd ?
164	.esi dd ?	164	.esi dd ?
165	.ebp dd ?	165	.ebp dd ?
166	.esp dd ?	166	.esp dd ?
167	.ebx dd ?	167	.ebx dd ?
168	.edx dd ?	168	.edx dd ?
169	.ecx dd ?	169	.ecx dd ?
170	.eax dd ?	170	.eax dd ?
171	.ret_addr dd ?	171	.ret_addr dd ?
172	.arg_0 dd ?	172	.arg_0 dd ?
173	end virtual	173	end virtual
174		174
175	pushad	175	pushad
176	sub esp, putimg.stack_data	176	sub esp, putimg.stack_data
177	; save pointer to image	177	; save pointer to image
178	mov [putimg.pti], ebx	178	mov [putimg.pti], ebx
179	; unpack the size	179	; unpack the size
180	mov eax, ecx	180	mov eax, ecx
181	and ecx, 0xFFFF	181	and ecx, 0xFFFF
182	shr eax, 16	182	shr eax, 16
183	mov [putimg.image_sx], eax	183	mov [putimg.image_sx], eax
184	mov [putimg.image_sy], ecx	184	mov [putimg.image_sy], ecx
185	; unpack the coordinates	185	; unpack the coordinates
186	mov eax, edx	186	mov eax, edx
187	and edx, 0xFFFF	187	and edx, 0xFFFF
188	shr eax, 16	188	shr eax, 16
189	mov [putimg.image_cx], eax	189	mov [putimg.image_cx], eax
190	mov [putimg.image_cy], edx	190	mov [putimg.image_cy], edx
191	; calculate absolute (i.e. screen) coordinates	191	; calculate absolute (i.e. screen) coordinates
192	mov eax, [current_slot_idx]	192	mov eax, [current_slot_idx]
193	shl eax, BSF sizeof.WDATA	193	shl eax, BSF sizeof.WDATA
194	mov ebx, [eax + window_data + WDATA.box.left]	194	mov ebx, [eax + window_data + WDATA.box.left]
195	add ebx, [putimg.image_cx]	195	add ebx, [putimg.image_cx]
196	mov [putimg.abs_cx], ebx	196	mov [putimg.abs_cx], ebx
197	mov ebx, [eax +window_data + WDATA.box.top]	197	mov ebx, [eax +window_data + WDATA.box.top]
198	add ebx, [putimg.image_cy]	198	add ebx, [putimg.image_cy]
199	mov [putimg.abs_cy], ebx	199	mov [putimg.abs_cy], ebx
200	; real_sx = MIN(wnd_sx-image_cx, image_sx);	200	; real_sx = MIN(wnd_sx-image_cx, image_sx);
201	mov ebx, [eax + window_data + WDATA.box.width] ; ebx = wnd_sx	201	mov ebx, [eax + window_data + WDATA.box.width] ; ebx = wnd_sx
202	inc ebx ; WDATA.box.width is one pixel less than real window x-size	202	inc ebx ; WDATA.box.width is one pixel less than real window x-size
203	sub ebx, [putimg.image_cx]	203	sub ebx, [putimg.image_cx]
204	ja @f	204	ja @f
205	add esp, putimg.stack_data	205	add esp, putimg.stack_data
206	popad	206	popad
207	ret	207	ret
208		208
209	@@:	209	@@:
210	cmp ebx, [putimg.image_sx]	210	cmp ebx, [putimg.image_sx]
211	jbe .end_x	211	jbe .end_x
212	mov ebx, [putimg.image_sx]	212	mov ebx, [putimg.image_sx]
213	.end_x:	213	.end_x:
214	mov [putimg.real_sx], ebx	214	mov [putimg.real_sx], ebx
215	; init real_sy	215	; init real_sy
216	mov ebx, [eax + window_data + WDATA.box.height] ; ebx = wnd_sy	216	mov ebx, [eax + window_data + WDATA.box.height] ; ebx = wnd_sy
217	inc ebx	217	inc ebx
218	sub ebx, [putimg.image_cy]	218	sub ebx, [putimg.image_cy]
219	ja @f	219	ja @f
220	add esp, putimg.stack_data	220	add esp, putimg.stack_data
221	popad	221	popad
222	ret	222	ret
223		223
224	@@:	224	@@:
225	cmp ebx, [putimg.image_sy]	225	cmp ebx, [putimg.image_sy]
226	jbe .end_y	226	jbe .end_y
227	mov ebx, [putimg.image_sy]	227	mov ebx, [putimg.image_sy]
228	.end_y:	228	.end_y:
229	mov [putimg.real_sy], ebx	229	mov [putimg.real_sy], ebx
230	; line increment	230	; line increment
231	mov eax, [putimg.image_sx]	231	mov eax, [putimg.image_sx]
232	mov ecx, [putimg.real_sx]	232	mov ecx, [putimg.real_sx]
233	sub eax, ecx	233	sub eax, ecx
234	;; imul eax, [putimg.source_bpp]	234	;; imul eax, [putimg.source_bpp]
235	; lea eax, [eax + eax * 2]	235	; lea eax, [eax + eax * 2]
236	call esi	236	call esi
237	add eax, [putimg.arg_0]	237	add eax, [putimg.arg_0]
238	mov [putimg.line_increment], eax	238	mov [putimg.line_increment], eax
239	; winmap new line increment	239	; winmap new line increment
240	mov eax, [_display.width]	240	mov eax, [_display.width]
241	sub eax, [putimg.real_sx]	241	sub eax, [putimg.real_sx]
242	mov [putimg.winmap_newline], eax	242	mov [putimg.winmap_newline], eax
243	; screen new line increment	243	; screen new line increment
244	mov eax, [_display.lfb_pitch]	244	mov eax, [_display.lfb_pitch]
245	mov ebx, [_display.bytes_per_pixel]	245	mov ebx, [_display.bytes_per_pixel]
246	imul ecx, ebx	246	imul ecx, ebx
247	sub eax, ecx	247	sub eax, ecx
248	mov [putimg.screen_newline], eax	248	mov [putimg.screen_newline], eax
249	; pointer to image	249	; pointer to image
250	mov esi, [putimg.pti]	250	mov esi, [putimg.pti]
251	; pointer to screen	251	; pointer to screen
252	mov edx, [putimg.abs_cy]	252	mov edx, [putimg.abs_cy]
253	; imul edx, [BytesPerScanLine]	253	; imul edx, [BytesPerScanLine]
254	mov edx, [BPSLine_calc_area + edx*4]	254	mov edx, [BPSLine_calc_area + edx*4]
255	mov eax, [putimg.abs_cx]	255	mov eax, [putimg.abs_cx]
256	imul eax, ebx	256	imul eax, ebx
257	add edx, eax	257	add edx, eax
258	; pointer to pixel map	258	; pointer to pixel map
259	mov eax, [putimg.abs_cy]	259	mov eax, [putimg.abs_cy]
260	; imul eax, [Screen_Max_X]	260	; imul eax, [Screen_Max_X]
261	; add eax, [putimg.abs_cy]	261	; add eax, [putimg.abs_cy]
262	mov eax, [d_width_calc_area + eax*4]	262	mov eax, [d_width_calc_area + eax*4]
263		263
264	add eax, [putimg.abs_cx]	264	add eax, [putimg.abs_cx]
265	add eax, [_display.win_map]	265	add eax, [_display.win_map]
266	xchg eax, ebp	266	xchg eax, ebp
267		267
268	mov ecx, [putimg.real_sx]	268	mov ecx, [putimg.real_sx]
269	add ecx, [putimg.abs_cx]	269	add ecx, [putimg.abs_cx]
270	mov [putimg.real_sx_and_abs_cx], ecx	270	mov [putimg.real_sx_and_abs_cx], ecx
271	mov ecx, [putimg.real_sy]	271	mov ecx, [putimg.real_sy]
272	add ecx, [putimg.abs_cy]	272	add ecx, [putimg.abs_cy]
273	mov [putimg.real_sy_and_abs_cy], ecx	273	mov [putimg.real_sy_and_abs_cy], ecx
274		274
275	; get process number	275	; get process number
276	mov ebx, [current_slot_idx]	276	mov ebx, [current_slot_idx]
277		277
278	cmp byte [_display.bits_per_pixel], 16	278	cmp byte [_display.bits_per_pixel], 16
279	je put_image_end_16	279	je put_image_end_16
280	cmp byte [_display.bits_per_pixel], 24	280	cmp byte [_display.bits_per_pixel], 24
281	je put_image_end_24	281	je put_image_end_24
282	cmp byte [_display.bits_per_pixel], 32	282	cmp byte [_display.bits_per_pixel], 32
283	je put_image_end_32	283	je put_image_end_32
284		284
285	;------------------------------------------------------------------------------	285	;------------------------------------------------------------------------------
286		286
287	put_image_end_16:	287	put_image_end_16:
288		288
289	mov edi, [putimg.real_sy]	289	mov edi, [putimg.real_sy]
290		290
291	; check for hardware cursor	291	; check for hardware cursor
292	mov ecx, [_display.select_cursor]	292	mov ecx, [_display.select_cursor]
293	cmp ecx, select_cursor	293	cmp ecx, select_cursor
294	je put_image_end_16_new	294	je put_image_end_16_new
295	cmp ecx, 0	295	cmp ecx, 0
296	je put_image_end_16_old	296	je put_image_end_16_old
297	.new_line:	297	.new_line:
298	mov ecx, [putimg.real_sx]	298	mov ecx, [putimg.real_sx]
299	.new_x:	299	.new_x:
300	push [putimg.edi]	300	push [putimg.edi]
301	mov eax, [putimg.ebp + 4]	301	mov eax, [putimg.ebp + 4]
302	call eax	302	call eax
303	cmp [ebp], bl	303	cmp [ebp], bl
304	jne .skip	304	jne .skip
305	; convert to 16 bpp and store to LFB	305	; convert to 16 bpp and store to LFB
306	and eax, 00000000111110001111110011111000b	306	and eax, 00000000111110001111110011111000b
307	shr ah, 2	307	shr ah, 2
308	shr ax, 3	308	shr ax, 3
309	ror eax, 8	309	ror eax, 8
310	add al, ah	310	add al, ah
311	rol eax, 8	311	rol eax, 8
312	mov [LFB_BASE + edx], ax	312	mov [LFB_BASE + edx], ax
313	.skip:	313	.skip:
314	add edx, 2	314	add edx, 2
315	inc ebp	315	inc ebp
316	dec ecx	316	dec ecx
317	jnz .new_x	317	jnz .new_x
318		318
319	add esi, [putimg.line_increment]	319	add esi, [putimg.line_increment]
320	add edx, [putimg.screen_newline]	320	add edx, [putimg.screen_newline]
321	add ebp, [putimg.winmap_newline]	321	add ebp, [putimg.winmap_newline]
322		322
323	cmp [putimg.ebp], putimage_get1bpp	323	cmp [putimg.ebp], putimage_get1bpp
324	jz .correct	324	jz .correct
325	cmp [putimg.ebp], putimage_get2bpp	325	cmp [putimg.ebp], putimage_get2bpp
326	jz .correct	326	jz .correct
327	cmp [putimg.ebp], putimage_get4bpp	327	cmp [putimg.ebp], putimage_get4bpp
328	jnz @f	328	jnz @f
329	.correct:	329	.correct:
330	mov eax, [putimg.edi]	330	mov eax, [putimg.edi]
331	mov byte [eax], 80h	331	mov byte [eax], 80h
332	@@:	332	@@:
333	dec edi	333	dec edi
334	jnz .new_line	334	jnz .new_line
335	.finish:	335	.finish:
336	add esp, putimg.stack_data	336	add esp, putimg.stack_data
337	popad	337	popad
338	ret	338	ret
339		339
340	;------------------------------------------------------------------------------	340	;------------------------------------------------------------------------------
341		341
342	align 4	342	align 4
343	put_image_end_16_old:	343	put_image_end_16_old:
344		344
345	.new_line:	345	.new_line:
346	mov ecx, [putimg.real_sx]	346	mov ecx, [putimg.real_sx]
347	.new_x:	347	.new_x:
348	push [putimg.edi]	348	push [putimg.edi]
349	mov eax, [putimg.ebp + 4]	349	mov eax, [putimg.ebp + 4]
350	call eax	350	call eax
351	cmp [ebp], bl	351	cmp [ebp], bl
352	jne .skip	352	jne .skip
353		353
354	push ecx	354	push ecx
355	neg ecx	355	neg ecx
356	add ecx, [putimg.real_sx_and_abs_cx + 4]	356	add ecx, [putimg.real_sx_and_abs_cx + 4]
357	shl ecx, 16	357	shl ecx, 16
358	add ecx, [putimg.real_sy_and_abs_cy + 4]	358	add ecx, [putimg.real_sy_and_abs_cy + 4]
359	sub ecx, edi	359	sub ecx, edi
360		360
361	; check mouse area for putpixel	361	; check mouse area for putpixel
362	call check_mouse_area_for_putpixel	362	call check_mouse_area_for_putpixel
363	pop ecx	363	pop ecx
364		364
365	; convert to 16 bpp and store to LFB	365	; convert to 16 bpp and store to LFB
366	;; and eax, 00000000111110001111110011111000b	366	;; and eax, 00000000111110001111110011111000b
367	;; shr ah, 2	367	;; shr ah, 2
368	;; shr ax, 3	368	;; shr ax, 3
369	;; ror eax, 8	369	;; ror eax, 8
370	;; add al, ah	370	;; add al, ah
371	;; rol eax, 8	371	;; rol eax, 8
372	mov [LFB_BASE + edx], ax	372	mov [LFB_BASE + edx], ax
373	.skip:	373	.skip:
374	inc edx	374	inc edx
375	inc edx	375	inc edx
376	inc ebp	376	inc ebp
377	dec ecx	377	dec ecx
378	jnz .new_x	378	jnz .new_x
379		379
380	add esi, [putimg.line_increment]	380	add esi, [putimg.line_increment]
381	add edx, [putimg.screen_newline]	381	add edx, [putimg.screen_newline]
382	add ebp, [putimg.winmap_newline]	382	add ebp, [putimg.winmap_newline]
383		383
384	cmp [putimg.ebp], putimage_get1bpp	384	cmp [putimg.ebp], putimage_get1bpp
385	jz .correct	385	jz .correct
386	cmp [putimg.ebp], putimage_get2bpp	386	cmp [putimg.ebp], putimage_get2bpp
387	jz .correct	387	jz .correct
388	cmp [putimg.ebp], putimage_get4bpp	388	cmp [putimg.ebp], putimage_get4bpp
389	jnz @f	389	jnz @f
390	.correct:	390	.correct:
391	mov eax, [putimg.edi]	391	mov eax, [putimg.edi]
392	mov byte [eax], 80h	392	mov byte [eax], 80h
393	@@:	393	@@:
394	dec edi	394	dec edi
395	jnz .new_line	395	jnz .new_line
396	jmp put_image_end_16.finish	396	jmp put_image_end_16.finish
397		397
398	;------------------------------------------------------------------------------	398	;------------------------------------------------------------------------------
399		399
400	align 4	400	align 4
401	put_image_end_16_new:	401	put_image_end_16_new:
402		402
403	.new_line:	403	.new_line:
404	mov ecx, [putimg.real_sx]	404	mov ecx, [putimg.real_sx]
405		405
406	.new_x:	406	.new_x:
407	push [putimg.edi]	407	push [putimg.edi]
408	mov eax, [putimg.ebp + 4]	408	mov eax, [putimg.ebp + 4]
409	call eax	409	call eax
410		410
411	cmp [ebp], bl	411	cmp [ebp], bl
412	jne .skip	412	jne .skip
413		413
414	push ecx	414	push ecx
415	.sh:	415	.sh:
416	neg ecx	416	neg ecx
417	add ecx, [putimg.real_sx_and_abs_cx + 4]	417	add ecx, [putimg.real_sx_and_abs_cx + 4]
418		418
419	; check for X	419	; check for X
420	cmp cx, [X_UNDER_sub_CUR_hot_x_add_curh]	420	cmp cx, [X_UNDER_sub_CUR_hot_x_add_curh]
421	jae .no_mouse_area	421	jae .no_mouse_area
422		422
423	sub cx, [X_UNDER_subtraction_CUR_hot_x]	423	sub cx, [X_UNDER_subtraction_CUR_hot_x]
424	jb .no_mouse_area	424	jb .no_mouse_area
425		425
426	shl ecx, 16	426	shl ecx, 16
427	add ecx, [putimg.real_sy_and_abs_cy + 4]	427	add ecx, [putimg.real_sy_and_abs_cy + 4]
428	sub ecx, edi	428	sub ecx, edi
429		429
430	; check for Y	430	; check for Y
431	cmp cx, [Y_UNDER_sub_CUR_hot_y_add_curh]	431	cmp cx, [Y_UNDER_sub_CUR_hot_y_add_curh]
432	jae .no_mouse_area	432	jae .no_mouse_area
433		433
434	sub cx, [Y_UNDER_subtraction_CUR_hot_y]	434	sub cx, [Y_UNDER_subtraction_CUR_hot_y]
435	jb .no_mouse_area	435	jb .no_mouse_area
436		436
437	; check mouse area for putpixel	437	; check mouse area for putpixel
438	call check_mouse_area_for_putpixel_new.1	438	call check_mouse_area_for_putpixel_new.1
439	cmp ecx, -1 ; SHIT HAPPENS?	439	cmp ecx, -1 ; SHIT HAPPENS?
440	jne .no_mouse_area	440	jne .no_mouse_area
441		441
442	mov ecx, [esp]	442	mov ecx, [esp]
443	jmp .sh	443	jmp .sh
444		444
445	.no_mouse_area:	445	.no_mouse_area:
446	pop ecx	446	pop ecx
447	; convert to 16 bpp and store to LFB	447	; convert to 16 bpp and store to LFB
448	and eax, 00000000111110001111110011111000b	448	and eax, 00000000111110001111110011111000b
449	shr ah, 2	449	shr ah, 2
450	shr ax, 3	450	shr ax, 3
451	ror eax, 8	451	ror eax, 8
452	add al, ah	452	add al, ah
453	rol eax, 8	453	rol eax, 8
454	mov [LFB_BASE+edx], ax	454	mov [LFB_BASE+edx], ax
455		455
456	.skip:	456	.skip:
457	add edx, 2	457	add edx, 2
458	inc ebp	458	inc ebp
459	dec ecx	459	dec ecx
460	jnz .new_x	460	jnz .new_x
461		461
462	add esi, [putimg.line_increment]	462	add esi, [putimg.line_increment]
463	add edx, [putimg.screen_newline]	463	add edx, [putimg.screen_newline]
464	add ebp, [putimg.winmap_newline]	464	add ebp, [putimg.winmap_newline]
465		465
466	cmp [putimg.ebp], putimage_get1bpp	466	cmp [putimg.ebp], putimage_get1bpp
467	jz .correct	467	jz .correct
468	cmp [putimg.ebp], putimage_get2bpp	468	cmp [putimg.ebp], putimage_get2bpp
469	jz .correct	469	jz .correct
470	cmp [putimg.ebp], putimage_get4bpp	470	cmp [putimg.ebp], putimage_get4bpp
471	jnz @f	471	jnz @f
472		472
473	.correct:	473	.correct:
474	mov eax, [putimg.edi]	474	mov eax, [putimg.edi]
475	mov byte [eax], 80h	475	mov byte [eax], 80h
476		476
477	@@:	477	@@:
478	dec edi	478	dec edi
479	jnz .new_line	479	jnz .new_line
480	jmp put_image_end_16.finish	480	jmp put_image_end_16.finish
481		481
482	;------------------------------------------------------------------------------	482	;------------------------------------------------------------------------------
483		483
484	align 4	484	align 4
485	put_image_end_24:	485	put_image_end_24:
486		486
487	mov edi, [putimg.real_sy]	487	mov edi, [putimg.real_sy]
488		488
489	; check for hardware cursor	489	; check for hardware cursor
490	mov ecx, [_display.select_cursor]	490	mov ecx, [_display.select_cursor]
491	cmp ecx, select_cursor	491	cmp ecx, select_cursor
492	je put_image_end_24_new	492	je put_image_end_24_new
493	cmp ecx, 0	493	cmp ecx, 0
494	je put_image_end_24_old	494	je put_image_end_24_old
495	.new_line:	495	.new_line:
496	mov ecx, [putimg.real_sx]	496	mov ecx, [putimg.real_sx]
497	.new_x:	497	.new_x:
498	push [putimg.edi]	498	push [putimg.edi]
499	mov eax, [putimg.ebp + 4]	499	mov eax, [putimg.ebp + 4]
500	call eax	500	call eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/vesa20.inc – Rev 9925 → 9930