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

 ;;                                                              ;;
 ;;  See file COPYING for details                                ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 1664 $
-; If you're planning to write your own video driver I suggest
-; you replace the VESA12.INC file and see those instructions.
-;Screen_Max_X             equ     0xfe00
-;Screen_Max_Y            equ     0xfe04
-;BytesPerScanLine        equ     0xfe08
-;LFBAddress              equ     0xfe80
-;ScreenBPP               equ     0xfbf1
 $Revision: 1707 $
 ; ebx = y coordinate
+;
 ; ret:
 ; ecx = 00 RR GG BB
-getpixel:
-     push    eax ebx edx edi
-     call    dword [GETPIXEL]
-     pop     edi edx ebx eax
-     ret
-Vesa20_getpixel24:
-; eax = x
-; ebx = y
-     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
-     lea     edi, [eax+eax*2] ; edi = x*3
-     add     edi, ebx         ; edi = x*3+(y*y multiplier)
-     mov     ecx, [LFB_BASE+edi]
-     and     ecx, 0xffffff
-     ret
+get_pixel:
-Vesa20_getpixel32:
+     mov     ecx, [BytesPerScanLine]
-     imul    ebx, [BytesPerScanLine]    ; ebx = y * y multiplier
+     imul    ecx, ebx
-     lea     edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
+     lea     ecx, [ecx+eax*4]		; ecx = x*4+(y*y multiplier)
-     mov     ecx, [LFB_BASE+edi]
+     mov     ecx, [ecx+LFB_BASE]
      and     ecx, 0xffffff
      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	; 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
      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
      mov     [putimg.real_sy], ebx
 ; line increment
      mov     eax, [putimg.image_sx]
      mov     ecx, [putimg.real_sx]
      sub     eax, ecx
-;;     imul    eax, [putimg.source_bpp]
-;     lea     eax, [eax + eax * 2]
      call    esi
      add     eax, [putimg.arg_0]
      mov     [putimg.line_increment], eax
 ; winmap new line increment
      mov     eax, [Screen_Max_X]
      inc     eax
      sub     eax, [putimg.real_sx]
      mov     [putimg.winmap_newline], eax
 ; screen new line increment
      mov     eax, [BytesPerScanLine]
-     movzx   ebx, byte [ScreenBPP]
-     shr     ebx, 3
+     shl     ecx, 1
-     imul    ecx, ebx
+     shl     ecx, 1
      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
+     shl     eax, 1
-     imul    eax, ebx
+     shl     eax, 1
      add     edx, eax
 ; pointer to pixel map
      mov     eax, [putimg.abs_cy]
      imul    eax, [Screen_Max_X]
      add     eax, [putimg.abs_cy]
      add     eax, [putimg.abs_cx]
      add     eax, [_WinMapAddress]
      xchg    eax, ebp
 ; get process number
      mov     ebx, [CURRENT_TASK]
-     cmp     byte [ScreenBPP], 32
-     je      put_image_end_32
-;put_image_end_24:
-     mov     edi, [putimg.real_sy]
-align   4
-.new_line:
-     mov     ecx, [putimg.real_sx]
-;     push    ebp edx
-align   4
-.new_x:
-     push    [putimg.edi]
-     mov     eax, [putimg.ebp+4]
-     call    eax
-     cmp     [ebp], bl
-     jne     .skip
-;     mov     eax, [esi]        ; eax = RRBBGGRR
-     mov     [LFB_BASE+edx], ax
-     shr     eax, 16
-     mov     [LFB_BASE+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] ;[Screen_Max_X]
-;     inc     ebp
-     cmp     [putimg.ebp], putimage_get1bpp
-     jz      .correct
-     cmp     [putimg.ebp], putimage_get2bpp
-     jz      .correct
-     cmp     [putimg.ebp], putimage_get4bpp
-     jnz     @f
-.correct:
-     mov     eax, [putimg.edi]
-     mov     byte [eax], 80h
-@@:
-     dec     edi
-     jnz     .new_line
-.finish:
-     add     esp, putimg.stack_data
-     popad
-     ret
 put_image_end_32:
      mov     edi, [putimg.real_sy]
-align   4
+align	4
 .new_line:
-     mov     ecx, [putimg.real_sx]
-;     push    ebp edx
+     mov     ecx, [putimg.real_sx]
-align   4
+align	4
 .new_x:
      push    [putimg.edi]
      mov     eax, [putimg.ebp+4]
      call    eax
      cmp     [ebp], bl
-     jne     .skip
-;     mov     eax, [esi]        ; ecx = RRBBGGRR
+     jne     .skip
      mov     [LFB_BASE+edx], eax
-.skip:
-;     add     esi, [putimg.source_bpp]
+.skip:
      add     edx, 4
      inc     ebp
      dec     ecx
-     jnz     .new_x
-;     pop     edx ebp
+     jnz     .new_x
      add     esi, [putimg.line_increment]
      add     edx, [putimg.screen_newline] ;[BytesPerScanLine]
-     add     ebp, [putimg.winmap_newline] ;[Screen_Max_X]
-;     inc     ebp
+     add     ebp, [putimg.winmap_newline] ;[Screen_Max_X]
      cmp     [putimg.ebp], putimage_get1bpp
      jz      .correct
      cmp     [putimg.ebp], putimage_get2bpp
      jz      .correct
      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
 ; ecx = ?? RR GG BB    ; 0x01000000 negation
-;;;        mov  [novesachecksum], dword 0
+; edi = 0x00000001 force
      pushad
      cmp   [Screen_Max_X], eax
+     jb    .exit
-     jb    .exit
+     cmp   [Screen_Max_Y], ebx
-     cmp   [Screen_Max_Y], ebx
+     jb    .exit
-     jb    .exit
-     test  edi,1                 ; force ?
+.check_forced:
-     jnz   .forced
+     test    edi,1		 ; force ?
      jnz     .checked
 ; not forced:
+.not_forced:
-     push eax
+     push     edx
-     mov  edx,[_display.width]     ; screen x size
+     mov      edx,[_display.width]	   ; screen x size
-     imul edx, ebx
+     imul     edx, ebx
-     add  eax, [_WinMapAddress]
+     add      edx, [_WinMapAddress]
+     movzx    edx, byte [eax+edx]
-     movzx  edx, byte [eax+edx]
+     cmp      edx, [CURRENT_TASK]
+     pop      edx
+     jne      .exit
-     cmp edx, [CURRENT_TASK]
-     pop eax
+; OK to set pixel
-     jne .exit
+.checked:
+     push  ebx
-.forced:
+     imul  ebx, [BytesPerScanLine]
-; check if negation
+     lea   ebx, [ebx+eax*4]
      test  ecx,0x01000000
      jz    .noneg
-     call  getpixel
+     mov   ecx, [LFB_BASE+ebx]
      not   ecx
-     mov   [esp+32-8],ecx
-.noneg:
+     and   ecx, 0x01FFFFFF
-; OK to set pixel
-     call  dword [PUTPIXEL]    ; call the real put_pixel function
-.exit:
-     popad
-     ret
-align 4
-Vesa20_putpixel24:
-; eax = x
-; ebx = y
-     imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
-     lea     edi, [eax+eax*2]  ; edi = x*3
+.noneg:
-     mov     eax, [esp+32-8+4]
+     mov   [LFB_BASE+ebx], ecx
-     mov     [LFB_BASE+ebx+edi], ax
+     pop   ebx
-     shr     eax, 16
+.exit:
-     mov     [LFB_BASE+ebx+edi+2], al
+     ret
      ret
 align 4
+put_pixel:	; left for compatibility with Vesa20_putpixel32
-Vesa20_putpixel32:
+; eax = x
-; eax = x
+; ebx = y
-; ebx = y
+     imul    ebx, [BytesPerScanLine]	 ; ebx = y * y multiplier
-     imul    ebx, [BytesPerScanLine]     ; ebx = y * y multiplier
+     lea     edi, [ebx+eax*4]  ; edi = x*4+(y*y multiplier)
      mov     ebx, [dl_y2]
      call    [putpixel]
 .exit:
      add     esp, 6*4
      popa
-;     dec   [mouse_pause]
      call   [draw_pointer]
      ret
 align 4
 hline:
-; draw an horizontal line
+; ------------  draw a horizontal line -------------
 ; eax = x1
 ; edx = x2
 ; ebx = y
 ; ecx = color
