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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/vesa20.inc – Rev 283 → 314