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


$Revision: 425 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                        ;;
;;  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                          ;;
;;                                                        ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; If you're planning to write your own video driver I suggest
; you replace the VESA12.INC file and see those instructions.
 
;ScreenWidth             equ     0xfe00
;ScreenHeight            equ     0xfe04
;BytesPerScanLine        equ     0xfe08
;LFBAddress              equ     0xfe80
;ScreenBPP               equ     0xfbf1
;WinMapAddress           equ     0x460000
 
 
 
;*************************************************
; getpixel
;
; in:
; eax = x coordinate
; ebx = y coordinate
;
; ret:
; ecx = 00 RR GG BB
 
getpixel:
        push    eax ebx edx edi
        call    dword [GETPIXEL]
        pop     edi edx ebx eax
        ret
 
Vesa20_getpixel24:
        ; eax = x
        ; ebx = y
        imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
        lea     edi, [eax+eax*2] ; edi = x*3
        add     edi, ebx         ; edi = x*3+(y*y multiplier)
        add     edi, [LFBAddress]    ; ebx = where pixel is in memory
        mov     ecx, [edi]
        and     ecx, 0xffffff
        ret
 
 
Vesa20_getpixel32:
        imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
        lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
        add     edi, [LFBAddress]    ; ebx = where pixel is in memory
        mov     ecx, [edi]
        and     ecx, 0xffffff
        ret
 
;*************************************************
 
virtual at esp
 putimg:
   .real_sx        dd ?
   .real_sy        dd ?
   .image_sx       dd ?
   .image_sy       dd ?
   .image_cx       dd ?
   .image_cy       dd ?
   .pti            dd ?
   .abs_cx         dd ?
   .abs_cy         dd ?
   .line_increment dd ?
   .winmap_newline dd ?
   .screen_newline dd ?
   .stack_data = 4*12
   .edi         dd      ?
   .esi         dd      ?
   .ebp         dd      ?
   .esp         dd      ?
   .ebx         dd      ?
   .edx         dd      ?
   .ecx         dd      ?
   .eax         dd      ?
   .ret_addr    dd      ?
   .arg_0       dd      ?
end virtual
 
align 16
; ebx = pointer
; ecx = size [x|y]
; edx = coordinates [x|y]
; ebp = pointer to 'get' function
; esi = pointer to 'init' function
; edi = parameter for 'get' function
vesa20_putimage:
        pushad
        call    [disable_mouse]
 
        sub     esp, putimg.stack_data
 
        ; save pointer to image
        mov     [putimg.pti], ebx
 
        ; unpack the size
        mov     eax, ecx
        and     ecx, 0xFFFF
        shr     eax, 16
        mov     [putimg.image_sx], eax
        mov     [putimg.image_sy], ecx
 
        ; unpack the coordinates
        mov     eax, edx
        and     edx, 0xFFFF
        shr     eax, 16
        mov     [putimg.image_cx], eax
        mov     [putimg.image_cy], edx
 
        ; calculate absolute (i.e. screen) coordinates
        mov     eax, [TASK_BASE]
        mov     ebx, [eax-twdw + WDATA.box.left]
        add     ebx, [putimg.image_cx]
        mov     [putimg.abs_cx], ebx
        mov     ebx, [eax-twdw + WDATA.box.top]
        add     ebx, [putimg.image_cy]
        mov     [putimg.abs_cy], ebx
 
        ; real_sx = MIN(wnd_sx-image_cx, image_sx);
        mov     ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx
; \begin{diamond}[20.08.2006]
; note that WDATA.box.width is one pixel less than real window x-size
        inc     ebx
; \end{diamond}[20.08.2006]
        sub     ebx, [putimg.image_cx]
        ja      @f
        add     esp, putimg.stack_data
        popad
        ret
      @@:
        cmp     ebx, [putimg.image_sx]
        jbe     .end_x
        mov     ebx, [putimg.image_sx]
      .end_x:
        mov     [putimg.real_sx], ebx
 
        ; init real_sy
        mov     ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy
; \begin{diamond}[20.08.2006]
        inc     ebx
; \end{diamond}[20.08.2006]
        sub     ebx, [putimg.image_cy]
        ja      @f
        add     esp, putimg.stack_data
        popad
        ret
      @@:
        cmp     ebx, [putimg.image_sy]
        jbe     .end_y
        mov     ebx, [putimg.image_sy]
      .end_y:
        mov     [putimg.real_sy], ebx
 
        ; line increment
        mov     eax, [putimg.image_sx]
        sub     eax, [putimg.real_sx]
;;        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, [ScreenWidth]
        inc     eax
        sub     eax, [putimg.real_sx]
        mov     [putimg.winmap_newline], eax
 
        ; screen new line increment
        mov     eax, [BytesPerScanLine]
        mov     ecx, [putimg.real_sx]
        movzx   ebx, byte [ScreenBPP]
        shr     ebx, 3
        imul    ecx, ebx
        sub     eax, ecx
        mov     [putimg.screen_newline], eax
 
        ; pointer to image
        mov     esi, [putimg.pti]
 
        ; pointer to screen
        mov     edx, [putimg.abs_cy]
        imul    edx, [BytesPerScanLine]
        mov     eax, [putimg.abs_cx]
        movzx   ebx, byte [ScreenBPP]
        shr     ebx, 3
        imul    eax, ebx
        add     edx, eax
        add     edx, [LFBAddress]
 
        ; pointer to pixel map
        mov     eax, [putimg.abs_cy]
        imul    eax, [ScreenWidth]
        add     eax, [putimg.abs_cy]
        add     eax, [putimg.abs_cx]
        add     eax, WinMapAddress
        xchg    eax, ebp
 
        ; get process number
        mov     ebx, [CURRENT_TASK]
 
        cmp     byte [ScreenBPP], 32
        je      put_image_end_32
 
;put_image_end_24:
        mov     edi, [putimg.real_sy]
        align   4
      .new_line:
        mov     ecx, [putimg.real_sx]
 
;        push    ebp edx
        align   4
          .new_x:
 
                push    [putimg.edi]
                mov     eax, [putimg.ebp+4]
                call    eax
                cmp     [ebp], bl
                jne     .skip
;                mov     eax, [esi]        ; eax = RRBBGGRR
                mov     [edx], ax
                shr     eax, 16
                mov     [edx+2], al
              .skip:
 
;            add     esi, 3 ;[putimg.source_bpp]
            add     edx, 3
            inc     ebp
 
            dec     ecx
            jnz     .new_x
;        pop     edx ebp
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
        add     ebp, [putimg.winmap_newline] ;[ScreenWidth]
        ;inc     ebp
 
        dec     edi
        jnz     .new_line
   .finish:
        add     esp, putimg.stack_data
        popad
ret
 
put_image_end_32:
        mov     edi, [putimg.real_sy]
        align   4
      .new_line:
        mov     ecx, [putimg.real_sx]
 
;        push    ebp edx
        align   4
          .new_x:
 
                push    [putimg.edi]
                mov     eax, [putimg.ebp+4]
                call    eax
                cmp     [ebp], bl
                jne     .skip
;                mov     eax, [esi]        ; ecx = RRBBGGRR
                mov     [edx], eax
              .skip:
 
