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

-$Revision: 431 $
+$Revision: 469 $
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                              ;;
 ;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
-        add     edi, [LFBAddress]    ; ebx = where pixel is in memory
+     add     edi, [LFBAddress]    ; ebx = where pixel is in memory
-        mov     ecx, [edi]
+     mov     ecx, [edi]
-        and     ecx, 0xffffff
+     and     ecx, 0xffffff
-        ret
+     ret
 Vesa20_getpixel32:
-        imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
+     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
-        lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
+     lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
-        add     edi, [LFBAddress]    ; ebx = where pixel is in memory
+     add     edi, [LFBAddress]    ; ebx = where pixel is in memory
 ; 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
+     pushad
-        call    [disable_mouse]
+     call    [disable_mouse]
-        sub     esp, putimg.stack_data
+     sub     esp, putimg.stack_data
-        ; save pointer to image
+; save pointer to image
-        mov     [putimg.pti], ebx
+     mov     [putimg.pti], ebx
-        ; unpack the size
+; unpack the size
-        mov     eax, ecx
+     mov     eax, ecx
-        and     ecx, 0xFFFF
+     and     ecx, 0xFFFF
-        shr     eax, 16
+     shr     eax, 16
-        mov     [putimg.image_sx], eax
+     mov     [putimg.image_sx], eax
-        mov     [putimg.image_sy], ecx
+     mov     [putimg.image_sy], ecx
-        ; unpack the coordinates
+; unpack the coordinates
-        mov     eax, edx
+     mov     eax, edx
-        and     edx, 0xFFFF
+     and     edx, 0xFFFF
-        shr     eax, 16
+     shr     eax, 16
-        mov     [putimg.image_cx], eax
+     mov     [putimg.image_cx], eax
-        mov     [putimg.image_cy], edx
+     mov     [putimg.image_cy], edx
-        ; calculate absolute (i.e. screen) coordinates
+; calculate absolute (i.e. screen) coordinates
-        mov     eax, [TASK_BASE]
+     mov     eax, [TASK_BASE]
-        mov     ebx, [eax-twdw + WDATA.box.left]
+     mov     ebx, [eax-twdw + WDATA.box.left]
-        add     ebx, [putimg.image_cx]
+     add     ebx, [putimg.image_cx]
-        mov     [putimg.abs_cx], ebx
+     mov     [putimg.abs_cx], ebx
-        mov     ebx, [eax-twdw + WDATA.box.top]
+     mov     ebx, [eax-twdw + WDATA.box.top]
-        add     ebx, [putimg.image_cy]
+     add     ebx, [putimg.image_cy]
-        mov     [putimg.abs_cy], ebx
+     mov     [putimg.abs_cy], ebx
-        ; real_sx = MIN(wnd_sx-image_cx, image_sx);
+; real_sx = MIN(wnd_sx-image_cx, image_sx);
-        mov     ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_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
+     inc     ebx
-        cmp     ebx, [putimg.image_sx]
+     cmp     ebx, [putimg.image_sx]
-        jbe     .end_x
+     jbe     .end_x
-        mov     ebx, [putimg.image_sx]
+     mov     ebx, [putimg.image_sx]
-      .end_x:
+.end_x:
-        mov     [putimg.real_sx], ebx
+     mov     [putimg.real_sx], ebx
-        ; init real_sy
+; init real_sy
-        mov     ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy
+     mov     ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy
 ; \begin{diamond}[20.08.2006]
-        inc     ebx
+     inc     ebx
 ; \end{diamond}[20.08.2006]
-        cmp     ebx, [putimg.image_sy]
+     cmp     ebx, [putimg.image_sy]
-        jbe     .end_y
+     jbe     .end_y
-        mov     ebx, [putimg.image_sy]
+     mov     ebx, [putimg.image_sy]
-      .end_y:
+.end_y:
-        mov     [putimg.real_sy], ebx
+     mov     [putimg.real_sy], ebx
-        ; line increment
+; line increment
-        mov     eax, [putimg.image_sx]
+     mov     eax, [putimg.image_sx]
-        sub     eax, [putimg.real_sx]
+     sub     eax, [putimg.real_sx]
-;;        imul    eax, [putimg.source_bpp]
+;;     imul    eax, [putimg.source_bpp]
-;        lea     eax, [eax + eax * 2]
+;     lea     eax, [eax + eax * 2]
-        call    esi
+     call    esi
-        add     eax, [putimg.arg_0]
+     add     eax, [putimg.arg_0]
-        mov     [putimg.line_increment], eax
+     mov     [putimg.line_increment], eax
-        ; winmap new line increment
+; winmap new line increment
-        mov     eax, [ScreenWidth]
+     mov     eax, [ScreenWidth]
-        inc     eax
+     inc     eax
-        sub     eax, [putimg.real_sx]
+     sub     eax, [putimg.real_sx]
-        mov     [putimg.winmap_newline], eax
+     mov     [putimg.winmap_newline], eax
-        ; screen new line increment
+; screen new line increment
-        mov     eax, [BytesPerScanLine]
+     mov     eax, [BytesPerScanLine]
-        mov     ecx, [putimg.real_sx]
+     mov     ecx, [putimg.real_sx]
-        movzx   ebx, byte [ScreenBPP]
+     movzx   ebx, byte [ScreenBPP]
-        shr     ebx, 3
+     shr     ebx, 3
-        imul    ecx, ebx
+     imul    ecx, ebx
-        sub     eax, ecx
+     sub     eax, ecx
-        mov     [putimg.screen_newline], eax
+     mov     [putimg.screen_newline], eax
-        ; pointer to image
+; pointer to image
-        mov     esi, [putimg.pti]
+     mov     esi, [putimg.pti]
-        ; pointer to screen
+; pointer to screen
-        mov     edx, [putimg.abs_cy]
+     mov     edx, [putimg.abs_cy]
-        imul    edx, [BytesPerScanLine]
+     imul    edx, [BytesPerScanLine]
-        mov     eax, [putimg.abs_cx]
+     mov     eax, [putimg.abs_cx]
-        movzx   ebx, byte [ScreenBPP]
+     movzx   ebx, byte [ScreenBPP]
-        shr     ebx, 3
+     shr     ebx, 3
-        imul    eax, ebx
+     imul    eax, ebx
-        add     edx, eax
+     add     edx, eax
-        add     edx, [LFBAddress]
+     add     edx, [LFBAddress]
-        ; pointer to pixel map
+; pointer to pixel map
-        mov     eax, [putimg.abs_cy]
+     mov     eax, [putimg.abs_cy]
-        imul    eax, [ScreenWidth]
+     imul    eax, [ScreenWidth]
-        add     eax, [putimg.abs_cy]
+     add     eax, [putimg.abs_cy]
-        add     eax, [putimg.abs_cx]
+     add     eax, [putimg.abs_cx]
-        add     eax, WinMapAddress
+     add     eax, WinMapAddress
-        xchg    eax, ebp
+     xchg    eax, ebp
-        ; get process number
+; get process number
-        mov     ebx, [CURRENT_TASK]
+     mov     ebx, [CURRENT_TASK]
-        cmp     byte [ScreenBPP], 32
+     cmp     byte [ScreenBPP], 32
-        je      put_image_end_32
+     je      put_image_end_32
 ;put_image_end_24:
-        mov     edi, [putimg.real_sy]
+     mov     edi, [putimg.real_sy]
-        align   4
+align   4
-      .new_line:
+.new_line:
-        mov     ecx, [putimg.real_sx]
+     mov     ecx, [putimg.real_sx]
-;        push    ebp edx
+;     push    ebp edx
-        align   4
+align   4
-          .new_x:
+.new_x:
-                push    [putimg.edi]
+     push    [putimg.edi]
-                mov     eax, [putimg.ebp+4]
+     mov     eax, [putimg.ebp+4]
-                call    eax
+     call    eax
-                cmp     [ebp], bl
+     cmp     [ebp], bl
-                jne     .skip
+     jne     .skip
-;                mov     eax, [esi]        ; eax = RRBBGGRR
+;     mov     eax, [esi]        ; eax = RRBBGGRR
-                mov     [edx], ax
+     mov     [edx], ax
-                shr     eax, 16
+     shr     eax, 16
-                mov     [edx+2], al
+     mov     [edx+2], al
-              .skip:
+.skip:
-;            add     esi, 3 ;[putimg.source_bpp]
+;     add     esi, 3 ;[putimg.source_bpp]
-            add     edx, 3
+     add     edx, 3
-            inc     ebp
+     inc     ebp
-            dec     ecx
+     dec     ecx
-            jnz     .new_x
+     jnz     .new_x
-;        pop     edx ebp
+;     pop     edx ebp
-        add     esi, [putimg.line_increment]
+     add     esi, [putimg.line_increment]
-        add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
+     add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
-        add     ebp, [putimg.winmap_newline] ;[ScreenWidth]
+     add     ebp, [putimg.winmap_newline] ;[ScreenWidth]
-        ;inc     ebp
+;     inc     ebp
-        dec     edi
+     dec     edi
-        jnz     .new_line
+     jnz     .new_line
-   .finish:
+.finish:
-        add     esp, putimg.stack_data
+     add     esp, putimg.stack_data
-        popad
+     popad
 put_image_end_32:
-        mov     edi, [putimg.real_sy]
+     mov     edi, [putimg.real_sy]
-        align   4
+align   4
-      .new_line:
+.new_line:
-        mov     ecx, [putimg.real_sx]
+     mov     ecx, [putimg.real_sx]
-;        push    ebp edx
+;     push    ebp edx
-        align   4
+align   4
-          .new_x:
+.new_x:
-                push    [putimg.edi]
+     push    [putimg.edi]
-                mov     eax, [putimg.ebp+4]
+     mov     eax, [putimg.ebp+4]
-                call    eax
+     call    eax
-                cmp     [ebp], bl
+     cmp     [ebp], bl
-                jne     .skip
+     jne     .skip
-;                mov     eax, [esi]        ; ecx = RRBBGGRR
+;     mov     eax, [esi]        ; ecx = RRBBGGRR
-                mov     [edx], eax
+     mov     [edx], eax
-              .skip:
+.skip:
-;            add     esi, [putimg.source_bpp]
+;     add     esi, [putimg.source_bpp]
-            add     edx, 4
+     add     edx, 4
-            inc     ebp
+     inc     ebp
-            dec     ecx
+     dec     ecx
-            jnz     .new_x
+     jnz     .new_x
-;        pop     edx ebp
+;     pop     edx ebp
-        add     esi, [putimg.line_increment]
+     add     esi, [putimg.line_increment]
-        add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
+     add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
-        add     ebp, [putimg.winmap_newline] ;[ScreenWidth]
+     add     ebp, [putimg.winmap_newline] ;[ScreenWidth]
-        ;inc     ebp
+;     inc     ebp
-        dec     edi
+     dec     edi
-        jnz     .new_line
+     jnz     .new_line
-   .finish:
+.finish:
-        add     esp, putimg.stack_data
+     add     esp, putimg.stack_data
-        popad
+     popad
 ; ebx = y coordinate
 ; ecx = ?? RR GG BB    ; 0x01000000 negation
 ; edi = 0x00000001 force
