Subversion Repositories Kolibri OS

Rev

Rev 9715 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2011-2022. All rights reserved. ;;
  4. ;; Distributed under terms of the GNU General Public License    ;;
  5. ;;                                                              ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. $Revision: 9926 $
  9.  
  10.  
  11. struct  BLITTER_BLOCK
  12.         xmin            dd ?
  13.         ymin            dd ?
  14.         xmax            dd ?
  15.         ymax            dd ?
  16. ends
  17.  
  18.  
  19. struct  BLITTER
  20.         dc              RECT
  21.         sc              RECT
  22.         dst_x           dd ?            ;  32
  23.         dst_y           dd ?            ;  36
  24.         src_x           dd ?            ;  40
  25.         src_y           dd ?            ;  44
  26.         w               dd ?            ;  48
  27.         h               dd ?            ;  52
  28.  
  29.         bitmap          dd ?            ;  56
  30.         stride          dd ?            ;  60
  31. ends
  32.  
  33.  
  34.  
  35. align 4
  36. block_clip:
  37. ;esi= clip RECT ptr
  38. ;edi= RECT ptr
  39. ;return code:
  40. ;CF= 0 - draw, 1 - don't draw
  41.  
  42.         push    ebx
  43.  
  44.         mov     eax, [edi + RECT.left]
  45.         mov     ebx, [edi + RECT.right]
  46.         mov     ecx, [esi + RECT.left]    ;clip.left
  47.         mov     edx, [esi + RECT.right]   ;clip.right
  48.  
  49.         cmp     eax, edx                ;left >= clip.right
  50.         jge     .fail
  51.  
  52.         cmp     ebx, ecx                ;right < clip.left
  53.         jl      .fail
  54.  
  55.         cmp     eax, ecx                ;left >= clip.left
  56.         jge     @F
  57.  
  58.         mov     [edi + RECT.left], ecx
  59. @@:
  60.         cmp     ebx, edx                ;right <= clip.right
  61.         jle     @f
  62.  
  63.         mov     [edi + RECT.right], edx
  64. @@:
  65.         mov     eax, [edi + RECT.top]
  66.         mov     ebx, [edi + RECT.bottom]
  67.         mov     ecx, [esi + RECT.top]     ;clip.top
  68.         mov     edx, [esi + RECT.bottom]  ;clip.bottom
  69.  
  70.         cmp     eax, edx                ;top >= clip.bottom
  71.         jge     .fail
  72.  
  73.         cmp     ebx, ecx                ;bottom < clip.top
  74.         jl      .fail
  75.  
  76.         cmp     eax, ecx                ;top >= clip.top
  77.         jge     @F
  78.  
  79.         mov     [edi + RECT.top], ecx
  80. @@:
  81.         cmp     ebx, edx                ;bottom <= clip.bottom
  82.         jle     @f
  83.  
  84.         mov     [edi + RECT.bottom], edx
  85. @@:
  86.         pop     ebx
  87.         clc
  88.         ret
  89. .fail:
  90.         pop     ebx
  91.         stc
  92.         ret
  93.  
  94.  
  95. align 4
  96. blit_clip:
  97.  
  98. ;return code:
  99. ;CF= 0 - draw, 1 - don't draw
  100.  
  101. .sx0   = 8
  102. .sy0   = 12
  103. .sx1   = 16
  104. .sy1   = 20
  105.  
  106. .dx0   = 24
  107. .dy0   = 28
  108. .dx1   = 32
  109. .dy1   = 36
  110.  
  111.  
  112.         push    edi
  113.         push    esi
  114.         push    ebx
  115.         sub     esp, 40
  116.  
  117.         mov     ebx, ecx
  118.         mov     edx, [ecx + BLITTER.src_x]
  119.         mov     [esp+.sx0], edx
  120.         mov     eax, [ecx + BLITTER.src_y]
  121.         mov     [esp+.sy0], eax
  122.         add     edx, [ecx + BLITTER.w]
  123.         add     eax, [ecx + BLITTER.h]
  124.         mov     [esp + .sx1], edx
  125.         mov     [esp + .sy1], eax
  126.  
  127.         lea     edi, [esp + .sx0]
  128.         lea     esi, [ebx + BLITTER.sc]
  129.  
  130.         call    block_clip
  131.         jc      .done
  132.  
  133.         mov     edi, [esp + .sx0]
  134.         mov     edx, [ebx + BLITTER.dst_x]
  135.         add     edx, edi
  136.         sub     edx, [ebx + BLITTER.src_x]
  137.         mov     [esp + .dx0], edx
  138.  
  139.         mov     ecx, [esp+.sy0]
  140.         mov     eax, [ebx + BLITTER.dst_y]
  141.         add     eax, ecx
  142.         sub     eax, [ebx + BLITTER.src_y]
  143.         mov     [esp + .dy0], eax
  144.  
  145.         sub     edx, edi
  146.         add     edx, [esp + .sx1]
  147.         mov     [esp + .dx1], edx
  148.  
  149.         sub     eax, ecx
  150.         add     eax, [esp + .sy1]
  151.         mov     [esp + .dy1], eax
  152.  
  153.         lea     edi, [esp + .dx0]
  154.         lea     esi, [ebx + BLITTER.dc]
  155.         call    block_clip
  156.         jc      .done
  157.  
  158.         mov     edx, [esp + .dx0]
  159.         mov     eax, [esp + .dx1]
  160.         sub     eax, edx
  161.         mov     [ebx + BLITTER.w], eax
  162.  
  163.         mov     eax, [esp + .dy0]
  164.         mov     ecx, [esp + .dy1]
  165.         sub     ecx, eax
  166.         mov     [ebx + BLITTER.h], ecx
  167.  
  168.         mov     ecx, [ebx + BLITTER.src_x]
  169.         add     ecx, edx
  170.         sub     ecx, [ebx + BLITTER.dst_x]
  171.         mov     [ebx + BLITTER.src_x], ecx
  172.  
  173.         mov     ecx, [ebx + BLITTER.src_y]
  174.         add     ecx, eax
  175.         sub     ecx, [ebx + BLITTER.dst_y]
  176.         mov     [ebx + BLITTER.src_y], ecx
  177.         mov     [ebx + BLITTER.dst_x], edx
  178.         mov     [ebx + BLITTER.dst_y], eax
  179.         clc
  180. .done:
  181.         add     esp, 40
  182.         pop     ebx
  183.         pop     esi
  184.         pop     edi
  185.  
  186.  
  187. purge .sx0
  188. purge .sy0
  189. purge .sx1
  190. purge .sy1
  191.  
  192. purge .dx0
  193. purge .dy0
  194. purge .dx1
  195. purge .dy1
  196.  
  197.         ret
  198.  
  199. align 4
  200. blit_32:
  201.         push    ebp
  202.         push    edi
  203.         push    esi
  204.         push    ebx
  205. virtual at sizeof.BLITTER
  206. .position       dd      ? ; (x shl 16) + y
  207. ; ???
  208. .extra_var1     dd      ?
  209. .flags          dd      ?
  210. .local_vars_size = $
  211. end virtual
  212.         sub     esp, .local_vars_size
  213.        
  214.         mov     [esp + .flags], ebx
  215.  
  216.         mov     eax, [current_slot_idx]
  217.         shl     eax, BSF sizeof.WDATA
  218.         mov     ebx, [window_data + eax + WDATA.box.width]
  219.         mov     edx, [window_data + eax + WDATA.box.height]
  220.         inc     ebx
  221.         inc     edx
  222.  
  223.         xor     eax, eax
  224.  
  225.         mov     [esp + BLITTER.dc.left], eax
  226.         mov     [esp + BLITTER.dc.top], eax
  227.         mov     [esp + BLITTER.dc.right], ebx
  228.         mov     [esp + BLITTER.dc.bottom], edx
  229.  
  230.         mov     [esp + BLITTER.sc.left], eax
  231.         mov     [esp + BLITTER.sc.top], eax
  232.         mov     eax, [ecx+24]
  233.  
  234.         mov     [esp + BLITTER.sc.right], eax
  235.         mov     eax, [ecx+28]
  236.  
  237.         mov     [esp + BLITTER.sc.bottom], eax
  238.  
  239.         mov     eax, [ecx]
  240.         mov     [esp + BLITTER.dst_x], eax
  241.         mov     eax, [ecx+4]
  242.         mov     [esp + BLITTER.dst_y], eax
  243.  
  244.         mov     eax, [ecx+16]
  245.         mov     [esp + BLITTER.src_x], eax
  246.         mov     eax, [ecx+20]
  247.         mov     [esp + BLITTER.src_y], eax
  248.         mov     eax, [ecx+8]
  249.         mov     [esp + BLITTER.w], eax
  250.         mov     eax, [ecx+12]
  251.         mov     [esp + BLITTER.h], eax
  252.  
  253.  
  254.         mov     eax, [ecx+32]
  255.         mov     [esp + BLITTER.bitmap], eax
  256.         mov     eax, [ecx+36]
  257.         mov     [esp + BLITTER.stride], eax
  258.  
  259.         mov     ecx, esp
  260.         call    blit_clip
  261.         jc      .L57
  262.  
  263.         mov     eax, [current_slot_idx]
  264.         shl     eax, BSF sizeof.WDATA
  265.  
  266.         mov     ebx, [esp + BLITTER.dst_x]
  267.         mov     ebp, [esp + BLITTER.dst_y]
  268.         add     ebx, [window_data + eax + WDATA.box.left]
  269.         add     ebp, [window_data + eax + WDATA.box.top]
  270.        
  271.         test    [esp + .flags], BLIT_CLIENT_RELATIVE
  272.         jz      .no_client_relative        
  273.  
  274.         add     ebx, [window_data + eax + WDATA.clientbox.left]
  275.         add     ebp, [window_data + eax + WDATA.clientbox.top]
  276. .no_client_relative:
  277.  
  278.         mov     ecx, ebx
  279.         add     ecx, [esp + BLITTER.w]
  280.         shl     ecx, 16
  281.         mov     cx, bp
  282.         add     ecx, [esp + BLITTER.h]
  283.  
  284.         mov     eax, ebx
  285.         shl     eax, 16
  286.         mov     ax, bp
  287.         mov     [esp + .position], eax
  288.  
  289.         mov     edi, ebp
  290.  
  291. ;        imul    edi, [_display.pitch]
  292.         mov     edi, [BPSLine_calc_area+edi*4]
  293. ;        imul    ebp, [_display.width]
  294.         mov     ebp, [d_width_calc_area+ebp*4]
  295.  
  296.         add     ebp, ebx
  297.         add     ebp, [_display.win_map]
  298.  
  299.         mov     eax, [esp + BLITTER.src_y]
  300.         imul    eax, [esp + BLITTER.stride]
  301.         mov     esi, [esp + BLITTER.src_x]
  302.         lea     esi, [eax + esi*4]
  303.         add     esi, [esp + BLITTER.bitmap]
  304.  
  305.         mov     eax, ecx
  306.         mov     ecx, [esp + BLITTER.h]
  307.         mov     edx, [esp + BLITTER.w]
  308.  
  309.         test    ecx, ecx    ;FIXME check clipping
  310.         jz      .L57
  311.  
  312.         test    edx, edx
  313.         jz      .L57
  314.  
  315.         cmp     [_display.bits_per_pixel], 32
  316.         jne     .core_24
  317.  
  318.         lea     edi, [edi + ebx*4]
  319.  
  320.         mov     ebx, [current_slot_idx]
  321. ; check for hardware cursor
  322.         cmp     [_display.select_cursor], select_cursor
  323.         je      .core_32.software_cursor
  324.         cmp     [_display.select_cursor], 0
  325.         jne     .core_32.hardware_cursor
  326. ;--------------------------------------
  327. .core_32.software_cursor:
  328. align 4
  329. .outer32:
  330.  
  331. align 4
  332. .inner32:
  333.         cmp     [ebp], bl
  334.         jne     .skip
  335. ;--------------------------------------
  336.         mov     eax, [esi]
  337.  
  338.         mov     ecx, [esp + .position]
  339.  
  340. ; check mouse area for putpixel
  341.         call    [_display.check_mouse]
  342. ;--------------------------------------
  343. ; store to real LFB
  344.         mov     [LFB_BASE + edi], eax
  345. ;--------------------------------------
  346. align 4
  347. .skip:
  348.         add     esi, 4
  349.         add     edi, 4
  350.         inc     ebp
  351.         add     [esp + .position], 1 shl 16
  352.         dec     edx
  353.         jnz     .inner32
  354.  
  355.         add     esi, [esp + BLITTER.stride]
  356.         add     edi, [_display.lfb_pitch]
  357.         add     ebp, [_display.width]
  358.  
  359.         mov     edx, [esp + BLITTER.w]
  360.         mov     eax, edx
  361.         inc     [esp+.position]
  362.         sub     ebp, edx
  363.         shl     eax, 2
  364.         sub     esi, eax
  365.         sub     edi, eax
  366.         shl     eax, 16-2
  367.         sub     [esp + .position], eax
  368.         dec     [esp + BLITTER.h]
  369.         jnz     .outer32
  370.         jmp     .done
  371. .core_32.hardware_cursor:
  372. align 4
  373. .hw.outer32:
  374.         xor     ecx, ecx
  375.  
  376. align 4
  377. .hw.inner32:
  378.         cmp     [ebp + ecx], bl
  379.         jne     .hw.skip
  380.         mov     eax, [esi + ecx*4]
  381.         mov     [LFB_BASE + edi + ecx*4], eax
  382.  
  383. align 4
  384. .hw.skip:
  385.         inc     ecx
  386.         dec     edx
  387.         jnz     .hw.inner32
  388.  
  389.         add     esi, [esp + BLITTER.stride]
  390.         add     edi, [_display.lfb_pitch]
  391.         add     ebp, [_display.width]
  392.  
  393.         mov     edx, [esp + BLITTER.w]
  394.         dec     [esp + BLITTER.h]
  395.         jnz     .hw.outer32
  396.  
  397. .done:
  398. ;        call    [draw_pointer]
  399. ;        call    __sys_draw_pointer
  400. .L57:
  401.         add     esp, .local_vars_size
  402.         pop     ebx
  403.         pop     esi
  404.         pop     edi
  405.         pop     ebp
  406.         ret
  407.  
  408. .core_24:
  409.         cmp     [_display.bits_per_pixel], 24
  410.         jne     .core_16
  411.  
  412.         lea     ebx, [ebx + ebx*2]
  413.         lea     edi, [LFB_BASE + edi + ebx]
  414.         mov     ebx, [current_slot_idx]
  415.  
  416. align 4
  417. .outer24:
  418.         mov     [esp + .extra_var1], edi
  419.         xor     ecx, ecx
  420.  
  421. align 4
  422. .inner24:
  423.         cmp     [ebp + ecx], bl           ; Does the process own this pixel?
  424.         jne     .skip_1
  425. ;--------------------------------------
  426.         push    eax
  427.         mov     eax, [esi + ecx*4]
  428.  
  429.         lea     edi, [edi + ecx*2]
  430.  
  431. ; check for hardware cursor
  432.         cmp     [_display.select_cursor], select_cursor
  433.         je      @f
  434.         cmp     [_display.select_cursor], 0
  435.         jne     .no_mouseunder_1
  436. ;--------------------------------------
  437. align 4
  438. @@:
  439.         push    ecx
  440.  
  441.         mov     ecx, [esp+4]
  442.         ror     ecx, 16
  443.         sub     ecx, edx
  444.         rol     ecx, 16
  445.         sub     ecx, [esp + BLITTER.h + 8]
  446.  
  447. ; check mouse area for putpixel
  448.         call    [_display.check_mouse]
  449.         pop     ecx
  450. ;--------------------------------------
  451. align 4
  452. .no_mouseunder_1:
  453.         mov     [edi + ecx], ax
  454.         shr     eax, 16
  455.         mov     [edi + ecx+2], al
  456.  
  457.         pop     eax
  458. ;--------------------------------------
  459. align 4
  460. .skip_1:
  461.         mov     edi, [esp + .extra_var1]
  462.         inc     ecx
  463.         dec     edx
  464.         jnz     .inner24
  465.  
  466.         add     esi, [esp + BLITTER.stride]
  467.         add     edi, [_display.lfb_pitch]
  468.         add     ebp, [_display.width]
  469.  
  470.         mov     edx, [esp + BLITTER.w]
  471.         dec     [esp + BLITTER.h]
  472.         jnz     .outer24
  473.  
  474.         jmp     .done
  475.  
  476.  
  477. .core_16:
  478.         lea     edi, [LFB_BASE + edi + ebx*2]
  479.         mov     ebx, [current_slot_idx]
  480.  
  481.   .outer16:
  482.         mov     [esp + .extra_var1], edi
  483.         xor     ecx, ecx
  484.  
  485.   .inner16:
  486.         cmp     [ebp + ecx], bl                   ; Does the process own this pixel?
  487.         jne     .skip_2
  488. ;--------------------------------------
  489.         push    eax
  490.         mov     eax, [esi + ecx*4]
  491.  
  492. ; check for hardware cursor
  493.         cmp     [_display.select_cursor], select_cursor
  494.         je      @f
  495.         cmp     [_display.select_cursor], 0
  496.         jne     .no_mouseunder_2
  497. ;--------------------------------------
  498.   @@:
  499.         push    ecx
  500.  
  501.         mov     ecx, [esp+4]
  502.         ror     ecx, 16
  503.         sub     ecx, edx
  504.         rol     ecx, 16
  505.         sub     ecx, [esp + BLITTER.h + 8]
  506.  
  507. ; check mouse area for putpixel
  508.         call    [_display.check_mouse]
  509.         pop     ecx
  510. ;--------------------------------------
  511.   .no_mouseunder_2:
  512. ; convert to 16 bpp and store to LFB
  513.         and     eax, 00000000111110001111110011111000b
  514.         shr     ah, 2
  515.         shr     ax, 3
  516.         ror     eax, 8
  517.         add     al, ah
  518.         rol     eax, 8
  519.         mov     [edi + ecx*2], ax
  520.         pop     eax
  521. ;--------------------------------------
  522.   .skip_2:
  523.         mov     edi, [esp + .extra_var1]
  524.         inc     ecx
  525.         dec     edx
  526.         jnz     .inner16
  527.  
  528.         add     esi, [esp + BLITTER.stride]
  529.         add     edi, [_display.lfb_pitch]
  530.         add     ebp, [_display.width]
  531.  
  532.         mov     edx, [esp + BLITTER.w]
  533.         dec     [esp + BLITTER.h]
  534.         jnz     .outer16
  535.  
  536.         jmp     .done
  537.  
  538.