;            add     esi, [putimg.source_bpp]
            add     edx, 4
            inc     ebp
 
            dec     ecx
            jnz     .new_x
;        pop     edx ebp
 
        add     esi, [putimg.line_increment]
        add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
        add     ebp, [putimg.winmap_newline] ;[ScreenWidth]
        ;inc     ebp
 
        dec     edi
        jnz     .new_line
   .finish:
        add     esp, putimg.stack_data
        popad
        call   VGA__putimage
        mov     [EGA_counter],1
ret
 
 
;*************************************************
align 4
__sys_putpixel:
 
; eax = x coordinate
; ebx = y coordinate
; ecx = ?? RR GG BB    ; 0x01000000 negation
; edi = 0x00000001 force
 
;;;        mov  [novesachecksum], dword 0
 
        pushad
        test  edi,1                 ; force ?
        jnz   .forced
      ; not forced:
        push  ecx               ; save 24th bit in case negative pixel wanted
        call  checkpixel
        test  ecx,ecx
        pop   ecx
        jnz   .exit
      .forced:
        cmp   [ScreenWidth], eax
        jb    .exit
        cmp   [ScreenHeight], ebx
        jb    .exit
      .ok:
        ; check if negation
        test  ecx,0x01000000
        jz    .noneg
        call  getpixel
        not   ecx
        mov   [esp+32-8],ecx
      .noneg:
        ; OK to set pixel
        call  dword [PUTPIXEL]    ; call the real put_pixel function
      .exit:
        popad
 
        ret
 
align 4
Vesa20_putpixel24:
 
        ; eax = x
        ; ebx = y
 
        imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
        lea     edi, [eax+eax*2]  ; edi = x*3
        mov     eax, [esp+32-8+4]
        add     edi, [LFBAddress]
        add     edi, ebx          ; ebx = where to put pixel in memory
        mov     [edi], ax
        shr     eax, 16
        mov     [edi+2], al
 
        ret
 
 
align 4
Vesa20_putpixel32:
 
        ; eax = x
        ; ebx = y
 
        imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
        lea     edi, [ebx+eax*4]  ; edi = x*4+(y*y multiplier)
        mov     eax, [esp+32-8+4] ; eax = color
        add     edi, [LFBAddress]     ; ebx = where to put pixel in memory
        mov     [edi], eax
 
        ret
 
 
;*************************************************
 
;align 4
calculate_edi:
        mov     edi, ebx
        imul    edi, [ScreenWidth]
        add     edi, ebx
        add     edi, eax
ret
 
;*************************************************
 
; DRAWLINE
 
align 4
__sys_draw_line:
;     inc   [mouse_pause]
        call    [disable_mouse]
 
; draw a line
; eax = HIWORD = x1
;       LOWORD = x2
; ebx = HIWORD = y1
;       LOWORD = y2
; ecx = color
; edi = force ?
        pusha
 
dl_x1 equ esp+20
dl_y1 equ esp+16
dl_x2 equ esp+12
dl_y2 equ esp+8
dl_dx equ esp+4
dl_dy equ esp+0
 
        xor     edx, edx      ; clear edx
        xor     esi, esi      ; unpack arguments
        xor     ebp, ebp
        mov     si, ax        ; esi = x2
        mov     bp, bx        ; ebp = y2
        shr     eax, 16       ; eax = x1
        shr     ebx, 16       ; ebx = y1
 
        push    eax           ; save x1
        push    ebx           ; save y1
        push    esi           ; save x2
        push    ebp           ; save y2
 
        ; checking x-axis...
        sub     esi, eax      ; esi = x2-x1
        push    esi           ; save y2-y1
        jl      .x2lx1        ; is x2 less than x1 ?
        jg      .no_vline     ; x1 > x2 ?
        mov     edx, ebp      ; else (if x1=x2)
        call    vline
        push    edx    ; necessary to rightly restore stack frame at .exit
        jmp     .exit
.x2lx1:
        neg     esi            ; get esi absolute value
.no_vline:
 
        ; checking y-axis...
        sub     ebp, ebx       ; ebp = y2-y1
        push    ebp            ; save y2-y1
        jl      .y2ly1         ; is y2 less than y1 ?
        jg      .no_hline      ; y1 > y2 ?
        mov     edx, [dl_x2]   ; else (if y1=y2)
        call    hline
        jmp     .exit
.y2ly1:
        neg     ebp            ; get ebp absolute value
.no_hline:
 
 
        cmp     ebp, esi
        jle     .x_rules       ; |y2-y1| < |x2-x1|  ?
 
        cmp     [dl_y2], ebx   ; make sure y1 is at the begining
        jge     .no_reverse1
 
        neg     dword [dl_dx]
        mov     edx, [dl_x2]
        mov     [dl_x2], eax
        mov     [dl_x1], edx
        mov     edx, [dl_y2]
        mov     [dl_y2], ebx
        mov     [dl_y1], edx
 
.no_reverse1:
 
        mov     eax, [dl_dx]
        cdq                    ; extend eax sing to edx
        shl     eax, 16        ; using 16bit fix-point maths
        idiv    ebp            ; eax = ((x2-x1)*65536)/(y2-y1)
        mov     edx, ebp       ; edx = counter (number of pixels to draw)
        mov     ebp, 1 *65536  ; <<16   ; ebp = dy = 1.0
        mov     esi, eax       ; esi = dx
 
        jmp     .y_rules
.x_rules:
 
        cmp     [dl_x2], eax    ; make sure x1 is at the begining
        jge     .no_reverse2
 
        neg     dword [dl_dy]
        mov     edx, [dl_x2]
        mov     [dl_x2], eax
        mov     [dl_x1], edx
        mov     edx, [dl_y2]
        mov     [dl_y2], ebx
        mov     [dl_y1], edx
 
.no_reverse2:
 
        xor     edx, edx
        mov     eax, [dl_dy]
        cdq                    ; extend eax sing to edx
        shl     eax, 16        ; using 16bit fix-point maths
        idiv    esi            ; eax = ((y2-y1)*65536)/(x2-x1)
        mov     edx, esi       ; edx = counter (number of pixels to draw)
        mov     esi, 1 *65536  ;<< 16   ; esi = dx = 1.0
        mov     ebp, eax       ; ebp = dy
 
.y_rules:
 
        mov     eax, [dl_x1]
        mov     ebx, [dl_y1]
        shl     eax, 16
        shl     ebx, 16
 
align 4
 
.draw:
        push    eax ebx
        shr     eax, 16
        shr     ebx, 16
        call    [putpixel]
        pop     ebx eax
 
        add     ebx, ebp        ; y = y+dy
        add     eax, esi        ; x = x+dx
 
        dec     edx
        jnz     .draw
 
        ; force last drawn pixel to be at (x2,y2)
        mov     eax, [dl_x2]
        mov     ebx, [dl_y2]
        call    [putpixel]
.exit:
        add     esp, 6*4
        popa
;     dec   [mouse_pause]
     call   [draw_pointer]