-;;;        mov  [novesachecksum], dword 0
 ;;;        mov  [novesachecksum], dword 0
-        pushad
+     pushad
-        test  edi,1                 ; force ?
+     test  edi,1                 ; force ?
-        jnz   .forced
+     jnz   .forced
-      ; not forced:
+; not forced:
-      .noneg:
+.noneg:
-        ; OK to set pixel
+; OK to set pixel
-        call  dword [PUTPIXEL]    ; call the real put_pixel function
+     call  dword [PUTPIXEL]    ; call the real put_pixel function
-      .exit:
+.exit:
-        popad
+     popad
-        ret
+     ret
 align 4
-Vesa20_putpixel24:
 Vesa20_putpixel24:
-        ; eax = x
+; eax = x
-        ; ebx = y
 ; ebx = y
-        imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
+     imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
-        lea     edi, [eax+eax*2]  ; edi = x*3
+     lea     edi, [eax+eax*2]  ; edi = x*3
-        mov     eax, [esp+32-8+4]
+     mov     eax, [esp+32-8+4]
-        add     edi, [LFBAddress]
+     add     edi, [LFBAddress]
-        add     edi, ebx          ; ebx = where to put pixel in memory
+     add     edi, ebx          ; ebx = where to put pixel in memory
-        mov     [edi], ax
+     mov     [edi], ax
-        shr     eax, 16
+     shr     eax, 16
-        mov     [edi+2], al
      mov     [edi+2], al
-        ret
+     ret
 align 4
-Vesa20_putpixel32:
+align 4
-        ; eax = x
+Vesa20_putpixel32:
-        ; ebx = y
+; eax = x
 ; ebx = y
-        imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
+     imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
-        lea     edi, [ebx+eax*4]  ; edi = x*4+(y*y multiplier)
+     lea     edi, [ebx+eax*4]  ; edi = x*4+(y*y multiplier)
-        mov     eax, [esp+32-8+4] ; eax = color
-        add     edi, [LFBAddress]     ; ebx = where to put pixel in memory
+     mov     eax, [esp+32-8+4] ; eax = color
-        mov     [edi], eax
      add     edi, [LFBAddress]     ; ebx = where to put pixel in memory
-        ret
+     mov     [edi], eax
      ret
-        xor     ebp, ebp
+     xor     ebp, ebp
-        mov     si, ax        ; esi = x2
+     mov     si, ax        ; esi = x2
-        mov     bp, bx        ; ebp = y2
+     mov     bp, bx        ; ebp = y2
-        shr     eax, 16       ; eax = x1
+     shr     eax, 16       ; eax = x1
-        shr     ebx, 16       ; ebx = y1
+     shr     ebx, 16       ; ebx = y1
-        push    eax           ; save x1
+     push    eax           ; save x1
-        push    ebx           ; save y1
+     push    ebx           ; save y1
-        push    esi           ; save x2
+     push    esi           ; save x2
-        push    ebp           ; save y2
+     push    ebp           ; save y2
-        ; checking x-axis...
+; checking x-axis...
-        sub     esi, eax      ; esi = x2-x1
+     sub     esi, eax      ; esi = x2-x1
-        push    esi           ; save y2-y1
+     push    esi           ; save y2-y1
-        jl      .x2lx1        ; is x2 less than x1 ?
+     jl      .x2lx1        ; is x2 less than x1 ?
-        jg      .no_vline     ; x1 > x2 ?
+     jg      .no_vline     ; x1 > x2 ?
-        push    edx    ; necessary to rightly restore stack frame at .exit
+     push    edx    ; necessary to rightly restore stack frame at .exit
-        jmp     .exit
+     jmp     .exit
 .x2lx1:
-        neg     esi            ; get esi absolute value
+     neg     esi            ; get esi absolute value
 .no_vline:
-        ; checking y-axis...
+; checking y-axis...
-        sub     ebp, ebx       ; ebp = y2-y1
+     sub     ebp, ebx       ; ebp = y2-y1
-        push    ebp            ; save y2-y1
+     push    ebp            ; save y2-y1
-        jl      .y2ly1         ; is y2 less than y1 ?
+     jl      .y2ly1         ; is y2 less than y1 ?
-        jg      .no_hline      ; y1 > y2 ?
+     jg      .no_hline      ; y1 > y2 ?
-        mov     edx, [dl_x2]   ; else (if y1=y2)
+     mov     edx, [dl_x2]   ; else (if y1=y2)
-        call    hline
+     call    hline
-        jmp     .exit
+     jmp     .exit
 .y2ly1:
-        neg     ebp            ; get ebp absolute value
+     neg     ebp            ; get ebp absolute value
 .no_hline:
-        cmp     ebp, esi
+     cmp     ebp, esi
-        jle     .x_rules       ; |y2-y1| < |x2-x1|  ?
+     jle     .x_rules       ; |y2-y1| < |x2-x1|  ?
-        cmp     [dl_y2], ebx   ; make sure y1 is at the begining
+     cmp     [dl_y2], ebx   ; make sure y1 is at the begining
-        jge     .no_reverse1
+     jge     .no_reverse1
-        neg     dword [dl_dx]
+     neg     dword [dl_dx]
-        mov     edx, [dl_x2]
+     mov     edx, [dl_x2]
-        mov     [dl_x2], eax
+     mov     [dl_x2], eax
-        mov     [dl_x1], edx
+     mov     [dl_x1], edx
-        mov     edx, [dl_y2]
+     mov     edx, [dl_y2]
-        mov     [dl_y2], ebx
+     mov     [dl_y2], ebx
-        mov     [dl_y1], edx
+     mov     [dl_y1], edx
 .no_reverse1:
-        mov     eax, [dl_dx]
+     mov     eax, [dl_dx]
-        cdq                    ; extend eax sing to edx
+     cdq                    ; extend eax sing to edx
-        shl     eax, 16        ; using 16bit fix-point maths
+     shl     eax, 16        ; using 16bit fix-point maths
-        idiv    ebp            ; eax = ((x2-x1)*65536)/(y2-y1)
+     idiv    ebp            ; eax = ((x2-x1)*65536)/(y2-y1)
-        mov     edx, ebp       ; edx = counter (number of pixels to draw)
+     mov     edx, ebp       ; edx = counter (number of pixels to draw)
-        mov     ebp, 1 *65536  ; <<16   ; ebp = dy = 1.0
+     mov     ebp, 1 *65536  ; <<16   ; ebp = dy = 1.0
-        mov     esi, eax       ; esi = dx
+     mov     esi, eax       ; esi = dx
-        jmp     .y_rules
+     jmp     .y_rules
-.x_rules:
 .x_rules:
-        cmp     [dl_x2], eax    ; make sure x1 is at the begining
+     cmp     [dl_x2], eax    ; make sure x1 is at the begining
-        jge     .no_reverse2
      jge     .no_reverse2
-        neg     dword [dl_dy]
+     neg     dword [dl_dy]
-        mov     edx, [dl_x2]
+     mov     edx, [dl_x2]
-        mov     [dl_x2], eax
+     mov     [dl_x2], eax
-        mov     [dl_x1], edx
+     mov     [dl_x1], edx
-        mov     edx, [dl_y2]
+     mov     edx, [dl_y2]
-        mov     [dl_y2], ebx
+     mov     [dl_y2], ebx
-        mov     [dl_y1], edx
      mov     [dl_y1], edx
-.no_reverse2:
 .no_reverse2:
-        xor     edx, edx
+     xor     edx, edx
-        mov     eax, [dl_dy]
+     mov     eax, [dl_dy]
-        cdq                    ; extend eax sing to edx
+     cdq                    ; extend eax sing to edx
-        shl     eax, 16        ; using 16bit fix-point maths
+     shl     eax, 16        ; using 16bit fix-point maths
-        idiv    esi            ; eax = ((y2-y1)*65536)/(x2-x1)
+     idiv    esi            ; eax = ((y2-y1)*65536)/(x2-x1)
-        mov     edx, esi       ; edx = counter (number of pixels to draw)
+     mov     edx, esi       ; edx = counter (number of pixels to draw)
-        mov     esi, 1 *65536  ;<< 16   ; esi = dx = 1.0
+     mov     esi, 1 *65536  ;<< 16   ; esi = dx = 1.0
-        mov     ebp, eax       ; ebp = dy
      mov     ebp, eax       ; ebp = dy
-.y_rules:
 .y_rules:
-        mov     eax, [dl_x1]
+     mov     eax, [dl_x1]
-        mov     ebx, [dl_y1]
+     mov     ebx, [dl_y1]
-        shl     eax, 16
+     shl     eax, 16
-        shl     ebx, 16
      shl     ebx, 16
-align 4
 align 4
 .draw:
-        push    eax ebx
+     push    eax ebx
-        shr     eax, 16
+     shr     eax, 16
-        shr     ebx, 16
+     shr     ebx, 16
-        call    [putpixel]
+     call    [putpixel]
-        pop     ebx eax
      pop     ebx eax
-        add     ebx, ebp        ; y = y+dy
+     add     ebx, ebp        ; y = y+dy
-        add     eax, esi        ; x = x+dx
      add     eax, esi        ; x = x+dx
-        dec     edx
+     dec     edx
-        jnz     .draw
      jnz     .draw
-        ; force last drawn pixel to be at (x2,y2)
+; force last drawn pixel to be at (x2,y2)
-        mov     eax, [dl_x2]
+     mov     eax, [dl_x2]
-        mov     ebx, [dl_y2]
+     mov     ebx, [dl_y2]
-        call    [putpixel]
+     call    [putpixel]
 ; edx = x2
 ; ebx = y
 ; ecx = color
 ; edi = force ?
-        push    eax edx
+     push    eax edx
-        cmp     edx, eax      ; make sure x2 is above x1
+     cmp     edx, eax      ; make sure x2 is above x1
-        jge     @f
+     jge     @f
-        xchg    eax, edx
+     xchg    eax, edx
-        align   4
+align   4
-   @@:
+@@:
-        call    [putpixel]
+     call    [putpixel]
-        inc     eax
+     inc     eax
-        cmp     eax, edx
+     cmp     eax, edx
-        jle     @b
+     jle     @b
-        pop     edx eax
+     pop     edx eax
-ret
+     ret
 ; ebx = y1
 ; edx = y2
 ; ecx = color
 ; edi = force ?