+; edi = force ?
+     cmp     ebx, [Screen_Max_Y]
+     jge     .out
+     push    eax ebp esi ebx edx
-; edi = force ?
+     mov     ebp, [_display.width]	; ebp = screen co-ords base
+     imul    ebp, ebx
+     add     ebp, [_WinMapAddress]
-     push    eax edx
-     cmp     edx, eax      ; make sure x2 is above x1
+     cmp     edx, eax		; to make sure x2 > x1
      jge     @f
-     xchg    eax, edx
-align   4
+     xchg    eax, edx
+@@:
+     cmp     eax, [Screen_Max_X]
+     jge     .exit
+     imul    ebx, [BytesPerScanLine]
+     add     ebx, LFB_BASE
+     cmp     edx, [Screen_Max_X]	; last check
+     jb      .draw
+     mov     edx, [Screen_Max_X]
+.draw:	; -- the line ---
+     test    edi,1			; forced  ?
+     jnz    .checked
+; check whether the line covered by other windows
+     movzx   esi, byte [ebp+eax]
-@@:
+     cmp     esi, [CURRENT_TASK]
+     jne     .nextpixel
+.checked:
+     test    ecx,0x01000000
+     jz     .noneg
+     mov     ecx, [ebx+eax*4]
+     not     ecx
+     and     ecx, 0x01FFFFFF	; keep bit[24] high !
+.noneg:
+     mov     [ebx+eax*4], ecx
-     call    [putpixel]
+.nextpixel:
      inc     eax
      cmp     eax, edx
+     jle     .draw
-     jle     @b
+.exit:
+     pop     edx ebx esi ebp eax
-     pop     edx eax
+.out:
      ret
+align 4
 vline:
-; draw a vertical line
+; ---------  draw a vertical line  ------------
 ; eax = x
 ; ebx = y1
 ; edx = y2
+; ecx = color
+; edi = force ?
+     cmp     eax, [Screen_Max_X]
+     jge     .out
+     push    eax ebp esi ebx edx
+     mov     ebp, [_display.width]	; ebp = screen co-ords base
-; ecx = color
+     imul    ebp, ebx
+     add     ebp, [_WinMapAddress]
-; edi = force ?
+     add     ebp, eax
      push    ebx edx
-     cmp     edx, ebx      ; make sure y2 is above y1
+     cmp     edx, ebx			; to make sure y2 > y1
-     jge     @f
-     xchg    ebx, edx
+     jge     @f
+     xchg    ebx, edx
+@@:
+     cmp     ebx, [Screen_Max_Y]
+     jge     .exit
+     push    ebx
+     imul    ebx, [BytesPerScanLine]
+     shl     eax, 1
+     shl     eax, 1
+     add     eax, ebx
+     add     eax, LFB_BASE
+     pop     ebx        		; restore ebx = y1
+     cmp     edx, [Screen_Max_Y]	; the last check
+     jb     .draw
+     mov     edx, [Screen_Max_Y]	; to prevent off-screen drawing
+.draw:	  ; (vertical line itself)
+     test    edi,1			; forced  ?
+     jnz    .checked
+; check whether the line covered by other windows
-align   4
+     movzx   esi, byte [ebp]
+     cmp     esi, [CURRENT_TASK]
+     jne     .nextpixel
+.checked:
+     test    ecx,0x01000000
+     jz     .noneg
+     mov     ecx, [eax]
+     not     ecx
+     and     ecx, 0x01FFFFFF		; keep bit[24] high !
+.noneg:
+     mov     [eax], ecx
+.nextpixel:
-@@:
+     add     eax, [BytesPerScanLine]
-     call    [putpixel]
+     add     ebp, [_display.width]
      inc     ebx
+     cmp     ebx, edx
-     cmp     ebx, edx
+     jle    .draw
+.exit:
-     jle     @b
+     pop     edx ebx esi ebp eax
-     pop     edx ebx
+.out:
      pushad
      call    [_display.disable_mouse]
      sub     esp, drbar.stack_data
      mov     [drbar.color], edi
      sub     edx, ebx
-     jle     .exit          ;// mike.dld, 2005-01-29
+     jle     .exit
      sub     ecx, eax