ret
 
 
hline:
; draw an horizontal line
; eax = x1
; edx = x2
; ebx = y
; ecx = color
; edi = force ?
        push    eax edx
 
        cmp     edx, eax      ; make sure x2 is above x1
        jge     @f
        xchg    eax, edx
        align   4
   @@:
        call    [putpixel]
        inc     eax
        cmp     eax, edx
        jle     @b
 
        pop     edx eax
ret
 
 
vline:
; draw a vertical line
; eax = x
; ebx = y1
; edx = y2
; ecx = color
; edi = force ?
        push    ebx edx
 
        cmp     edx, ebx      ; make sure y2 is above y1
        jge     @f
        xchg    ebx, edx
        align   4
   @@:
        call    [putpixel]
        inc     ebx
        cmp     ebx, edx
        jle     @b
 
        pop     edx ebx
ret
 
 
;*************************************************
 
 
virtual at esp
      drbar:
        .bar_sx       dd ?
        .bar_sy       dd ?
        .bar_cx       dd ?
        .bar_cy       dd ?
        .abs_cx       dd ?
        .abs_cy       dd ?
        .real_sx      dd ?
        .real_sy      dd ?
        .color        dd ?
        .line_inc_scr dd ?
        .line_inc_map dd ?
        .stack_data = 4*11
end virtual
 
align 4
; eax   cx
; ebx   cy
; ecx   xe
; edx   ye
; edi   color
vesa20_drawbar:
 
        pushad
        call    [disable_mouse]
 
        sub     esp, drbar.stack_data
 
        mov     [drbar.color], edi
 
        sub     edx, ebx
        jle     .exit          ;// mike.dld, 2005-01-29
        sub     ecx, eax
        jle     .exit          ;// mike.dld, 2005-01-29
        mov     [drbar.bar_sy], edx
        mov     [drbar.bar_sx], ecx
 
        mov     [drbar.bar_cx], eax
        mov     [drbar.bar_cy], ebx
 
        mov     edi, [TASK_BASE]
        add     eax, [edi-twdw + WDATA.box.left] ; win_cx
        add     ebx, [edi-twdw + WDATA.box.top] ; win_cy
        mov     [drbar.abs_cx], eax
        mov     [drbar.abs_cy], ebx
 
        ; real_sx = MIN(wnd_sx-bar_cx, bar_sx);
        mov     ebx, [edi-twdw + WDATA.box.width] ; ebx = wnd_sx
; \begin{diamond}[20.08.2006]
; note that WDATA.box.width is one pixel less than real window x-size
        inc     ebx
; \end{diamond}[20.08.2006]
        sub     ebx, [drbar.bar_cx]
        ja      @f
  .exit:                       ;// mike.dld, 2005-01-29
        add     esp, drbar.stack_data
        popad
        xor     eax, eax
        inc     eax
 
        ret
      @@:
        cmp     ebx, [drbar.bar_sx]
        jbe     .end_x
        mov     ebx, [drbar.bar_sx]
      .end_x:
        mov     [drbar.real_sx], ebx
 
        ; real_sy = MIN(wnd_sy-bar_cy, bar_sy);
        mov     ebx, [edi-twdw + WDATA.box.height] ; ebx = wnd_sy
; \begin{diamond}[20.08.2006]
        inc     ebx
; \end{diamond}
        sub     ebx, [drbar.bar_cy]
        ja      @f
        add     esp, drbar.stack_data
        popad
        xor     eax, eax
        inc     eax
 
        ret
      @@:
        cmp     ebx, [drbar.bar_sy]
        jbe     .end_y
        mov     ebx, [drbar.bar_sy]
      .end_y:
        mov     [drbar.real_sy], ebx
 
        ; line_inc_map
        mov     eax, [ScreenWidth]
        sub     eax, [drbar.real_sx]
        inc     eax
        mov     [drbar.line_inc_map], eax
 
        ; line_inc_scr
        mov     eax, [drbar.real_sx]
        movzx   ebx, byte [ScreenBPP]
        shr     ebx, 3
        imul    eax, ebx
        neg     eax
        add     eax, [BytesPerScanLine]
        mov     [drbar.line_inc_scr], eax
 
        ; pointer to screen
        mov     edx, [drbar.abs_cy]
        imul    edx, [BytesPerScanLine]
        mov     eax, [drbar.abs_cx]
;        movzx   ebx, byte [ScreenBPP]
;        shr     ebx, 3
        imul    eax, ebx
        add     edx, eax
        add     edx, [LFBAddress]
 
        ; pointer to pixel map
        mov     eax, [drbar.abs_cy]
        imul    eax, [ScreenWidth]
        add     eax, [drbar.abs_cy]
        add     eax, [drbar.abs_cx]
        add     eax, WinMapAddress
        xchg    eax, ebp
 
        ; get process number
        mov     ebx, [CURRENT_TASK]
 
        cmp     byte [ScreenBPP], 24
        jne     draw_bar_end_32
draw_bar_end_24:
        mov     eax, [drbar.color]    ;; BBGGRR00
        mov     bh, al                ;; bh  = BB
        shr     eax, 8                ;; eax = RRGG
; eax - color high   RRGG
; bl - process num
; bh - color low    BB
; ecx - temp
; edx - pointer to screen
; esi - counter
; edi - counter
 
        mov     esi, [drbar.real_sy]
        align   4
     .new_y:
        mov     edi, [drbar.real_sx]
        align   4
     .new_x:
 
        cmp     byte [ebp], bl
        jne     .skip
        mov     [edx], bh
        mov     [edx + 1], ax
      .skip:
 
        ; add pixel
        add     edx, 3
        inc     ebp
 
        dec     edi
        jnz     .new_x
 
        ; add line
        add     edx, [drbar.line_inc_scr]
        add     ebp, [drbar.line_inc_map]
 
    ;  drawing gradient bars
        test    eax, 0x00800000
        jz      @f
        test    bh, bh
        jz      @f
        dec     bh
      @@:
    ; 
 
        dec     esi
        jnz     .new_y
 
        add     esp, drbar.stack_data
        popad
        xor     eax, eax
ret
 