-        push    ebx edx
+     push    ebx edx
-        cmp     edx, ebx      ; make sure y2 is above y1
+     cmp     edx, ebx      ; make sure y2 is above y1
-        jge     @f
+     jge     @f
-        xchg    ebx, edx
+     xchg    ebx, edx
-        align   4
+align   4
-   @@:
+@@:
-        call    [putpixel]
+     call    [putpixel]
-        inc     ebx
+     inc     ebx
-        cmp     ebx, edx
+     cmp     ebx, edx
-        jle     @b
+     jle     @b
-        pop     edx ebx
+     pop     edx ebx
-ret
+     ret
 ; ebx   cy
 ; ecx   xe
 ; edx   ye
 ; edi   color
 vesa20_drawbar:
-        pushad
+     pushad
-        call    [disable_mouse]
+     call    [disable_mouse]
-        sub     esp, drbar.stack_data
+     sub     esp, drbar.stack_data
-        mov     [drbar.color], edi
+     mov     [drbar.color], edi
-        sub     edx, ebx
+     sub     edx, ebx
-        jle     .exit          ;// mike.dld, 2005-01-29
+     jle     .exit          ;// mike.dld, 2005-01-29
-        sub     ecx, eax
+     sub     ecx, eax
-        jle     .exit          ;// mike.dld, 2005-01-29
+     jle     .exit          ;// mike.dld, 2005-01-29
-        mov     [drbar.bar_sy], edx
+     mov     [drbar.bar_sy], edx
-        mov     [drbar.bar_sx], ecx
+     mov     [drbar.bar_sx], ecx
-        mov     [drbar.bar_cx], eax
+     mov     [drbar.bar_cx], eax
-        mov     [drbar.bar_cy], ebx
+     mov     [drbar.bar_cy], ebx
-        mov     edi, [TASK_BASE]
+     mov     edi, [TASK_BASE]
-        add     eax, [edi-twdw + WDATA.box.left] ; win_cx
+     add     eax, [edi-twdw + WDATA.box.left] ; win_cx
-        add     ebx, [edi-twdw + WDATA.box.top] ; win_cy
+     add     ebx, [edi-twdw + WDATA.box.top] ; win_cy
-        mov     [drbar.abs_cx], eax
+     mov     [drbar.abs_cx], eax
-        mov     [drbar.abs_cy], ebx
+     mov     [drbar.abs_cy], ebx
-        ; real_sx = MIN(wnd_sx-bar_cx, bar_sx);
+; real_sx = MIN(wnd_sx-bar_cx, bar_sx);
-        mov     ebx, [edi-twdw + WDATA.box.width] ; ebx = wnd_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
+     inc     ebx
-  .exit:                       ;// mike.dld, 2005-01-29
+.exit:                       ;// mike.dld, 2005-01-29
-        add     esp, drbar.stack_data
+     add     esp, drbar.stack_data
-        popad
+     popad
-        xor     eax, eax
+     xor     eax, eax
-        inc     eax
+     inc     eax
-        ret
+     ret
-      @@:
+@@:
-        cmp     ebx, [drbar.bar_sx]
+     cmp     ebx, [drbar.bar_sx]
-        jbe     .end_x
+     jbe     .end_x
-        mov     ebx, [drbar.bar_sx]
+     mov     ebx, [drbar.bar_sx]
-      .end_x:
+.end_x:
-        mov     [drbar.real_sx], ebx
+     mov     [drbar.real_sx], ebx
-        ; real_sy = MIN(wnd_sy-bar_cy, bar_sy);
+; real_sy = MIN(wnd_sy-bar_cy, bar_sy);
-        mov     ebx, [edi-twdw + WDATA.box.height] ; ebx = wnd_sy
+     mov     ebx, [edi-twdw + WDATA.box.height] ; ebx = wnd_sy
 ; \begin{diamond}[20.08.2006]
-        inc     ebx
+     inc     ebx
 ; \end{diamond}