-     jle     .exit          ;// mike.dld, 2005-01-29
+     jle     .exit
      mov     [drbar.bar_sy], edx
      mov     [drbar.bar_sx], ecx
      mov     [drbar.bar_cx], eax
      mov     [drbar.bar_cy], ebx
      mov     edi, [TASK_BASE]
      add     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
+.exit:
      add     esp, drbar.stack_data
      popad
      xor     eax, eax
      inc     eax
      ret
      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
      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
+     shl     eax, 1
-     imul    eax, ebx
+     shl     eax, 1
      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
+     shl     eax, 1
-     imul    eax, ebx
+     shl     eax, 1
      add     edx, eax
 ; pointer to pixel map
      mov     eax, [drbar.abs_cy]
      imul    eax, [Screen_Max_X]
      add     eax, [drbar.abs_cy]
      add     eax, [drbar.abs_cx]
      add     eax, [_WinMapAddress]
      xchg    eax, ebp
 ; get process number
      mov     ebx, [CURRENT_TASK]
-     cmp     byte [ScreenBPP], 24
-     jne     draw_bar_end_32
-draw_bar_end_24:
+draw_bar_end_32:
-     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     [LFB_BASE+edx], bh
-     mov     [LFB_BASE+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
+align	4
 .new_y:
      mov     edi, [drbar.real_sx]
+;
      dec     esi
      jnz     .new_y
      add     esp, drbar.stack_data
      popad
+     xor     eax, eax
      ret
 align 4
 vesa20_drawbackground_tiled:
-        call    [_display.disable_mouse]
+	call	[_display.disable_mouse]
-        pushad
+	pushad
-        mul     ebx
+	mul	ebx
-        xchg    ebp, eax
+	xchg	ebp, eax
-        add     ebp, eax
+	add	ebp, eax
-        add     ebp, eax
+	add	ebp, eax
-        add     ebp, eax
+	add	ebp, eax
-        cmp     [ScreenBPP], byte 24    ; 24 or 32 bpp ? - x size
-        jz      @f
-        add     ebp, eax
+	add	ebp, eax
-@@:
-        add     ebp, LFB_BASE
+	add	ebp, LFB_BASE
 ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
-        call    calculate_edi
+	call	calculate_edi
-        xchg    edi, ebp
+	xchg	edi, ebp
-        add ebp, [_WinMapAddress]
+	add ebp, [_WinMapAddress]
-        jmp     @f
+	jmp	@f
 nbgp:
-        add     esi, 3
+	add	esi, 3
-        add     edi, 3
+	add	edi, 3
 @@:
-        cmp     [ScreenBPP], byte 25    ; 24 or 32 bpp?
-        sbb     edi, -1         ; +1 for 32 bpp
+	inc	edi   	 	; +1 for 32 bpp
-; I do not use 'inc eax' because this is slightly slower then 'add eax,1'
-        add     ebp, edx
+	add	ebp, edx
-        add     eax, edx
+	add	eax, edx
-        cmp     eax, [draw_data+32+RECT.right]
+	cmp	eax, [draw_data+32+RECT.right]
-        ja      dp4
+	ja	dp4
-        sub     ecx, edx
+	sub	ecx, edx
-        mul     ebx
+	mul	ebx
-        xchg    ebp, eax
+	xchg	ebp, eax
-        add     ebp, eax
+	add	ebp, eax
-        add     ebp, eax
+	add	ebp, eax
-        add     ebp, eax
+	add	ebp, eax
-        cmp     [ScreenBPP], byte 24    ; 24 or 32 bpp ? - x size
-        jz      @f
-        add     ebp, eax
+	add	ebp, eax
-@@:
 ; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
-        call    calculate_edi
+	call	calculate_edi
-        xchg    edi, ebp
+	xchg	edi, ebp
 ; Now eax=x, ebx=y, edi->output, ebp=offset in WinMapAddress
-        push    ebx
+	push	ebx
-        mov     [LFB_BASE+edi], ax
+	mov	[LFB_BASE+edi], ax
-        shr     eax, 16
+	shr	eax, 16
-        mov     [LFB_BASE+edi+2], al
+	mov	[LFB_BASE+edi+2], al
-snbgp:
-        cmp     [ScreenBPP], byte 25
+snbgp:
-        sbb     edi, -4
+	add	edi, 4
-        add     ebp, 1
+	inc	ebp
-        mov     eax, [esp+20]
+	mov	eax, [esp+20]
-        add     eax, 1
+	inc	eax
-        mov     [esp+20], eax
+	mov	[esp+20], eax
-        add     esi, 4
+	add	esi, 4
-        cmp     eax, [draw_data+32+RECT.right]
+	cmp	eax, [draw_data+32+RECT.right]
-        jbe     sdp3a
+	jbe	sdp3a
 sdp4:
 ; next y
-        mov     ebx, [esp+24]
+	mov	ebx, [esp+24]
-        add     ebx, 1
+	inc	ebx
-        mov     [esp+24], ebx
+	mov	[esp+24], ebx
-        cmp     ebx, [draw_data+32+RECT.bottom]
+	cmp	ebx, [draw_data+32+RECT.bottom]
-        ja      sdpdone
+	ja	sdpdone
 ; advance edi, ebp to next scan line
-        sub     eax, [draw_data+32+RECT.left]
+	sub	eax, [draw_data+32+RECT.left]
-        sub     ebp, eax
+	sub	ebp, eax
-        add     ebp, [Screen_Max_X]
+	add	ebp, [Screen_Max_X]
-        add     ebp, 1
+	inc	ebp
-        sub     edi, eax
+	sub	edi, eax
-        sub     edi, eax
+	sub	edi, eax
-        sub     edi, eax
-        cmp     [ScreenBPP], byte 24
-        jz      @f
+	sub	edi, eax
-        sub     edi, eax
-@@:
+	sub	edi, eax
-        add     edi, [BytesPerScanLine]
+	add	edi, [BytesPerScanLine]
 ; restore ecx,edx; advance esi to next background line
-        mov     eax, [esp+28]
+	mov	eax, [esp+28]
-        mov     ebx, [esp+32]
+	mov	ebx, [esp+32]
-        shr     ebx, 8
+	shr	ebx, 8
-        call    [overlapping_of_points_ptr]
+	call	[overlapping_of_points_ptr]
 @@:
-        stosd
+	stosd
-        mov     eax, [esp+20+8]
+	mov	eax, [esp+20+8]
-        add     eax, 1
+	inc	eax
-        mov     [esp+20+8], eax
+	mov	[esp+20+8], eax
-        cmp     eax, [draw_data+32+RECT.right]
+	cmp	eax, [draw_data+32+RECT.right]
-        ja      @f
+	ja	@f
-        add     ecx, [esp+36+8]
+	add	ecx, [esp+36+8]
-        mov     eax, edx
+	mov	eax, edx
-        mov     [esp+20+8], eax
+	mov	[esp+20+8], eax
-        ret
+	ret
 align 16
-overlapping_of_points:
-if 0
-; this version of procedure works, but is slower than next version
-        push    ecx edx
-        mov     edx, eax
-        push    esi
-        shr     ecx, 24
-        mov     esi, ecx
-        mov     ecx, ebx
-        movzx   ebx, dl
-        movzx   eax, cl
-        sub     eax, ebx
-        movzx   ebx, dh
-        imul    eax, esi
-        add     dl, ah
-        movzx   eax, ch
-        sub     eax, ebx
-        imul    eax, esi
-        add     dh, ah
-        ror     ecx, 16
-        ror     edx, 16
-        movzx   eax, cl
-        movzx   ebx, dl
-        sub     eax, ebx
-        imul    eax, esi
-        pop     esi
-        add     dl, ah
-        mov     eax, edx
-        pop     edx
-        ror     eax, 16
-        pop     ecx
-        ret
-else
+overlapping_of_points:
-        push    ecx edx
+	push	ecx edx
-        mov     edx, eax
+	mov	edx, eax
-        push    esi
+	push	esi
-        shr     ecx, 26
+	shr	ecx, 26
-        mov     eax, edx
+	mov	eax, edx
-        pop     edx
+	pop	edx
-        ror     eax, 16
+	ror	eax, 16
-        pop     ecx
+	pop	ecx
-        ret
+	ret
-end if
 iglobal
 align 4
-overlapping_of_points_ptr       dd      overlapping_of_points
+overlapping_of_points_ptr	dd	overlapping_of_points

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-A/trunk/video/vesa20.inc – Rev 1664 → 1707