draw_bar_end_32:
        mov     eax, [drbar.color]    ;; BBGGRR00
 
        mov     esi, [drbar.real_sy]
        align   4
     .new_y:
        mov     edi, [drbar.real_sx]
        align   4
     .new_x:
 
        cmp     byte [ebp], bl
        jne     .skip
        mov     [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    eax, 0x80000000
        jz      @f
        test    al, al
        jz      @f
        dec     al
      @@:
    ; 
 
        dec     esi
        jnz     .new_y
 
        add     esp, drbar.stack_data
        popad
        call    VGA_draw_bar
        xor     eax, eax
        mov     [EGA_counter],1
ret
 
 
;voodoodbcplimit:
 
; ebp:=(y+Ywin)*(ScreenXSize+1)+(x+Xwin)+AddrBuffer
 
 
;     pusha
 
;     xor edx,edx
;     mov eax,ebp
;     mov ebx,[ScreenWidth] ; Screen_X_size
;     inc ebx   ; +1
;     sub eax,WinMapAddress ; -AddrBuffer
;     div ebx ;
;     mov ebx,eax ; ebx:=Y
;     mov eax,edx ; eax:=X
;     call cplimit
 
;     test ecx,ecx
;     jne  dbcpl12
;     popa
;     clc
;     ret
;   dbcpl12:
;     popa
;     stc
;     ret
 
 
 
 
;dbcplimit:
 
;        pusha
 
;        xor  edx,edx
;        mov  ebx,[ScreenWidth]
;        inc  ebx
;        sub  eax,WinMapAddress
;        div  ebx
;        mov  ebx,eax
;        mov  eax,edx
;        call cplimit
 
;        test ecx,ecx
;        jne  dbcpl1
;        popa
;        clc
;        ret
;     dbcpl1:
;        popa
;        stc
;        ret
 
 
 
 
 
 
;--------------vbe voodoo ------------------------------------------------
vesa20_drawbackground_tiled:
 
     call [disable_mouse]
 
     push ebp
     push eax
     push ebx
     push ecx
     push edx
 
     mov edx,dword [WinMapAddress-8] ; B
     add edx,dword [WinMapAddress-8] ; +B
     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)
 
     mov eax,[BytesPerScanLine]
     mul ebx
     xchg ebp, eax  ; BytesPerScanLine*(Ywin+y)
     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,[LFBAddress]  ; +LFB
 
     ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
 
     call calculate_edi
 
 
   dp3:                             ; MAIN LOOP
 
     cmp [edi+WinMapAddress],byte 1 ; ptrBuffer^<>byte(1)
;     je  ybgp
;
;     jmp nbgp
;
;   ybgp:
     jne nbgp
 
     push eax
     push ebx
 
     mov ecx,dword [WinMapAddress-8]    ; B
     xor edx,edx                   ; edx:=0
     div ecx                       ; Xstart/B
 
     ; 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                   ;
     div ecx                       ; Ystart/H
 
     mov eax,edx                   ; eax:=Rem
     xor edx,edx                   ;
     mov ebx,[esp+8]               ; ebx:=B*3
     mul ebx                       ;
     add esi,eax                   ;
     mov eax,[esi+IMG_BACKGROUND]
     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
   @@:
 
     pop ebx
     pop eax
 
     jmp hook1
 
   nbgp:
     add ebp,3                     ; +3
     cmp [ScreenBPP],byte 24       ; 24 or 32 bpp ? - x size
     jz  @f
     inc ebp ; +1
   @@:
 
   hook1:
 
     inc edi                       ; ptrBuffer++
     add esi,3                     ; ptrImage+=3
     inc eax
     cmp eax,[draw_data+32+RECT.right]         ; X > xend?
;     jg nodp3
;     jmp dp3
;
;   nodp3:
     jle dp3
 
     mov ebp,[draw_data+32+RECT.left]
 
     inc ebx
 
     mov  eax,[BytesPerScanLine]
     mul  ebx
     xchg ebp, eax                 ; BytesPerScanLine*(Ywin+y)
     add  ebp, eax                 ; +X
     add  ebp, eax                 ; +X=X*2
     add  ebp, eax                 ; +X=X*3
     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
 
     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
     mov     [EGA_counter],1
     call  VGA_drawbackground
     ret
 
; ----------
 
 
vesa20_drawbackground_stretch:
 
     call  [disable_mouse]
 
     push ebp
     push eax
     push ebx
     push ecx
     push edx
 
     mov edx,dword [WinMapAddress-8] ; B
     add edx,dword [WinMapAddress-8] ; +B
     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)
 
     mov eax,[BytesPerScanLine]
     mul ebx
     xchg ebp, eax  ; BytesPerScanLine*(Ywin+y)
     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,[LFBAddress] ; +LFB
 
     ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
 
     call calculate_edi
 
 
sdp3: ; MAIN LOOP
cmp [edi+WinMapAddress],byte 1 ; ptrBuffer^<>byte(1)
jne snbgp
push eax
push ebx
mov eax,dword [WinMapAddress-8]
imul eax, [esp+4] ;4
xor edx,edx
mov ebx,[ScreenWidth]
div ebx
mov cx,dx
lea esi,[eax+eax*2]
mov eax,dword [WinMapAddress-4]
imul eax, [esp+0] ;0
xor edx,edx
mov ebx,[ScreenHeight]
div ebx
shl ecx,16
mov cx,dx
imul eax, [esp+8] ;8
add esi,eax
mov eax,[esi+IMG_BACKGROUND]
push eax
ror ecx,16
xor eax,eax
mov ax,cx
shl eax,1 ; óìíîæåíèå íà 2
lea eax,[eax+eax*4] ; óìíîæåíèå íà 5
xor edx,edx
mov ebx,[ScreenWidth]
div ebx
cmp eax,5
pop eax
jb @f
mov ebx,[esi+IMG_BACKGROUND+3]
call overlapping_of_points
@@:
push eax
ror ecx,16
xor eax,eax
mov ax,cx
shl eax,1 ; óìíîæåíèå íà 2
lea eax,[eax+eax*4] ; óìíîæåíèå íà
xor edx,edx
mov ebx,[ScreenHeight]
div ebx
cmp eax,5
pop eax
jb @f
mov ebx,[display_data-8]
shl ebx,1
add ebx,[display_data-8]
add ebx,IMG_BACKGROUND
add ebx,esi
mov ebx,[ebx]
call overlapping_of_points
@@:
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
@@:
pop ebx
pop eax
jmp shook1
 
overlapping_of_points:
push ecx edi
mov ecx,eax
mov edx,ebx
xor eax,eax
mov al,cl
xor ebx,ebx
mov bl,dl
add eax,ebx
rcr eax,1
xor edi,edi
mov di,ax
xor eax,eax
mov al,ch
xor ebx,ebx
mov bl,dh
add eax,ebx
rcr eax,1
ror edi,8
add edi,eax
ror ecx,8
ror edx,8
xor eax,eax
mov al,ch
xor ebx,ebx
mov bl,dh
add eax,ebx
rcr eax,1
ror edi,8
add eax,edi
ror eax,16
pop edi ecx
ret
 
   snbgp:
     add  ebp,3                     ; +3
     cmp [ScreenBPP],byte 24        ; 24 or 32 bpp ? - x size
     jz  @f
     inc ebp ; +1
   @@:
 
   shook1:
 
     inc edi                       ; ptrBuffer++
     add esi,3                     ; ptrImage+=3
     inc eax
     cmp eax,[draw_data+32+RECT.right]         ; X > xend?
     jle sdp3
 
     mov ebp,[draw_data+32+RECT.left]
 
     inc ebx
 
     mov  eax,[BytesPerScanLine]
     mul  ebx
     xchg ebp, eax                 ; BytesPerScanLine*(Ywin+y)
     add  ebp, eax                 ; +X
     add  ebp, eax                 ; +X=X*2
     add  ebp, eax                 ; +X=X*3
     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
 
     call calculate_edi
 
     cmp ebx,[draw_data+32+RECT.bottom]
     jle sdp3
 
     add esp,4
 
     pop edx
     pop ecx
     pop ebx
     pop eax
     pop ebp
     mov     [EGA_counter],1
     call  VGA_drawbackground
     ret