-        ja      @f
+     ja      @f
-        add     esp, drbar.stack_data
+     add     esp, drbar.stack_data
-        popad
+     popad
-        xor     eax, eax
+     xor     eax, eax
-        inc     eax
+     inc     eax
-        ret
+     ret
-      @@:
+@@:
-        cmp     ebx, [drbar.bar_sy]
+     cmp     ebx, [drbar.bar_sy]
-        jbe     .end_y
+     jbe     .end_y
-        mov     ebx, [drbar.bar_sy]
+     mov     ebx, [drbar.bar_sy]
-      .end_y:
+.end_y:
-        mov     [drbar.real_sy], ebx
+     mov     [drbar.real_sy], ebx
-        ; line_inc_map
+; line_inc_map
-        mov     eax, [ScreenWidth]
+     mov     eax, [ScreenWidth]
-        sub     eax, [drbar.real_sx]
+     sub     eax, [drbar.real_sx]
-        inc     eax
+     inc     eax
-        mov     [drbar.line_inc_map], eax
+     mov     [drbar.line_inc_map], eax
-        ; line_inc_scr
+; line_inc_scr
-        mov     eax, [drbar.real_sx]
+     mov     eax, [drbar.real_sx]
-        movzx   ebx, byte [ScreenBPP]
+     movzx   ebx, byte [ScreenBPP]
-        shr     ebx, 3
+     shr     ebx, 3
-        imul    eax, ebx
+     imul    eax, ebx
-        neg     eax
+     neg     eax
-        add     eax, [BytesPerScanLine]
+     add     eax, [BytesPerScanLine]
-        mov     [drbar.line_inc_scr], eax
+     mov     [drbar.line_inc_scr], eax
-        ; pointer to screen
+; pointer to screen
-        mov     edx, [drbar.abs_cy]
+     mov     edx, [drbar.abs_cy]
-        imul    edx, [BytesPerScanLine]
+     imul    edx, [BytesPerScanLine]
-        mov     eax, [drbar.abs_cx]
+     mov     eax, [drbar.abs_cx]
-;        movzx   ebx, byte [ScreenBPP]
+;     movzx   ebx, byte [ScreenBPP]
-;        shr     ebx, 3
+;     shr     ebx, 3
-        imul    eax, ebx
+     imul    eax, ebx
-        add     edx, eax
+     add     edx, eax
-        add     edx, [LFBAddress]
+     add     edx, [LFBAddress]
-        ; pointer to pixel map
+; pointer to pixel map
-        mov     eax, [drbar.abs_cy]
+     mov     eax, [drbar.abs_cy]
-        imul    eax, [ScreenWidth]
+     imul    eax, [ScreenWidth]
-        add     eax, [drbar.abs_cy]
+     add     eax, [drbar.abs_cy]
-        add     eax, [drbar.abs_cx]
+     add     eax, [drbar.abs_cx]
-        add     eax, WinMapAddress
+     add     eax, WinMapAddress
-        xchg    eax, ebp
+     xchg    eax, ebp
-        ; get process number
+; get process number
-        mov     ebx, [CURRENT_TASK]
+     mov     ebx, [CURRENT_TASK]
-        cmp     byte [ScreenBPP], 24
+     cmp     byte [ScreenBPP], 24
-        jne     draw_bar_end_32
+     jne     draw_bar_end_32
 draw_bar_end_24:
-        mov     eax, [drbar.color]    ;; BBGGRR00
+     mov     eax, [drbar.color]    ;; BBGGRR00
-        mov     bh, al                ;; bh  = BB
+     mov     bh, al                ;; bh  = BB
 ; bh - color low    BB
 ; ecx - temp
 ; edx - pointer to screen
 ; esi - counter
 ; edi - counter
-        mov     esi, [drbar.real_sy]
+     mov     esi, [drbar.real_sy]
-        align   4
+align   4
-     .new_y:
+.new_y:
-        mov     edi, [drbar.real_sx]
+     mov     edi, [drbar.real_sx]
-        align   4
+align   4
-     .new_x:
+.new_x:
-        cmp     byte [ebp], bl
+     cmp     byte [ebp], bl
-        jne     .skip
+     jne     .skip
-        mov     [edx], bh
+     mov     [edx], bh
-        mov     [edx + 1], ax
+     mov     [edx + 1], ax
-      .skip:
+.skip:
-        ; add pixel
+; add pixel
-        add     edx, 3
+     add     edx, 3
-        inc     ebp
+     inc     ebp
-        dec     edi
+     dec     edi
-        jnz     .new_x
+     jnz     .new_x
-        ; add line
+; add line
-        add     edx, [drbar.line_inc_scr]
+     add     edx, [drbar.line_inc_scr]
-        add     ebp, [drbar.line_inc_map]
+     add     ebp, [drbar.line_inc_map]
-    ;  drawing gradient bars
+;  drawing gradient bars
-        test    eax, 0x00800000
+     test    eax, 0x00800000
-        jz      @f
+     jz      @f
-        test    bh, bh
+     test    bh, bh
-        jz      @f
+     jz      @f
-        dec     bh
+     dec     bh
-      @@:
+@@:
+;
-        dec     esi
+     dec     esi
-        jnz     .new_y
+     jnz     .new_y
-        add     esp, drbar.stack_data
+     add     esp, drbar.stack_data
-        popad
+     popad
-        xor     eax, eax
+     xor     eax, eax
-ret
+     ret
 draw_bar_end_32:
-        mov     eax, [drbar.color]    ;; BBGGRR00
      mov     eax, [drbar.color]    ;; BBGGRR00
-        mov     esi, [drbar.real_sy]
+     mov     esi, [drbar.real_sy]
-        align   4
+align   4
-     .new_y:
+.new_y:
-        mov     edi, [drbar.real_sx]
+     mov     edi, [drbar.real_sx]
-        align   4
+align   4
-     .new_x:
 .new_x:
-        cmp     byte [ebp], bl
+     cmp     byte [ebp], bl
-        jne     .skip
+     jne     .skip
-        mov     [edx], eax
+     mov     [edx], eax
-      .skip:
 .skip:
-        ; add pixel
+; add pixel
-        add     edx, 4
+     add     edx, 4
-        inc     ebp
      inc     ebp
-        dec     edi
+     dec     edi
-        jnz     .new_x
      jnz     .new_x
-        ; add line
+; add line
-        add     edx, [drbar.line_inc_scr]
+     add     edx, [drbar.line_inc_scr]
-        add     ebp, [drbar.line_inc_map]
      add     ebp, [drbar.line_inc_map]
-    ;  drawing gradient bars
+;  drawing gradient bars
-        test    eax, 0x80000000
+     test    eax, 0x80000000
-        jz      @f
+     jz      @f
-        test    al, al
+     test    al, al
-        jz      @f
+     jz      @f
-        dec     al
+     dec     al
-      @@:
+@@:
-    ;
+;
-        dec     esi
+     dec     esi
-        jnz     .new_y
      jnz     .new_y
