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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                        ;;
;;  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 [0xe024]
        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 ?
   .source_bpp     dd ?
   .winmap_newline dd ?
   .screen_newline dd ?
   .stack_data = 4*13
end virtual
 
align 4
; ebx = pointer
; ecx = size [x|y]
; edx = coordinates [x|y]
vesa20_putimage:
        pushad
        call    [disable_mouse]
 
        sub     esp, putimg.stack_data
 
        mov     [putimg.source_bpp], 3
;        test    ebx, 0x80000000
;        jz      @f
;        inc     [putimg.source_bpp]
;      @@:
;        and     ebx, 0x7FFFFFFF
 
        ; 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, [0x3010]
        mov     ebx, [eax-twdw + 0]
        add     ebx, [putimg.image_cx]
        mov     [putimg.abs_cx], ebx
        mov     ebx, [eax-twdw + 4]
        add     ebx, [putimg.image_cy]
        mov     [putimg.abs_cy], ebx
 
        ; real_sx = MIN(wnd_sx-image_cx, image_sx);
        mov     ebx, [eax-twdw + 8] ; ebx = wnd_sx
        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]
        dec     ebx
      .end_x:
        inc     ebx
        mov     [putimg.real_sx], ebx
 
        ; init real_sy
        mov     ebx, [eax-twdw + 12] ; ebx = wnd_sy
        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]
        dec     ebx
      .end_y:
        inc     ebx
        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]
        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     ecx, [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     eax, [0x3010]
        mov     bl, [eax+0xE]
 
        cmp     byte [ScreenBPP], 32
        je      put_image_end_32
 
;put_image_end_24:
        ;cli ; !!!!!!!!!!!!!!!!!!!!!!
        mov     edi, [putimg.real_sy]
        align   4
      .new_line:
        mov     esi, [putimg.real_sx]
 
;        push    ebp edx
        align   4
          .new_x:
 
                cmp     [ebp], bl
                jne     .skip
                mov     eax, [ecx]        ; ecx = RRBBGGRR
                mov     [edx], ax
                shr     eax, 16
                mov     [edx+2], al
              .skip:
 
            add     ecx, 3 ;[putimg.source_bpp]
            add     edx, 3
            inc     ebp
 
            dec     esi
            jnz     .new_x
;        pop     edx ebp
 
        add     ecx, [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
 
        ;sti ; !!!!!!!!!!!!!!!!!!!!!
ret
 
put_image_end_32:
        mov     edi, [putimg.real_sy]
        align   4
      .new_line:
        mov     esi, [putimg.real_sx]
 
;        push    ebp edx
        align   4
          .new_x:
 
                cmp     [ebp], bl
                jne     .skip
                mov     eax, [ecx]        ; ecx = RRBBGGRR
                mov     [edx], eax
              .skip:
 
            add     ecx, [putimg.source_bpp]
            add     edx, 4
            inc     ebp
 
            dec     esi
            jnz     .new_x
;        pop     edx ebp
 
        add     ecx, [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
 
 
;*************************************************
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 [0xe020]        ; 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, [0x3010]
        add     eax, [edi-twdw + 0] ; win_cx
        add     ebx, [edi-twdw + 4] ; 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 + 8] ; ebx = wnd_sx
        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 + 12] ; ebx = wnd_sy
        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     eax, [0x3010]
        mov     bl, [eax+0xE]
 
        cmp     byte [ScreenBPP], 24
        jne     draw_bar_end_32
draw_bar_end_24:
        ;cli ; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        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
        ;sti ; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
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
        xor     eax, eax
 
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+0] ; x start:=(x+Xwin)
     mov ebx,[draw_data+32+4] ; 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+0x300000]
     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+8]         ; X > xend?
;     jg nodp3
;     jmp dp3
;
;   nodp3:
     jle dp3
 
     mov ebp,[draw_data+32+0]
 
     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+12]
;     jg  dp4
;
;     jmp dp3
;
;   dp4:
     jle dp3
 
     add esp,4
 
     pop edx
     pop ecx
     pop ebx
     pop eax
     pop ebp
 
     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+0] ; x start:=(x+Xwin)
     mov ebx,[draw_data+32+4] ; 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
     lea   esi,[eax+eax*2]
     mov   eax,dword [WinMapAddress-4]
     imul  eax, [esp+0]      ;0
     xor   edx,edx
     mov   ebx,[ScreenHeight]
     div   ebx
     imul  eax, [esp+8]      ;8
     add   esi,eax
 
     mov   eax,[esi+0x300000]
     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
 
   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+8]         ; X > xend?
     jle sdp3
 
     mov ebp,[draw_data+32+0]
 
     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+12]
     jle sdp3
 
     add esp,4
 
     pop edx
     pop ecx
     pop ebx
     pop eax
     pop ebp
 
     ret

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/vesa20.inc – Rev 52 → 75