Rev 389	Rev 425
-		1	$Revision: 425 $
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	3	;; ;;
3	;; VESA20.INC ;;	4	;; VESA20.INC ;;
4	;; ;;	5	;; ;;
5	;; Vesa 2.0 functions for MenuetOS ;;	6	;; Vesa 2.0 functions for MenuetOS ;;
6	;; ;;	7	;; ;;
7	;; Copyright 2002 Ville Turjanmaa ;;	8	;; Copyright 2002 Ville Turjanmaa ;;
8	;; Alexey, kgaz@crosswindws.net ;;	9	;; Alexey, kgaz@crosswindws.net ;;
9	;; - Voodoo compatible graphics ;;	10	;; - Voodoo compatible graphics ;;
10	;; Juan M. Caravaca ;;	11	;; Juan M. Caravaca ;;
11	;; - Graphics optimimizations eg. drawline ;;	12	;; - Graphics optimimizations eg. drawline ;;
12	;; ;;	13	;; ;;
13	;; See file COPYING for details ;;	14	;; See file COPYING for details ;;
14	;; ;;	15	;; ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	16	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		17
17	; If you're planning to write your own video driver I suggest	18	; If you're planning to write your own video driver I suggest
18	; you replace the VESA12.INC file and see those instructions.	19	; you replace the VESA12.INC file and see those instructions.
19		20
20	;ScreenWidth equ 0xfe00	21	;ScreenWidth equ 0xfe00
21	;ScreenHeight equ 0xfe04	22	;ScreenHeight equ 0xfe04
22	;BytesPerScanLine equ 0xfe08	23	;BytesPerScanLine equ 0xfe08
23	;LFBAddress equ 0xfe80	24	;LFBAddress equ 0xfe80
24	;ScreenBPP equ 0xfbf1	25	;ScreenBPP equ 0xfbf1
25	;WinMapAddress equ 0x460000	26	;WinMapAddress equ 0x460000
26		27
27		28
28		29
29	;*************************************************	30	;*************************************************
30	; getpixel	31	; getpixel
31	;	32	;
32	; in:	33	; in:
33	; eax = x coordinate	34	; eax = x coordinate
34	; ebx = y coordinate	35	; ebx = y coordinate
35	;	36	;
36	; ret:	37	; ret:
37	; ecx = 00 RR GG BB	38	; ecx = 00 RR GG BB
38		39
39	getpixel:	40	getpixel:
40	push eax ebx edx edi	41	push eax ebx edx edi
41	call dword [GETPIXEL]	42	call dword [GETPIXEL]
42	pop edi edx ebx eax	43	pop edi edx ebx eax
43	ret	44	ret
44		45
45	Vesa20_getpixel24:	46	Vesa20_getpixel24:
46	; eax = x	47	; eax = x
47	; ebx = y	48	; ebx = y
48	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	49	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
49	lea edi, [eax+eax2] ; edi = x3	50	lea edi, [eax+eax2] ; edi = x3
50	add edi, ebx ; edi = x3+(yy multiplier)	51	add edi, ebx ; edi = x3+(yy multiplier)
51	add edi, [LFBAddress] ; ebx = where pixel is in memory	52	add edi, [LFBAddress] ; ebx = where pixel is in memory
52	mov ecx, [edi]	53	mov ecx, [edi]
53	and ecx, 0xffffff	54	and ecx, 0xffffff
54	ret	55	ret
55		56
56		57
57	Vesa20_getpixel32:	58	Vesa20_getpixel32:
58	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	59	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
59	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)	60	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
60	add edi, [LFBAddress] ; ebx = where pixel is in memory	61	add edi, [LFBAddress] ; ebx = where pixel is in memory
61	mov ecx, [edi]	62	mov ecx, [edi]
62	and ecx, 0xffffff	63	and ecx, 0xffffff
63	ret	64	ret
64		65
65	;*************************************************	66	;*************************************************
66		67
67	virtual at esp	68	virtual at esp
68	putimg:	69	putimg:
69	.real_sx dd ?	70	.real_sx dd ?
70	.real_sy dd ?	71	.real_sy dd ?
71	.image_sx dd ?	72	.image_sx dd ?
72	.image_sy dd ?	73	.image_sy dd ?
73	.image_cx dd ?	74	.image_cx dd ?
74	.image_cy dd ?	75	.image_cy dd ?
75	.pti dd ?	76	.pti dd ?
76	.abs_cx dd ?	77	.abs_cx dd ?
77	.abs_cy dd ?	78	.abs_cy dd ?
78	.line_increment dd ?	79	.line_increment dd ?
79	.winmap_newline dd ?	80	.winmap_newline dd ?
80	.screen_newline dd ?	81	.screen_newline dd ?
81	.stack_data = 4*12	82	.stack_data = 4*12
82	.edi dd ?	83	.edi dd ?
83	.esi dd ?	84	.esi dd ?
84	.ebp dd ?	85	.ebp dd ?
85	.esp dd ?	86	.esp dd ?
86	.ebx dd ?	87	.ebx dd ?
87	.edx dd ?	88	.edx dd ?
88	.ecx dd ?	89	.ecx dd ?
89	.eax dd ?	90	.eax dd ?
90	.ret_addr dd ?	91	.ret_addr dd ?
91	.arg_0 dd ?	92	.arg_0 dd ?
92	end virtual	93	end virtual
93		94
94	align 16	95	align 16
95	; ebx = pointer	96	; ebx = pointer
96	; ecx = size [x\|y]	97	; ecx = size [x\|y]
97	; edx = coordinates [x\|y]	98	; edx = coordinates [x\|y]
98	; ebp = pointer to 'get' function	99	; ebp = pointer to 'get' function
99	; esi = pointer to 'init' function	100	; esi = pointer to 'init' function
100	; edi = parameter for 'get' function	101	; edi = parameter for 'get' function
101	vesa20_putimage:	102	vesa20_putimage:
102	pushad	103	pushad
103	call [disable_mouse]	104	call [disable_mouse]
104		105
105	sub esp, putimg.stack_data	106	sub esp, putimg.stack_data
106		107
107	; save pointer to image	108	; save pointer to image
108	mov [putimg.pti], ebx	109	mov [putimg.pti], ebx
109		110
110	; unpack the size	111	; unpack the size
111	mov eax, ecx	112	mov eax, ecx
112	and ecx, 0xFFFF	113	and ecx, 0xFFFF
113	shr eax, 16	114	shr eax, 16
114	mov [putimg.image_sx], eax	115	mov [putimg.image_sx], eax
115	mov [putimg.image_sy], ecx	116	mov [putimg.image_sy], ecx
116		117
117	; unpack the coordinates	118	; unpack the coordinates
118	mov eax, edx	119	mov eax, edx
119	and edx, 0xFFFF	120	and edx, 0xFFFF
120	shr eax, 16	121	shr eax, 16
121	mov [putimg.image_cx], eax	122	mov [putimg.image_cx], eax
122	mov [putimg.image_cy], edx	123	mov [putimg.image_cy], edx
123		124
124	; calculate absolute (i.e. screen) coordinates	125	; calculate absolute (i.e. screen) coordinates
125	mov eax, [TASK_BASE]	126	mov eax, [TASK_BASE]
126	mov ebx, [eax-twdw + WDATA.box.left]	127	mov ebx, [eax-twdw + WDATA.box.left]
127	add ebx, [putimg.image_cx]	128	add ebx, [putimg.image_cx]
128	mov [putimg.abs_cx], ebx	129	mov [putimg.abs_cx], ebx
129	mov ebx, [eax-twdw + WDATA.box.top]	130	mov ebx, [eax-twdw + WDATA.box.top]
130	add ebx, [putimg.image_cy]	131	add ebx, [putimg.image_cy]
131	mov [putimg.abs_cy], ebx	132	mov [putimg.abs_cy], ebx
132		133
133	; real_sx = MIN(wnd_sx-image_cx, image_sx);	134	; real_sx = MIN(wnd_sx-image_cx, image_sx);
134	mov ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx	135	mov ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx
135	; \begin{diamond}[20.08.2006]	136	; \begin{diamond}[20.08.2006]
136	; note that WDATA.box.width is one pixel less than real window x-size	137	; note that WDATA.box.width is one pixel less than real window x-size
137	inc ebx	138	inc ebx
138	; \end{diamond}[20.08.2006]	139	; \end{diamond}[20.08.2006]
139	sub ebx, [putimg.image_cx]	140	sub ebx, [putimg.image_cx]
140	ja @f	141	ja @f
141	add esp, putimg.stack_data	142	add esp, putimg.stack_data
142	popad	143	popad
143	ret	144	ret
144	@@:	145	@@:
145	cmp ebx, [putimg.image_sx]	146	cmp ebx, [putimg.image_sx]
146	jbe .end_x	147	jbe .end_x
147	mov ebx, [putimg.image_sx]	148	mov ebx, [putimg.image_sx]
148	.end_x:	149	.end_x:
149	mov [putimg.real_sx], ebx	150	mov [putimg.real_sx], ebx
150		151
151	; init real_sy	152	; init real_sy
152	mov ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy	153	mov ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy
153	; \begin{diamond}[20.08.2006]	154	; \begin{diamond}[20.08.2006]
154	inc ebx	155	inc ebx
155	; \end{diamond}[20.08.2006]	156	; \end{diamond}[20.08.2006]
156	sub ebx, [putimg.image_cy]	157	sub ebx, [putimg.image_cy]
157	ja @f	158	ja @f
158	add esp, putimg.stack_data	159	add esp, putimg.stack_data
159	popad	160	popad
160	ret	161	ret
161	@@:	162	@@:
162	cmp ebx, [putimg.image_sy]	163	cmp ebx, [putimg.image_sy]
163	jbe .end_y	164	jbe .end_y
164	mov ebx, [putimg.image_sy]	165	mov ebx, [putimg.image_sy]
165	.end_y:	166	.end_y:
166	mov [putimg.real_sy], ebx	167	mov [putimg.real_sy], ebx
167		168
168	; line increment	169	; line increment
169	mov eax, [putimg.image_sx]	170	mov eax, [putimg.image_sx]
170	sub eax, [putimg.real_sx]	171	sub eax, [putimg.real_sx]
171	;; imul eax, [putimg.source_bpp]	172	;; imul eax, [putimg.source_bpp]
172	; lea eax, [eax + eax * 2]	173	; lea eax, [eax + eax * 2]
173	call esi	174	call esi
174	add eax, [putimg.arg_0]	175	add eax, [putimg.arg_0]
175	mov [putimg.line_increment], eax	176	mov [putimg.line_increment], eax
176		177
177	; winmap new line increment	178	; winmap new line increment
178	mov eax, [ScreenWidth]	179	mov eax, [ScreenWidth]
179	inc eax	180	inc eax
180	sub eax, [putimg.real_sx]	181	sub eax, [putimg.real_sx]
181	mov [putimg.winmap_newline], eax	182	mov [putimg.winmap_newline], eax
182		183
183	; screen new line increment	184	; screen new line increment
184	mov eax, [BytesPerScanLine]	185	mov eax, [BytesPerScanLine]
185	mov ecx, [putimg.real_sx]	186	mov ecx, [putimg.real_sx]
186	movzx ebx, byte [ScreenBPP]	187	movzx ebx, byte [ScreenBPP]
187	shr ebx, 3	188	shr ebx, 3
188	imul ecx, ebx	189	imul ecx, ebx
189	sub eax, ecx	190	sub eax, ecx
190	mov [putimg.screen_newline], eax	191	mov [putimg.screen_newline], eax
191		192
192	; pointer to image	193	; pointer to image
193	mov esi, [putimg.pti]	194	mov esi, [putimg.pti]
194		195
195	; pointer to screen	196	; pointer to screen
196	mov edx, [putimg.abs_cy]	197	mov edx, [putimg.abs_cy]
197	imul edx, [BytesPerScanLine]	198	imul edx, [BytesPerScanLine]
198	mov eax, [putimg.abs_cx]	199	mov eax, [putimg.abs_cx]
199	movzx ebx, byte [ScreenBPP]	200	movzx ebx, byte [ScreenBPP]
200	shr ebx, 3	201	shr ebx, 3
201	imul eax, ebx	202	imul eax, ebx
202	add edx, eax	203	add edx, eax
203	add edx, [LFBAddress]	204	add edx, [LFBAddress]
204		205
205	; pointer to pixel map	206	; pointer to pixel map
206	mov eax, [putimg.abs_cy]	207	mov eax, [putimg.abs_cy]
207	imul eax, [ScreenWidth]	208	imul eax, [ScreenWidth]
208	add eax, [putimg.abs_cy]	209	add eax, [putimg.abs_cy]
209	add eax, [putimg.abs_cx]	210	add eax, [putimg.abs_cx]
210	add eax, WinMapAddress	211	add eax, WinMapAddress
211	xchg eax, ebp	212	xchg eax, ebp
212		213
213	; get process number	214	; get process number
214	mov ebx, [CURRENT_TASK]	215	mov ebx, [CURRENT_TASK]
215		216
216	cmp byte [ScreenBPP], 32	217	cmp byte [ScreenBPP], 32
217	je put_image_end_32	218	je put_image_end_32
218		219
219	;put_image_end_24:	220	;put_image_end_24:
220	mov edi, [putimg.real_sy]	221	mov edi, [putimg.real_sy]
221	align 4	222	align 4
222	.new_line:	223	.new_line:
223	mov ecx, [putimg.real_sx]	224	mov ecx, [putimg.real_sx]
224		225
225	; push ebp edx	226	; push ebp edx
226	align 4	227	align 4
227	.new_x:	228	.new_x:
228		229
229	push [putimg.edi]	230	push [putimg.edi]
230	mov eax, [putimg.ebp+4]	231	mov eax, [putimg.ebp+4]
231	call eax	232	call eax
232	cmp [ebp], bl	233	cmp [ebp], bl
233	jne .skip	234	jne .skip
234	; mov eax, [esi] ; eax = RRBBGGRR	235	; mov eax, [esi] ; eax = RRBBGGRR
235	mov [edx], ax	236	mov [edx], ax
236	shr eax, 16	237	shr eax, 16
237	mov [edx+2], al	238	mov [edx+2], al
238	.skip:	239	.skip:
239		240
240	; add esi, 3 ;[putimg.source_bpp]	241	; add esi, 3 ;[putimg.source_bpp]
241	add edx, 3	242	add edx, 3
242	inc ebp	243	inc ebp
243		244
244	dec ecx	245	dec ecx
245	jnz .new_x	246	jnz .new_x
246	; pop edx ebp	247	; pop edx ebp
247		248
248	add esi, [putimg.line_increment]	249	add esi, [putimg.line_increment]
249	add edx, [putimg.screen_newline] ;[BytesPerScanLine]	250	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
250	add ebp, [putimg.winmap_newline] ;[ScreenWidth]	251	add ebp, [putimg.winmap_newline] ;[ScreenWidth]
251	;inc ebp	252	;inc ebp
252		253
253	dec edi	254	dec edi
254	jnz .new_line	255	jnz .new_line
255	.finish:	256	.finish:
256	add esp, putimg.stack_data	257	add esp, putimg.stack_data
257	popad	258	popad
258	ret	259	ret
259		260
260	put_image_end_32:	261	put_image_end_32:
261	mov edi, [putimg.real_sy]	262	mov edi, [putimg.real_sy]
262	align 4	263	align 4
263	.new_line:	264	.new_line:
264	mov ecx, [putimg.real_sx]	265	mov ecx, [putimg.real_sx]
265		266
266	; push ebp edx	267	; push ebp edx
267	align 4	268	align 4
268	.new_x:	269	.new_x:
269		270
270	push [putimg.edi]	271	push [putimg.edi]
271	mov eax, [putimg.ebp+4]	272	mov eax, [putimg.ebp+4]
272	call eax	273	call eax
273	cmp [ebp], bl	274	cmp [ebp], bl
274	jne .skip	275	jne .skip
275	; mov eax, [esi] ; ecx = RRBBGGRR	276	; mov eax, [esi] ; ecx = RRBBGGRR
276	mov [edx], eax	277	mov [edx], eax
277	.skip:	278	.skip:
278		279
279	; add esi, [putimg.source_bpp]	280	; add esi, [putimg.source_bpp]
280	add edx, 4	281	add edx, 4
281	inc ebp	282	inc ebp
282		283
283	dec ecx	284	dec ecx
284	jnz .new_x	285	jnz .new_x
285	; pop edx ebp	286	; pop edx ebp
286		287
287	add esi, [putimg.line_increment]	288	add esi, [putimg.line_increment]
288	add edx, [putimg.screen_newline] ;[BytesPerScanLine]	289	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
289	add ebp, [putimg.winmap_newline] ;[ScreenWidth]	290	add ebp, [putimg.winmap_newline] ;[ScreenWidth]
290	;inc ebp	291	;inc ebp
291		292
292	dec edi	293	dec edi
293	jnz .new_line	294	jnz .new_line
294	.finish:	295	.finish:
295	add esp, putimg.stack_data	296	add esp, putimg.stack_data
296	popad	297	popad
297	call VGA__putimage	298	call VGA__putimage
298	mov [EGA_counter],1	299	mov [EGA_counter],1
299	ret	300	ret
300		301
301		302
302	;*************************************************	303	;*************************************************
303	align 4	304	align 4
304	__sys_putpixel:	305	__sys_putpixel:
305		306
306	; eax = x coordinate	307	; eax = x coordinate
307	; ebx = y coordinate	308	; ebx = y coordinate
308	; ecx = ?? RR GG BB ; 0x01000000 negation	309	; ecx = ?? RR GG BB ; 0x01000000 negation
309	; edi = 0x00000001 force	310	; edi = 0x00000001 force
310		311
311	;;; mov [novesachecksum], dword 0	312	;;; mov [novesachecksum], dword 0
312		313
313	pushad	314	pushad
314	test edi,1 ; force ?	315	test edi,1 ; force ?
315	jnz .forced	316	jnz .forced
316	; not forced:	317	; not forced:
317	push ecx ; save 24th bit in case negative pixel wanted	318	push ecx ; save 24th bit in case negative pixel wanted
318	call checkpixel	319	call checkpixel
319	test ecx,ecx	320	test ecx,ecx
320	pop ecx	321	pop ecx
321	jnz .exit	322	jnz .exit
322	.forced:	323	.forced:
323	cmp [ScreenWidth], eax	324	cmp [ScreenWidth], eax
324	jb .exit	325	jb .exit
325	cmp [ScreenHeight], ebx	326	cmp [ScreenHeight], ebx
326	jb .exit	327	jb .exit
327	.ok:	328	.ok:
328	; check if negation	329	; check if negation
329	test ecx,0x01000000	330	test ecx,0x01000000
330	jz .noneg	331	jz .noneg
331	call getpixel	332	call getpixel
332	not ecx	333	not ecx
333	mov [esp+32-8],ecx	334	mov [esp+32-8],ecx
334	.noneg:	335	.noneg:
335	; OK to set pixel	336	; OK to set pixel
336	call dword [PUTPIXEL] ; call the real put_pixel function	337	call dword [PUTPIXEL] ; call the real put_pixel function
337	.exit:	338	.exit:
338	popad	339	popad
339		340
340	ret	341	ret
341		342
342	align 4	343	align 4
343	Vesa20_putpixel24:	344	Vesa20_putpixel24:
344		345
345	; eax = x	346	; eax = x
346	; ebx = y	347	; ebx = y
347		348
348	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	349	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
349	lea edi, [eax+eax2] ; edi = x3	350	lea edi, [eax+eax2] ; edi = x3
350	mov eax, [esp+32-8+4]	351	mov eax, [esp+32-8+4]
351	add edi, [LFBAddress]	352	add edi, [LFBAddress]
352	add edi, ebx ; ebx = where to put pixel in memory	353	add edi, ebx ; ebx = where to put pixel in memory
353	mov [edi], ax	354	mov [edi], ax
354	shr eax, 16	355	shr eax, 16
355	mov [edi+2], al	356	mov [edi+2], al
356		357
357	ret	358	ret
358		359
359		360
360	align 4	361	align 4
361	Vesa20_putpixel32:	362	Vesa20_putpixel32:
362		363
363	; eax = x	364	; eax = x
364	; ebx = y	365	; ebx = y
365		366
366	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier	367	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
367	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)	368	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
368	mov eax, [esp+32-8+4] ; eax = color	369	mov eax, [esp+32-8+4] ; eax = color
369	add edi, [LFBAddress] ; ebx = where to put pixel in memory	370	add edi, [LFBAddress] ; ebx = where to put pixel in memory
370	mov [edi], eax	371	mov [edi], eax
371		372
372	ret	373	ret
373		374
374		375
375	;*************************************************	376	;*************************************************
376		377
377	;align 4	378	;align 4
378	calculate_edi:	379	calculate_edi:
379	mov edi, ebx	380	mov edi, ebx
380	imul edi, [ScreenWidth]	381	imul edi, [ScreenWidth]
381	add edi, ebx	382	add edi, ebx
382	add edi, eax	383	add edi, eax
383	ret	384	ret
384		385
385	;*************************************************	386	;*************************************************
386		387
387	; DRAWLINE	388	; DRAWLINE
388		389
389	align 4	390	align 4
390	__sys_draw_line:	391	__sys_draw_line:
391	; inc [mouse_pause]	392	; inc [mouse_pause]
392	call [disable_mouse]	393	call [disable_mouse]
393		394
394	; draw a line	395	; draw a line
395	; eax = HIWORD = x1	396	; eax = HIWORD = x1
396	; LOWORD = x2	397	; LOWORD = x2
397	; ebx = HIWORD = y1	398	; ebx = HIWORD = y1
398	; LOWORD = y2	399	; LOWORD = y2
399	; ecx = color	400	; ecx = color
400	; edi = force ?	401	; edi = force ?
401	pusha	402	pusha
402		403
403	dl_x1 equ esp+20	404	dl_x1 equ esp+20
404	dl_y1 equ esp+16	405	dl_y1 equ esp+16
405	dl_x2 equ esp+12	406	dl_x2 equ esp+12
406	dl_y2 equ esp+8	407	dl_y2 equ esp+8
407	dl_dx equ esp+4	408	dl_dx equ esp+4
408	dl_dy equ esp+0	409	dl_dy equ esp+0
409		410
410	xor edx, edx ; clear edx	411	xor edx, edx ; clear edx
411	xor esi, esi ; unpack arguments	412	xor esi, esi ; unpack arguments
412	xor ebp, ebp	413	xor ebp, ebp
413	mov si, ax ; esi = x2	414	mov si, ax ; esi = x2
414	mov bp, bx ; ebp = y2	415	mov bp, bx ; ebp = y2
415	shr eax, 16 ; eax = x1	416	shr eax, 16 ; eax = x1
416	shr ebx, 16 ; ebx = y1	417	shr ebx, 16 ; ebx = y1
417		418
418	push eax ; save x1	419	push eax ; save x1
419	push ebx ; save y1	420	push ebx ; save y1
420	push esi ; save x2	421	push esi ; save x2
421	push ebp ; save y2	422	push ebp ; save y2
422		423
423	; checking x-axis...	424	; checking x-axis...
424	sub esi, eax ; esi = x2-x1	425	sub esi, eax ; esi = x2-x1
425	push esi ; save y2-y1	426	push esi ; save y2-y1
426	jl .x2lx1 ; is x2 less than x1 ?	427	jl .x2lx1 ; is x2 less than x1 ?
427	jg .no_vline ; x1 > x2 ?	428	jg .no_vline ; x1 > x2 ?
428	mov edx, ebp ; else (if x1=x2)	429	mov edx, ebp ; else (if x1=x2)
429	call vline	430	call vline
430	push edx ; necessary to rightly restore stack frame at .exit	431	push edx ; necessary to rightly restore stack frame at .exit
431	jmp .exit	432	jmp .exit
432	.x2lx1:	433	.x2lx1:
433	neg esi ; get esi absolute value	434	neg esi ; get esi absolute value
434	.no_vline:	435	.no_vline:
435		436
436	; checking y-axis...	437	; checking y-axis...
437	sub ebp, ebx ; ebp = y2-y1	438	sub ebp, ebx ; ebp = y2-y1
438	push ebp ; save y2-y1	439	push ebp ; save y2-y1
439	jl .y2ly1 ; is y2 less than y1 ?	440	jl .y2ly1 ; is y2 less than y1 ?
440	jg .no_hline ; y1 > y2 ?	441	jg .no_hline ; y1 > y2 ?
441	mov edx, [dl_x2] ; else (if y1=y2)	442	mov edx, [dl_x2] ; else (if y1=y2)
442	call hline	443	call hline
443	jmp .exit	444	jmp .exit
444	.y2ly1:	445	.y2ly1:
445	neg ebp ; get ebp absolute value	446	neg ebp ; get ebp absolute value
446	.no_hline:	447	.no_hline:
447		448
448		449
449	cmp ebp, esi	450	cmp ebp, esi
450	jle .x_rules ; \|y2-y1\| < \|x2-x1\| ?	451	jle .x_rules ; \|y2-y1\| < \|x2-x1\| ?
451		452
452	cmp [dl_y2], ebx ; make sure y1 is at the begining	453	cmp [dl_y2], ebx ; make sure y1 is at the begining
453	jge .no_reverse1	454	jge .no_reverse1
454		455
455	neg dword [dl_dx]	456	neg dword [dl_dx]
456	mov edx, [dl_x2]	457	mov edx, [dl_x2]
457	mov [dl_x2], eax	458	mov [dl_x2], eax
458	mov [dl_x1], edx	459	mov [dl_x1], edx
459	mov edx, [dl_y2]	460	mov edx, [dl_y2]
460	mov [dl_y2], ebx	461	mov [dl_y2], ebx
461	mov [dl_y1], edx	462	mov [dl_y1], edx
462		463
463	.no_reverse1:	464	.no_reverse1:
464		465
465	mov eax, [dl_dx]	466	mov eax, [dl_dx]
466	cdq ; extend eax sing to edx	467	cdq ; extend eax sing to edx
467	shl eax, 16 ; using 16bit fix-point maths	468	shl eax, 16 ; using 16bit fix-point maths
468	idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)	469	idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)
469	mov edx, ebp ; edx = counter (number of pixels to draw)	470	mov edx, ebp ; edx = counter (number of pixels to draw)
470	mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0	471	mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0
471	mov esi, eax ; esi = dx	472	mov esi, eax ; esi = dx
472		473
473	jmp .y_rules	474	jmp .y_rules
474	.x_rules:	475	.x_rules:
475		476
476	cmp [dl_x2], eax ; make sure x1 is at the begining	477	cmp [dl_x2], eax ; make sure x1 is at the begining
477	jge .no_reverse2	478	jge .no_reverse2
478		479
479	neg dword [dl_dy]	480	neg dword [dl_dy]
480	mov edx, [dl_x2]	481	mov edx, [dl_x2]
481	mov [dl_x2], eax	482	mov [dl_x2], eax
482	mov [dl_x1], edx	483	mov [dl_x1], edx
483	mov edx, [dl_y2]	484	mov edx, [dl_y2]
484	mov [dl_y2], ebx	485	mov [dl_y2], ebx
485	mov [dl_y1], edx	486	mov [dl_y1], edx
486		487
487	.no_reverse2:	488	.no_reverse2:
488		489
489	xor edx, edx	490	xor edx, edx
490	mov eax, [dl_dy]	491	mov eax, [dl_dy]
491	cdq ; extend eax sing to edx	492	cdq ; extend eax sing to edx
492	shl eax, 16 ; using 16bit fix-point maths	493	shl eax, 16 ; using 16bit fix-point maths
493	idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)	494	idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)
494	mov edx, esi ; edx = counter (number of pixels to draw)	495	mov edx, esi ; edx = counter (number of pixels to draw)
495	mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0	496	mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0
496	mov ebp, eax ; ebp = dy	497	mov ebp, eax ; ebp = dy
497		498
498	.y_rules:	499	.y_rules:
499		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/vesa20.inc – Rev 389 → 425