-        add     esp, drbar.stack_data
+     add     esp, drbar.stack_data
-        popad
+     popad
-        call    VGA_draw_bar
+     call    VGA_draw_bar
-        xor     eax, eax
+     xor     eax, eax
-        mov     [EGA_counter],1
+     mov     [EGA_counter],1
-ret
      ret
 ;--------------vbe voodoo ------------------------------------------------
-vesa20_drawbackground_tiled:
 ;--------------vbe voodoo ------------------------------------------------
-     call [disable_mouse]
+vesa20_drawbackground_tiled:
      call [disable_mouse]
      push ebp
      push eax
-     push ebx
-     push ecx
+     push ebx
-     push edx
+     push ecx
      push edx
      mov edx,dword [WinMapAddress-8] ; B
-     add edx,dword [WinMapAddress-8] ; +B
      add edx,dword [WinMapAddress-8] ; +B
-     push edx
+     add edx,dword [WinMapAddress-8] ; +B
-     mov ebp,[draw_data+32+RECT.left] ; x start:=(x+Xwin)
+     push edx
-     mov ebx,[draw_data+32+RECT.top] ; y start:=(y+Ywin)
+     mov ebp,[draw_data+32+RECT.left] ; x start:=(x+Xwin)
      mov ebx,[draw_data+32+RECT.top] ; y start:=(y+Ywin)
      mov eax,[BytesPerScanLine]
      mul ebx
      xchg ebp, eax  ; BytesPerScanLine*(Ywin+y)
-     add ebp, eax   ; +X
      add ebp, eax   ; +X
      add ebp, eax   ; +X
      add ebp, eax   ; +X
      cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
      jz @f
-     add ebp,eax ; +X
-   @@:
+     add ebp,eax ; +X
-     add ebp,[LFBAddress]  ; +LFB
 @@:
-     ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
-     call calculate_edi
+     add ebp,[LFBAddress]  ; +LFB
 ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
-   dp3:                             ; MAIN LOOP
-     cmp [edi+WinMapAddress],byte 1 ; ptrBuffer^<>byte(1)
-;     je  ybgp
-;
-;     jmp nbgp
+     call calculate_edi
-;
-;   ybgp:
+dp3:                             ; MAIN LOOP
-     jne nbgp
+     cmp [edi+WinMapAddress],byte 1 ; ptrBuffer^<>byte(1)
-     push eax
+     jne nbgp
-     push ebx
+     push eax
      push ebx
-     mov ecx,dword [WinMapAddress-8]    ; B
-     xor edx,edx                   ; edx:=0
+     mov ecx,dword [WinMapAddress-8]    ; B
-     div ecx                       ; Xstart/B
      xor edx,edx                   ; edx:=0
-     ; eax=Int(qn) edx:=Rem
      div ecx                       ; Xstart/B
-     lea esi,[edx+edx*2]           ; esi:=edx*3
+; eax=Int(qn) edx:=Rem
      lea esi,[edx+edx*2]           ; esi:=edx*3
      mov ecx,dword [WinMapAddress-4]    ; ecx:=H
-     mov eax,[esp+0]               ; eax:=Ystart
-     xor edx,edx                   ;
+     mov eax,[esp+0]               ; eax:=Ystart
-     div ecx                       ; Ystart/H
+     xor edx,edx                   ;
      div ecx                       ; Ystart/H
      mov eax,edx                   ; eax:=Rem
      xor edx,edx                   ;
      mov ebx,[esp+8]               ; ebx:=B*3
+     mul ebx                       ;
+     add esi,eax                   ;
-     mul ebx                       ;
+;     mov eax,[esi+IMG_BACKGROUND]
-     add esi,eax                   ;
-     mov eax,[esi+IMG_BACKGROUND]
+     mov  eax,[img_background]
-     and eax,0xffffff
+     mov  eax,[esi+eax]
      and eax,0xffffff
      xchg edi, ebp
      stosw
      shr eax,16
      stosb
      xchg ebp, edi                 ; ebp+=3
      cmp [ScreenBPP],byte 24       ; 24 or 32 bpp ? - x size
-     jz @f
-     inc ebp ; +1
+     jz @f
-   @@:
+     inc ebp ; +1
-     pop ebx
+@@:
-     pop eax
      pop ebx
-     jmp hook1
+     pop eax
      jmp hook1
-   nbgp:
+nbgp:
      add ebp,3                     ; +3
      cmp [ScreenBPP],byte 24       ; 24 or 32 bpp ? - x size
-     jz  @f
-     inc ebp ; +1
+     jz  @f
-   @@:
      inc ebp ; +1
-   hook1:
+@@:
 hook1:
      inc edi                       ; ptrBuffer++
-     add esi,3                     ; ptrImage+=3
-     inc eax
-     cmp eax,[draw_data+32+RECT.right]         ; X > xend?
-;     jg nodp3
-;     jmp dp3
+     add esi,3                     ; ptrImage+=3
-;
-;   nodp3:
+     inc eax
-     jle dp3
      cmp eax,[draw_data+32+RECT.right]         ; X > xend?
-     mov ebp,[draw_data+32+RECT.left]
      jle dp3
-     inc ebx
+     mov ebp,[draw_data+32+RECT.left]
      inc ebx
      mov  eax,[BytesPerScanLine]
      mul  ebx
      cmp  [ScreenBPP],byte 24      ; 24 or 32 bpp ? - x size
      jz   @f
      add  ebp,eax                  ; +X=X*4
-   @@:
+@@:
      add ebp,[LFBAddress]          ; +LFB
-     ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
+; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
      call calculate_edi
      cmp ebx,[draw_data+32+RECT.bottom]
-;     jg  dp4
-;
-;     jmp dp3
-;
-;   dp4:
      jle dp3
      add esp,4
      pop edx
      pop ecx
      pop ebx
      pop eax
      pop ebp
 ; ----------
-vesa20_drawbackground_stretch:
-     call  [disable_mouse]
+vesa20_drawbackground_stretch:
      call  [disable_mouse]
      push ebp
      push eax
-     push ebx
-     push ecx
+     push ebx
-     push edx
+     push ecx
      push edx
      mov edx,dword [WinMapAddress-8] ; B
-     add edx,dword [WinMapAddress-8] ; +B
      add edx,dword [WinMapAddress-8] ; +B
-     push edx
+     add edx,dword [WinMapAddress-8] ; +B
+     push edx
      mov ebp,[draw_data+32+RECT.left] ; x start:=(x+Xwin)
      mov ebx,[draw_data+32+RECT.top] ; y start:=(y+Ywin)
      dec ebx
      mov eax,[BytesPerScanLine]
      mul ebx
      xchg ebp, eax  ; BytesPerScanLine*(Ywin+y)
-     add ebp, eax   ; +X
      add ebp, eax   ; +X
      add ebp, eax   ; +X
      add ebp, eax   ; +X
      cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
      jz  @f
-     add ebp,eax ; +X
-   @@:
+     add ebp,eax ; +X
-     add ebp,[LFBAddress] ; +LFB
 @@:
-     ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
      add ebp,[LFBAddress] ; +LFB
-     call calculate_edi
+; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
      call calculate_edi
 sdp3: ; MAIN LOOP
-div ebx
+     div ebx
-shl ecx,16
+     shl ecx,16
-mov cx,dx
+     mov cx,dx
-imul eax, [esp+8] ;8
+     imul eax, [esp+8] ;8
-add esi,eax
+     add esi,eax
-mov eax,[esi+IMG_BACKGROUND]
+;     mov eax,[esi+IMG_BACKGROUND]
+     mov  eax,[img_background]
+     push eax
+     mov  eax,[display_data-4]
+     imul eax,[display_data-8]
+     imul eax,3
+     sub  eax,3
+     cmp  eax,esi
+     pop  eax
+     jbe  @f
+     mov  eax,[esi+eax]
+@@:
-push eax
+     push eax
-ror ecx,16
+     ror ecx,16
-xor eax,eax
+     xor eax,eax
-mov ax,cx
+     mov ax,cx
-shl eax,1 ; óìíîæåíèå íà 2
+     shl eax,1 ; óìíîæåíèå íà 2
-mov ebx,[ScreenWidth]
+     mov ebx,[ScreenWidth]
-div ebx
+     div ebx
-cmp eax,5
+     cmp eax,5
-pop eax
+     pop eax
-jb @f
+     jb @f
-mov ebx,[esi+IMG_BACKGROUND+3]
+;     mov ebx,[esi+IMG_BACKGROUND+3]
+     mov  ebx,[img_background]
+     push eax
+     mov  eax,[display_data-4]
+     imul eax,[display_data-8]
+     imul eax,3
+     sub  eax,3
+     cmp  eax,esi
+     pop  eax
+     jbe  @f
+     mov  ebx,[esi+ebx+3]
-call overlapping_of_points
+     call overlapping_of_points
 @@:
-push eax
+     push eax
-ror ecx,16
+     ror ecx,16
-xor eax,eax
+     xor eax,eax
-pop eax
+     pop eax
-jb @f
+     jb @f
-mov ebx,[display_data-8]
+     mov ebx,[display_data-8]
-shl ebx,1
+     shl ebx,1
-add ebx,[display_data-8]
+     add ebx,[display_data-8]
-add ebx,IMG_BACKGROUND
+     add ebx,[img_background]   ;IMG_BACKGROUND
+     push eax
+     mov  eax,[display_data-4]
+     imul eax,[display_data-8]
+     imul eax,3
+     cmp  eax,esi
+     pop  eax
+     jbe  @f
-add ebx,esi
+     add ebx,esi
-mov ebx,[ebx]
+     mov ebx,[ebx]
-call overlapping_of_points
+     call overlapping_of_points
 @@:
-and eax,0xffffff
+     and eax,0xffffff
      jz  @f
      inc ebp ; +1
-   @@:
+@@:
-   shook1:
 shook1:
      inc edi                       ; ptrBuffer++
      add esi,3                     ; ptrImage+=3
      inc eax
      cmp eax,[draw_data+32+RECT.right]         ; X > xend?
+     jle sdp3
-     jle sdp3
+;     jbe sdp3
      ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
+     call calculate_edi
 ;     cmp ebx,[ScreenHeight]
-     call calculate_edi
+;     ja  @f
+     cmp ebx,[draw_data+32+RECT.bottom]
-     cmp ebx,[draw_data+32+RECT.bottom]
+     jle sdp3
-     jle sdp3
+;     jbe sdp3
 @@:
      add esp,4

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/vesa20.inc – Rev 431 → 469