/kernel/branches/Kolibri-A/trunk/const.inc |
---|
85,7 → 85,7 |
CAPS_SYSCAL equ 64 ; |
CAPS_XD equ 65 ;execution disable |
CAPS_FFXSR equ 66 ; |
CAPS_RDTSCP equ 67 ; |
CAPS_RDTSCP equ 67 ; not used anywhere |
CAPS_X64 equ 68 ; |
CAPS_3DNOW equ 69 ; |
CAPS_3DNOWEXT equ 70 ; |
197,7 → 197,7 |
mouseunder equ (OS_BASE+0x0006900) |
CDDataBuf equ (OS_BASE+0x0007000) |
FLOPPY_BUFF equ (OS_BASE+0x0008000) |
ACTIVE_PROC_STACK equ (OS_BASE+0x000A400) ;unused |
;ACTIVE_PROC_STACK equ (OS_BASE+0x000A400) ;unused |
idts equ (OS_BASE+0x000B100) |
WIN_STACK equ (OS_BASE+0x000C000) |
WIN_POS equ (OS_BASE+0x000C400) |
204,16 → 204,16 |
FDD_BUFF equ (OS_BASE+0x000D000) |
;unused ? only one reference |
ENABLE_TASKSWITCH equ (OS_BASE+0x000E000) |
;ENABLE_TASKSWITCH equ (OS_BASE+0x000E000) |
PUTPIXEL equ (OS_BASE+0x000E020) |
GETPIXEL equ (OS_BASE+0x000E024) |
;PUTPIXEL equ (OS_BASE+0x000E020) |
;GETPIXEL equ (OS_BASE+0x000E024) |
;unused ? only one reference |
BANK_SWITCH equ (OS_BASE+0x000E030) |
; BANK_SWITCH equ (OS_BASE+0x000E030) ; VESA 1.2 - not used |
;unused ? store mousepointer |
MOUSE_PICTURE equ (OS_BASE+0x000F200) |
;MOUSE_PICTURE equ (OS_BASE+0x000F200) ; mousedrv.inc - not used |
MOUSE_VISIBLE equ (OS_BASE+0x000F204) |
WIN_TEMP_XY equ (OS_BASE+0x000F300) |
/kernel/branches/Kolibri-A/trunk/data32.inc |
---|
413,9 → 413,9 |
;* end code - Mario79 |
img_background rd 1 |
mem_BACKGROUND rd 1 |
static_background_data rd 1 |
;img_background rd 1 |
;mem_BACKGROUND rd 1 |
;static_background_data rd 1 |
cache_ide0: |
cache_ide0_pointer rd 1 |
/kernel/branches/Kolibri-A/trunk/gui/font.inc |
---|
51,7 → 51,7 |
cmp byte [edx], 0 |
jz .end |
; // Alver 22.06.2008 // { |
cmp byte [esp+28], 1 |
cmp byte [esp+28], 1 ; was the entry point = dtext.1 ? |
jne @f |
dec esi |
js .end |
58,7 → 58,7 |
; } \\ Alver \\ |
@@: |
inc edx |
pushad |
pushad ; esp -= 64 ! |
movzx edx, byte [edx-1] |
test ecx, 0x10000000 |
jnz .font2 |
71,14 → 71,14 |
shr dl, 1 |
jz .pixloop1end |
jnc .nopix |
call [putpixel] |
call _putpixel |
jmp .pixloop1cont |
.nopix: |
test ecx, 0x40000000 |
jz .pixloop1cont |
push ecx |
mov ecx, [esp+4+20h+20h] |
call [putpixel] |
mov ecx, [esp+4+20h+20h] ; original eax? |
call _putpixel |
pop ecx |
.pixloop1cont: |
inc eax |
103,7 → 103,7 |
.pixloop2: |
shr dl, 1 |
jnc .nopix2 |
call [putpixel] |
call _putpixel |
jmp .pixloop2cont |
.nopix2: |
test ecx, 0x40000000 |
110,7 → 110,7 |
jz .pixloop2cont |
push ecx |
mov ecx, [esp+12+20h+20h] |
call [putpixel] |
call _putpixel |
pop ecx |
.pixloop2cont: |
inc eax |
/kernel/branches/Kolibri-A/trunk/gui/mouse.inc |
---|
518,11 → 518,13 |
;< esi = process slot |
;< edi = pointer to WDATA struct |
;------------------------------------------------------------------------------ |
mov esi, [Screen_Max_X] |
inc esi |
imul esi, [mouse.state.pos.y] |
add esi, [_WinMapAddress] |
add esi, [mouse.state.pos.x] |
mov esi, [mouse.state.pos.y] |
mov edi, [mouse.state.pos.x] |
shr esi, 1 |
shr edi, 2 |
imul esi, [_WinMapWidth] |
add edi, [_WinMapAddress] |
add esi, edi |
movzx esi, byte[esi] |
mov edi, esi |
shl edi, 5 |
/kernel/branches/Kolibri-A/trunk/gui/window.inc |
---|
12,7 → 12,7 |
;///// public functions /////////////////////////////////////////////////////// |
;============================================================================== |
window.BORDER_SIZE = 5 |
window.BORDER_SIZE = 4 |
macro FuncTable name, table_name, [label] |
{ |
336,11 → 336,11 |
@@: cmp edx, -1 |
jne @f |
mov edx, [edi + WDATA.box.width] |
and dl, 0xFC |
; and dl, 0xFC |
@@: cmp esi, -1 |
jne @f |
mov esi, [edi + WDATA.box.height] |
and esi, 0xFFFFFFFE |
; and esi, 0xFFFFFFFE |
@@: push esi edx ecx ebx |
mov eax, esp |
515,10 → 515,10 |
mov eax, [edi + WDATA.box.width] |
sub eax, ebx |
jle @f |
and bl, 0xFC ; <<<<<<< |
; and bl, 0xFC ; <<<<<<< |
mov [edi + WDATA.box.width], ebx |
@@: sub ebx, [edi + WDATA.box.width] |
and bl, 0xFC ; <<<<<<< |
; and bl, 0xFC ; <<<<<<< |
mov [edi + WDATA.box.left], ebx |
.fix_vertical: |
530,10 → 530,10 |
mov eax, [edi + WDATA.box.height] |
sub eax, ebx |
jle @f |
and bl, 0xFE ; <<<<<<< |
; and bl, 0xFE ; <<<<<<< |
mov [edi + WDATA.box.height], ebx |
@@: sub ebx, [edi + WDATA.box.height] |
and bl, 0xFE ; <<<<<<< |
; and bl, 0xFE ; <<<<<<< |
mov [edi + WDATA.box.top], ebx |
jmp .fix_client_box |
666,6 → 666,7 |
add ebx, edx |
mov eax, [esi + WDATA.box.left] |
inc eax |
shl eax, 16 |
add eax, [esi + WDATA.box.left] |
add eax, [esi + WDATA.box.width] |
1455,9 → 1456,9 |
movzx eax, cx |
mov [edi + WDATA.box.height], eax |
sar ebx, 16 |
and bl, 0xFC ; <<<<<<<< |
; and bl, 0xFC ; <<<<<<<< |
sar ecx, 16 |
and cl, 0xFE ; <<<<<<<< |
; and cl, 0xFE ; <<<<<<<< |
mov [edi + WDATA.box.left], ebx |
mov [edi + WDATA.box.top], ecx |
1647,6 → 1648,7 |
ff_width dd ? |
ff_xsz dd ? |
ff_ysz dd ? |
ff_map dd ? |
ff_scale dd ? |
end virtual |
1673,39 → 1675,40 |
sub edx, ebx |
inc ecx |
inc edx |
shr ecx, 2 ; 1 tile = 4 pix |
shr edx, 1 ; 1 tile = 2 lines |
; get WinMap start |
push esi |
mov edi, [_WinMapWidth] |
mov esi, edi |
shr ebx, 1 |
imul edi, ebx |
shr eax, 1 |
shr eax, 1 |
shr eax, 2 |
add edi, eax |
add edi, [_WinMapAddress] |
pop eax |
mov ah, al |
push ax |
shl eax, 16 |
pop ax |
pop eax ; al = process# |
; mov ah, al |
; push ax |
; shl eax, 16 |
; pop ax ; eax = 4 dup PROCESS_NUM |
sub esi, ecx ; map line increment (bytes) |
mov ebx, ecx ; map line width |
.next_line: |
push ecx |
shr ecx, 2 |
rep stosd |
mov ecx, [esp] |
and ecx, 3 |
; shr ecx, 2 ; 1dword = 4 tiles |
; rep stosd ; filling the screen map |
; mov ecx, ebx |
; and ecx, 3 ; 0 to 3 tiles remaining |
rep stosb |
pop ecx |
mov ecx, ebx |
add edi, esi |
sub edi, ecx |
dec edx |
jnz .next_line |
jmp .exit |
.shaped_window: |
; for (y=0; y <= x_size; y++) |
; for (y=0; y <= y_size; y++) |
; for (x=0; x <= x_size; x++) |
; if (shape[coord(x,y,scale)]==1) |
; set_pixel(x, y, process_number); |
1717,19 → 1720,22 |
push [edi + APPDATA.wnd_shape_scale] ; push scale first -> for loop |
; get WinMap start -> ebp |
push ebx |
push eax |
mov eax, [_WinMapWidth] ; <<<< |
mov ebp, eax |
shr ebp, 2 |
add ebp, [_WinMapAddress] |
mov eax, [_WinMapWidth] |
shr ebx, 1 |
imul eax, ebx |
mov ebp, [esp] |
shr ebp, 1 |
shr ebp, 1 |
add ebp, eax |
add ebp, [_WinMapAddress] |
add ebp, eax ; ebp = map origin |
mov edi, [edi + APPDATA.wnd_shape] |
pop eax |
pop ebx |
push ebp ; for loop - screen map origin |
; eax = x_start |
; ebx = y_start |
; ecx = x_size |
1736,9 → 1742,10 |
; edx = y_size |
; esi = process_number |
; edi = &shape |
; ebp = [ff_map] |
; [scale] |
push edx ecx ; for loop - x,y size |
mov ecx, esi |
shl ecx, 5 |
mov edx, [window_data + ecx + WDATA.box.top] |
1769,40 → 1776,41 |
add eax, edx |
pop edx ebx |
add eax, edi |
call .read_byte |
call .read_byte ; al= shaped window pix-mask at a given point |
test al,al |
jz @f |
mov eax, esi |
mov [ebp], al |
mov [ebp], al ; a tile belongs to the window if the 1st pixel's mask = 1 |
; -- end body -- |
@@: inc ebp |
inc edx |
@@: |
add edx, 4 |
inc ebp |
cmp edx, [ff_xsz] |
jb .ff_new_x |
sub ebp, [ff_xsz] |
add ebp, [ff_x] |
add ebp, [Screen_Max_X] ; screen.x |
inc ebp |
inc ebx |
inc ebx |
cmp ebx, [ff_ysz] |
jb .ff_new_y |
add esp, 24 |
jnb @f |
mov ebp, [ff_map] |
add ebp, [_WinMapWidth] ; even line: jump to next map row |
mov [ff_map], ebp |
jmp .ff_new_y |
@@: |
add esp, 7*4 |
.exit: |
popad |
ret |
.read_byte: |
; eax - address |
; esi - slot |
; eax - buffer address |
; esi - slot# |
push eax ecx edx esi |
xchg eax, esi |
lea ecx, [esp + 12] |
mov edx, 1 |
call read_process_memory |
pop esi edx ecx eax |
lea ecx, [esp + 12] ; buffer addr = stacked [eax] to return |
mov edx, 1 ; buffer size |
call read_process_memory ; (core/taskman.inc) returns #bytes read |
pop esi edx ecx eax ; eax = PID |
ret |
align 4 |
/kernel/branches/Kolibri-A/trunk/hid/mousedrv.inc |
---|
161,7 → 161,7 |
mov esi, edi |
add edi, esi |
add edi, esi ; *3 |
add edi,[MOUSE_PICTURE] ; we have our str address |
add edi, mousepointer ;[MOUSE_PICTURE] ; we have our str address |
mov esi, edi |
add esi, 16*24*3 |
push ecx |
/kernel/branches/Kolibri-A/trunk/kernel.asm |
---|
63,9 → 63,6 |
USE_COM_IRQ equ 1 ; make irq 3 and irq 4 available for PCI devices |
; Enabling the next line will enable serial output console |
;debug_com_base equ 0x3f8 ; 0x3f8 is com1, 0x2f8 is com2, 0x3e8 is com3, 0x2e8 is com4, no irq's are used |
include "proc32.inc" |
include "kglobals.inc" |
344,8 → 341,8 |
mov [screen_workarea.bottom],eax |
movzx eax,word [BOOT_VAR+0x9008] ; screen mode |
mov [SCR_MODE],eax |
mov eax,[BOOT_VAR+0x9014] ; Vesa 1.2 bnk sw add |
mov [BANK_SWITCH],eax |
; mov eax,[BOOT_VAR+0x9014] ; Vesa 1.2 bnk sw add == not used any more |
; mov [BANK_SWITCH],eax |
movzx eax, word[BOOT_VAR+0x9001] ; for other modes |
mov [BytesPerScanLine],ax |
mov [_display.pitch], eax |
375,8 → 372,8 |
; === EGA, VGA & Vesa 1.2 modes not supported === |
setvesa20: |
v20ga32: |
mov [PUTPIXEL],dword put_pixel |
mov [GETPIXEL],dword get_pixel |
; mov [PUTPIXEL],dword put_pixel |
; mov [GETPIXEL],dword get_pixel |
; -------- Fast System Call init ---------- |
.SEnP: |
514,8 → 511,8 |
mov [BgrDrawMode],eax |
mov [BgrDataWidth],eax |
mov [BgrDataHeight],eax |
mov [mem_BACKGROUND], 4 |
mov [img_background], static_background_data |
; mov [mem_BACKGROUND], 4 |
; mov [img_background], static_background_data |
mov [SLOT_BASE + 256 + APPDATA.dir_table], sys_pgdir - OS_BASE |
603,17 → 600,6 |
mov esi, boot_memdetect |
call boot_log |
; <<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> |
mov ebx, img_test_struct |
mov ecx, 3*65536 + 4 |
mov edx, 32*65536 + 512 |
mov esi, 32 |
xor edi, edi |
mov ebp, edi |
call sys_putimage_palette.forced |
;<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>> |
movzx ecx, word [boot_y] |
or ecx, (10+29*6) shl 16 ; "Determining amount of memory" |
sub ecx, 10 |
645,16 → 631,9 |
mov esi,boot_bgr |
call boot_log |
call init_background |
call _init_background ;graph32.inc ? |
call calculatebackground |
; RESERVE SYSTEM IRQ'S JA PORT'S |
; mov esi,boot_resirqports |
; call boot_log |
; call reserve_irqs_ports |
; SET UP OS TASK |
mov esi,boot_setostask |
706,6 → 685,138 |
mov [SLOT_BASE+APPDATA.cursor],eax |
mov [SLOT_BASE+APPDATA.cursor+256],eax |
; <<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>> |
; mov esi, img_test_struct_8 |
; mov edi, 151 |
; mov ebp, edi |
; imul edi, [BytesPerScanLine] |
; add edi, LFB_BASE + 32*4 |
; mov [img_lfb_origin], edi |
; shr ebp, 1 |
; imul ebp, [_WinMapWidth] |
; add ebp, 32/4 |
; add ebp, [_WinMapAddress] |
; mov ecx, ebp |
; add ecx, [_WinMapWidth] |
; mov byte[ecx+1], 2 |
; mov ecx, 6 |
; mov [img_pix_y], ecx |
; mov eax, 1 |
; mov [img_bytes_per_pix], eax |
; mov ebx, 1 |
; bts ebx, 24 |
; mov eax, 8-1 |
; mov [img_pix_x], eax |
; inc eax |
; shr eax, 2 |
; mov [img_map_x], eax |
; mov [img_draw_core_fn], draw_core_8bpp |
; mov [img_draw_edge_fn], draw_edge_8bpp |
; mov [img_buf_line_size], 9 |
; mov [img_palette], img_test_palette |
; call draw_aligned_box |
; add edi, 48 |
; mov edx, 8 |
; call draw_unaligned_edge |
; mono |
; bts ebx, 25 |
; add edi, [_WinMapWidth] ; = 1/16 of the screen width |
; mov esi, img_test_struct_1 |
; mov [img_lfb_origin], edi |
; mov ecx, 9 |
; mov [img_map_x], 4 |
; mov [img_bitoffset], 1 |
; mov [img_edgeoffset], 16 |
; mov [img_draw_core_fn], draw_core_1bpp |
; mov [img_draw_edge_fn], draw_edge_1bpp |
; mov [img_buf_line_size], 2 |
; mov [img_bytes_per_pix], 0 |
; call draw_aligned_box |
; add edi, 48 |
; mov edx, 8 |
; call draw_unaligned_edge |
; btr ebx, 25 |
; 32bpp |
; add edi, [_WinMapWidth] ; = 1/16 of the screen width |
; mov esi, img_test_struct_32 |
; mov [img_lfb_origin], edi |
; mov ecx, 6 |
; mov [img_map_x], 2 |
; mov [img_draw_core_fn], draw_core_32bpp |
; mov [img_draw_edge_fn], draw_edge_32bpp |
; mov [img_buf_line_size], 32 |
; mov [img_bytes_per_pix], 4 |
; call draw_aligned_box |
; add edi, 48 |
; mov edx, 8 |
; call draw_unaligned_edge |
; 24bpp |
; add edi, [_WinMapWidth] ; = 1/16 of the screen width |
; mov esi, img_test_struct_24 |
; mov [img_lfb_origin], edi |
; mov ecx, 7 |
; mov [img_map_x], 4 |
; mov [img_draw_core_fn], draw_core_24bpp |
; mov [img_draw_edge_fn], draw_edge_24bpp |
; mov [img_buf_line_size], 45 |
; mov [img_bytes_per_pix], 3 |
; call draw_aligned_box |
; add edi, 80 |
; mov edx, 4 |
; call draw_unaligned_edge |
; mov [TASK_BASE-twdw + WDATA.box.left], 0 |
; mov [TASK_BASE-twdw + WDATA.box.top], 0 |
; mov eax, [Screen_Max_X] |
; mov [TASK_BASE-twdw + WDATA.box.width], eax |
; mov eax, [Screen_Max_Y] |
; mov [TASK_BASE-twdw + WDATA.box.height], eax |
; mov ebx, img_test_struct_24 |
; mov ecx, 16*65536 + 7 |
; mov edx, 512*65536 + 400 |
; call _putimage |
;----------- |
; mov ebx, img_test_struct_32 |
; mov ecx, 6*65536 + 6 |
; mov edx, 32*65536 + 512 |
; mov esi, 32 |
; xor edi, edi |
; mov ebp, edi |
; call sys_putimage_palette.forced |
; mov [img_palette], img_test_palette |
; mov [img_bytes_per_pix], 0 |
; mov [img_buf_line_size], 0 |
; mov ebx, img_test_palette |
; mov [img_draw_core_fn], draw_core_0bpp |
; mov [img_draw_edge_fn], draw_edge_0bpp |
; mov ecx, 20*65536 + 9 |
; mov edx, 513*65536 + 401 |
; call _putimage |
; mov eax, 561 |
; mov ebx, 461 |
; mov ecx, 555 |
; mov edx, 333 |
; mov edi, 0xAA5533 |
; call _drawbar |
; jmp $ |
;<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>> |
; READ TSC / SECOND |
mov esi,boot_tsc |
744,17 → 855,18 |
call set_variables |
; SET MOUSE |
;call detect_devices |
stdcall load_driver, szPS2MDriver |
; stdcall load_driver, szCOM_MDriver |
mov esi,boot_setmouse |
call boot_log |
call setmouse |
; call setmouse |
cli |
; STACK AND FDC |
call stack_init |
852,47 → 964,7 |
;// mike.dld ] |
; Setup serial output console (if enabled) |
if defined debug_com_base |
; enable Divisor latch |
mov dx, debug_com_base+3 |
mov al, 1 shl 7 |
out dx, al |
; Set speed to 115200 baud (max speed) |
mov dx, debug_com_base |
mov al, 0x01 |
out dx, al |
mov dx, debug_com_base+1 |
mov al, 0x00 |
out dx, al |
; No parity, 8bits words, one stop bit, dlab bit back to 0 |
mov dx, debug_com_base+3 |
mov al, 3 |
out dx, al |
; disable interrupts |
mov dx, debug_com_base+1 |
mov al, 0 |
out dx, al |
; clear + enable fifo (64 bits) |
mov dx, debug_com_base+2 |
mov al, 0x7 + 1 shl 5 |
out dx, al |
end if |
; START MULTITASKING |
if preboot_blogesc |
933,9 → 1005,6 |
inc edi |
call dtext |
; mov [novesachecksum],1000 |
; call checkVga_N13 |
popad |
ret |
951,11 → 1020,9 |
call window_check_events |
call mouse_check_events |
call checkmisc |
; call checkVga_N13 |
call stack_handler |
call checkidle |
call check_fdd_motor_status |
; call check_ATAPI_device_event |
; call check_fdd_motor_status |
jmp osloop |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
; ; |
1764,6 → 1831,7 |
test eax, eax |
jz @F |
stdcall user_free, eax |
@@: |
2150,227 → 2218,29 |
bgrlock db 0 |
endg |
;=============================== SysFn 15 ================================ |
; no background service supported so far ... |
;=========================================== |
sys_background: |
cmp ebx,1 ; BACKGROUND SIZE |
jnz nosb1 |
test ecx,ecx |
; cmp ecx,0 |
jz sbgrr |
test edx,edx |
; cmp edx,0 |
jz sbgrr |
@@: |
;;Maxis use atomic bts for mutexes 4.4.2009 |
bts dword [bgrlock], 0 |
jnc @f |
call change_task |
jmp @b |
@@: |
mov [BgrDataWidth],ecx |
mov [BgrDataHeight],edx |
; mov [bgrchanged],1 |
pushad |
; return memory for old background |
mov eax, [img_background] |
cmp eax, static_background_data |
jz @f |
stdcall kernel_free, eax |
@@: |
; calculate RAW size |
xor eax,eax |
inc eax |
cmp [BgrDataWidth],eax |
jae @f |
mov [BgrDataWidth],eax |
@@: |
cmp [BgrDataHeight],eax |
jae @f |
mov [BgrDataHeight],eax |
@@: |
mov eax,[BgrDataWidth] |
imul eax,[BgrDataHeight] |
lea eax,[eax*3] |
mov [mem_BACKGROUND],eax |
; get memory for new background |
stdcall kernel_alloc, eax |
test eax, eax |
jz .memfailed |
mov [img_background], eax |
jmp .exit |
.memfailed: |
; revert to static monotone data |
mov [img_background], static_background_data |
xor eax, eax |
inc eax |
mov [BgrDataWidth], eax |
mov [BgrDataHeight], eax |
mov [mem_BACKGROUND], 4 |
cmp ebx,6 ; subfns 1..5 do not return anything |
jb .exit |
mov dword [esp+32], 0 ; subfns 6,7 return 0 as error |
.exit: |
popad |
mov [bgrlock], 0 |
sbgrr: |
ret |
nosb1: |
;=============================== SysFn 39 ================================ |
; no background service supported so far ... |
;=========================================== |
align 4 |
cmp ebx,2 ; SET PIXEL |
jnz nosb2 |
mov eax, [img_background] |
test ecx, ecx |
jz @f |
cmp eax, static_background_data |
jz .ret |
@@: |
mov ebx, [mem_BACKGROUND] |
add ebx, 4095 |
and ebx, -4096 |
sub ebx, 4 |
cmp ecx, ebx |
ja .ret |
mov ebx,[eax+ecx] |
and ebx,0xFF000000 ;255*256*256*256 |
and edx,0x00FFFFFF ;255*256*256+255*256+255 |
add edx,ebx |
mov [eax+ecx],edx |
.ret: |
sys_getbackground: |
mov dword [esp+32], 0 |
ret |
nosb2: |
cmp ebx,3 ; DRAW BACKGROUND |
jnz nosb3 |
draw_background_temp: |
; cmp [bgrchanged],1 ;0 |
; je nosb31 |
;draw_background_temp: |
; mov [bgrchanged],1 ;0 |
;=========================================== |
mov [background_defined], 1 |
mov byte[BACKGROUND_CHANGED], 1 |
call force_redraw_background |
nosb31: |
ret |
nosb3: |
cmp ebx,4 ; TILED / STRETCHED |
jnz nosb4 |
cmp ecx,[BgrDrawMode] |
je nosb41 |
mov [BgrDrawMode],ecx |
; mov [bgrchanged],1 |
nosb41: |
ret |
nosb4: |
cmp ebx,5 ; BLOCK MOVE TO BGR |
jnz nosb5 |
cmp [img_background], static_background_data |
jnz @f |
test edx, edx |
jnz .fin |
cmp esi, 4 |
ja .fin |
@@: |
; bughere |
mov eax, ecx |
mov ebx, edx |
add ebx, [img_background] ;IMG_BACKGROUND |
mov ecx, esi |
call memmove |
.fin: |
ret |
nosb5: |
cmp ebx, 6 |
jnz nosb6 |
;;Maxis use atomic bts for mutex 4.4.2009 |
@@: |
bts dword [bgrlock], 0 |
jnc @f |
call change_task |
jmp @b |
@@: |
mov eax, [CURRENT_TASK] |
mov [bgrlockpid], eax |
cmp [img_background], static_background_data |
jz .nomem |
stdcall user_alloc, [mem_BACKGROUND] |
mov [esp+32], eax |
test eax, eax |
jz .nomem |
mov ebx, eax |
shr ebx, 12 |
or dword [page_tabs+(ebx-1)*4], DONT_FREE_BLOCK |
mov esi, [img_background] |
shr esi, 12 |
mov ecx, [mem_BACKGROUND] |
add ecx, 0xFFF |
shr ecx, 12 |
.z: |
mov eax, [page_tabs+ebx*4] |
test al, 1 |
jz @f |
call free_page |
@@: |
mov eax, [page_tabs+esi*4] |
or al, PG_UW |
mov [page_tabs+ebx*4], eax |
mov eax, ebx |
shl eax, 12 |
invlpg [eax] |
inc ebx |
inc esi |
loop .z |
ret |
.nomem: |
and [bgrlockpid], 0 |
mov [bgrlock], 0 |
nosb6: |
cmp ebx, 7 |
jnz nosb7 |
cmp [bgrlock], 0 |
jz .err |
mov eax, [CURRENT_TASK] |
cmp [bgrlockpid], eax |
jnz .err |
mov eax, ecx |
mov ebx, ecx |
shr eax, 12 |
mov ecx, [page_tabs+(eax-1)*4] |
test cl, USED_BLOCK+DONT_FREE_BLOCK |
jz .err |
jnp .err |
push eax |
shr ecx, 12 |
dec ecx |
@@: |
and dword [page_tabs+eax*4], 0 |
mov edx, eax |
shl edx, 12 |
push eax |
invlpg [edx] |
pop eax |
inc eax |
loop @b |
pop eax |
and dword [page_tabs+(eax-1)*4], not DONT_FREE_BLOCK |
stdcall user_free, ebx |
mov [esp+32], eax |
and [bgrlockpid], 0 |
mov [bgrlock], 0 |
ret |
.err: |
and dword [esp+32], 0 |
ret |
nosb7: |
ret |
force_redraw_background: |
and [draw_data+32 + RECT.left], 0 |
and [draw_data+32 + RECT.top], 0 |
2382,54 → 2252,9 |
pop ebx eax |
inc byte[REDRAW_BACKGROUND] |
ret |
;=========================================== |
align 4 |
sys_getbackground: |
; cmp eax,1 ; SIZE |
dec ebx |
jnz nogb1 |
mov eax,[BgrDataWidth] |
shl eax,16 |
mov ax,[BgrDataHeight] |
mov [esp+32],eax |
ret |
nogb1: |
; cmp eax,2 ; PIXEL |
dec ebx |
jnz nogb2 |
mov eax, [img_background] |
test ecx, ecx |
jz @f |
cmp eax, static_background_data |
jz .ret |
@@: |
mov ebx, [mem_BACKGROUND] |
add ebx, 4095 |
and ebx, -4096 |
sub ebx, 4 |
cmp ecx, ebx |
ja .ret |
mov eax,[ecx+eax] |
and eax, 0xFFFFFF |
mov [esp+32],eax |
.ret: |
ret |
nogb2: |
; cmp eax,4 ; TILED / STRETCHED |
dec ebx |
dec ebx |
jnz nogb4 |
mov eax,[BgrDrawMode] |
nogb4: |
mov [esp+32],eax |
ret |
align 4 |
sys_getkey: |
2846,26 → 2671,6 |
;--------------------------------------------------------------------------------------------- |
; check if pixel is allowed to be drawn |
; -- not in use any more ? |
;checkpixel: |
; push eax ebx edx |
; shr ebx, 1 |
; mov edx, [_WinMapWidth] ; <<<< |
; imul edx, ebx |
; shr eax, 2 |
; add eax, [_WinMapAddress] |
; mov dl, [eax+edx] |
; |
; xor ecx, ecx |
; mov eax, [CURRENT_TASK] |
; cmp al, dl |
; setne cl |
; |
; pop edx ebx eax |
; ret |
iglobal |
cpustring db 'CPU',0 |
endg |
3291,18 → 3096,10 |
drawbackground: |
inc [mouse_pause] |
; cmp [BgrDrawMode],dword 1 |
; jne bgrstr |
; call vesa20_drawbackground_tiled |
call drawbackground |
call draw_background ; graph32.inc |
dec [mouse_pause] |
call [draw_pointer] |
ret |
; bgrstr: |
; call vesa20_drawbackground_stretch |
; dec [mouse_pause] |
; call [draw_pointer] |
; ret |
; ==================================================================== |
align 4 |
3339,7 → 3136,8 |
inc [mouse_pause] |
call _putimage |
dec [mouse_pause] |
jmp [draw_pointer] |
call [draw_pointer] |
ret |
align 4 |
3357,12 → 3155,13 |
add dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.left] |
rol edx, 16 |
.forced: |
push eax |
push esi |
mov [img_palette], edi |
mov eax, esi |
cmp eax, 32 ;>32bpp (stupid call) |
ja .exit |
shr al, 3 ; 0=1bpp, other lo-pix modes not supported |
push esi |
shr al, 3 ; 0=1bpp or solid color |
mov [img_bytes_per_pix], eax |
mov esi, [eax*4 + img_core_proc_0] |
mov [img_draw_core_fn], esi |
3370,29 → 3169,34 |
mov [img_draw_edge_fn], esi |
mov esi, ecx |
shr esi, 16 ; esi = SizeX |
imul esi, eax |
or al, al |
jz .1bpp |
imul esi, eax |
jmp .done |
jnz .done |
mov eax, [esp] ; bits per pixel |
or al, al |
jz .done |
.1bpp: |
add esi, 7 |
shr esi, 3 ; 8 pixels per byte |
mov [img_draw_edge_fn], draw_edge_1bpp |
mov [img_draw_core_fn], draw_core_1bpp |
.done: |
add esi, ebp ; + line offset |
mov [img_buf_line_size], esi |
pop esi |
jmp _putimage ;<<< sys_putimage_bpp |
pop eax |
jmp sys_putimage_bpp |
.exit: |
ret |
align 4 |
img_core_proc_0 dd draw_core_1bpp |
img_core_proc_0 dd draw_core_0bpp |
img_core_proc_1 dd draw_core_8bpp |
img_core_proc_2 dd draw_core_16bpp |
img_core_proc_3 dd draw_core_24bpp |
img_core_proc_4 dd draw_core_32bpp |
img_edge_proc_0 dd draw_edge_1bpp |
img_edge_proc_0 dd draw_edge_0bpp |
img_edge_proc_1 dd draw_edge_8bpp |
img_edge_proc_2 dd draw_edge_16bpp |
img_edge_proc_3 dd draw_edge_24bpp |
3414,7 → 3218,7 |
.forced: |
inc [mouse_pause] |
; dbv20: |
call vesa20_drawbar |
call _drawbar |
dec [mouse_pause] |
jmp [draw_pointer] |
3517,27 → 3321,25 |
ret |
setmouse: ; set mousepicture -pointer |
;setmouse: ; set mousepicture -pointer |
; ps2 mouse enable |
mov [MOUSE_PICTURE],dword mousepointer |
; mov [MOUSE_PICTURE],dword mousepointer |
; cli |
; ret |
cli |
;if used _rdtsc |
;_rdtsc: |
; bt [cpu_caps], CAPS_TSC |
; jnc ret_rdtsc |
; rdtsc |
; ret |
; ret_rdtsc: |
; mov edx,0xffffffff |
; mov eax,0xffffffff |
; ret |
;end if |
ret |
if used _rdtsc |
_rdtsc: |
bt [cpu_caps], CAPS_TSC |
jnc ret_rdtsc |
rdtsc |
ret |
ret_rdtsc: |
mov edx,0xffffffff |
mov eax,0xffffffff |
ret |
end if |
rerouteirqs: |
cli |
3667,24 → 3469,6 |
cmp eax, 1 |
jne .smbl1 |
if defined debug_com_base |
push dx ax |
@@: ; Wait for empty transmit register (yes, this slows down system..) |
mov dx, debug_com_base+5 |
in al, dx |
test al, 1 shl 5 |
jz @r |
mov dx, debug_com_base ; Output the byte |
mov al, bl |
out dx, al |
pop ax dx |
end if |
mov [msg_board_data+ecx],bl |
inc ecx |
and ecx, 4095 |
3875,16 → 3659,9 |
mov eax, ebx |
mov ebx, ecx |
mov ecx, edx |
mov edx, [TASK_BASE] |
add eax, [edx-twdw+WDATA.box.left] |
add ebx, [edx-twdw+WDATA.box.top] |
mov edi, [current_slot] |
add eax, [edi+APPDATA.wnd_clientbox.left] |
add ebx, [edi+APPDATA.wnd_clientbox.top] |
xor edi, edi ; no force |
; mov edi, 1 |
call [_display.disable_mouse] |
jmp [putpixel] |
; call [_display.disable_mouse] |
jmp __sys_putpixel |
align 4 |
3966,7 → 3743,7 |
div ecx |
mov ebx, edx |
xchg eax, ebx |
call dword [GETPIXEL] ; eax - x, ebx - y |
call get_pixel ; eax - x, ebx - y |
mov [esp + 32], ecx |
ret |
4028,7 → 3805,7 |
push eax ebx ecx |
add eax,ecx |
call dword [GETPIXEL] ; eax - x, ebx - y |
call get_pixel ; eax - x, ebx - y |
mov [ebp],cx |
shr ecx,16 |
4187,8 → 3964,7 |
stdcall kernel_free, [_WinMapAddress] |
mov eax, [_display.width] |
shr eax, 1 |
shr eax, 1 |
shr eax, 2 |
mov [_WinMapWidth], eax |
mov eax, [_display.height] |
shr eax, 1 |
4528,3 → 4304,28 |
uglobals_size = $ - endofcode |
diff16 "Zero-filled blk",0,endofcode |
diff16 "End of kernel ",0,$ |
;Êóðãèíÿí - ìàòåìàòèê, è îñíîâíûå ñâîè âûâîäû äåëàåò íà îñíîâå òåîðèè êàòàñòðîô (åñòü òàêàÿ âïîëíå ñåáå ïðèêëàäíàÿ îáëàñòü ìàòåìàòèêè) ñ ýëåìåíòàìè âàðèàöèîííîãî è ôàêòîðíîãî àíàëèçà.  ïðèíöèïå, îí ìîã áû èçëîæèòü ñóòü â 3-4 ñóõèõ ôîðìóëàõ, íî òîëüêî ïîíÿòü èõ ìîãëè (è çàõîòåëè) áû ÷åëîâåê 200-300... |
;Âîò è ïðèõîäèòñÿ åìó èçëàãàòü òî æå ñàìîå, íî ãîðàçäî äëèííåå è äîõîä÷èâåå. Ëè÷íî ÿ íå ïîëåíèëñÿ è ïðî÷èòàë öèêë "Êðèçèñ è äðóãèå" â àðõèâå "Çàâòðà" çà 2009 ãîä. |
;Âîò î÷åíü êðàòêàÿ âûæèìêà åãî îñíîâíûõ èäåé (ñ ìîåé êîëîêîëüíè, êîíå÷íî): |
;1) Ïëàíåòà ïåðåíàñåëåíà, ðåñóðñîâ íà âñåõ íå õâàòèò, ïåðèîä ëèáåðàëüíåíêîé ãëîáàëèçàöèè äîëæåí ñìåíèòüñÿ ýðîé æåñòêîãî ðàöèîíèðîâàíèÿ ïðè òîòàëüíîì êîíòðîëå âñåãî. |
;2) Ó ãðÿäóùåãî òîòàëèòàðíîãî îáùåñòâà äîëæíà áûòü ãîñïîäñòâóþùàÿ èäåîëîãèÿ, ìîáèëèçóþùàÿ ëþäåé â ñóðîâîé áîðüáå. Êàêîé åé áûòü? äëÿ ýòîãî íàäî îòâåòèòü íà äâà îñíîâíûõ âîïðîñà: à) ìîæíî ëè ñäåëàòü ÷åëîâåêà ëó÷øå, ñèëüíåå, óìíåå? è á) ìîæíî ëè ñäåëàòü îáùåñòâî ëó÷øå, ñïðàâåäëèâåå, ñâîáîäíåå? |
;3) ñóùåñòâóåò 4 âîçìîæíûõ îòâåòà íà ýòè 2 âîïðîñà: (à+á+) èñòîðè÷åñêèé ìîäåðí, îí æå êîììóíèçì; (à+á-) àíòèèñòîðè÷åñêèé ìîäåðí, èëè ôàøèçì; (à-á+) ðåëèãèîçíûé ôóíäàìåíòàëèçì, èëè Êîíòðìîäåðí; è íàêîíåö (à-á-) öèíè÷íûé àíòèãóìàíèçì, îí æå Ïîñòìîäåðí. |
;4) êðóøåíèå êîììóíèñòè÷åñêîãî ïðîåêòà â XX âåêå áûëî òùàòåëüíî ñïëàíèðîâàííîé êàòàñòðîôîé ñ öåëüþ ïîâîðîòà ÷åëîâå÷åñòâà ñ ìîäåðíèñòñêîãî ïóòè ðàçâèòèÿ íà ïîñòìîäåðíèñòñêèé ïóòü ðàñïàäà. Êóðãèíÿí çäåñü èìååò â âèäó êàòàñòðîôó â ìàòåìàòè÷åñêîì ñìûñëå, ò.å. íå êàêîå-òî ïå÷àëüíîå ñîáûòèå, à ïðîöåññ, ïðèâîäÿùèé ê òàêîìó ñîáûòèþ. ß íå õî÷ó ïåðåñêàçûâàòü çäåñü âñå ïîëîæåíèÿ òåîðèè êàòàñòðîô - âàæíî òîëüêî ïîíèìàòü, ÷òî òàêîé ïðîöåññ âîâñå íå îáÿçàòåëüíî äîëæåí ïðèâîäèòü ê ôàòàëüíîìó èñõîäó - âûõîä èç êàòàñòðîôû âñåãäà ìîæíî íàéòè, âïëîòü äî ñàìîãî ïîñëåäíåãî ìîìåíòà! |
;5) êàòèòüñÿ ïî ýòîìó êàòàñòðîôè÷åñêîìó ïóòè ëåãêî, íî íàéòè âûõîä èç êàòàñòðîôû ñ êàæäûì øàãîì âñå ñëîæíåå. ×òîáû èçáåæàòü ôàòàëüíîãî êîíöà, îäíîé ýíåðãèè ìàëî - òðåáóåòñÿ èçðÿäíàÿ ñèëà âîëè. |
;6) çäåñü Êóðãèíÿí ïîäêëþ÷àåò äðóãîé ìàòåìàòè÷åñêèé àïïàðàò - òåîðèþ èãð. È ïîêàçûâàåò, êàê øóëåðà - ìàãèñòðû ñëîæíîé êîàëèöèîííî-àíòàãîíèñòè÷åñêîé èãðû óìåþò öåëåíàïðàâëåííî è ýôôåêòèâíî ëèøàòü ïðîòèâíèêîâ âîëè è ñìûñëîâ äëÿ ïîèñêà âûõîäà èç êàòàñòðîôû. |
;7) êîíå÷íî, ÷åëîâå÷åñêîå îáùåñòâî - ñëîæíåéøàÿ ñèñòåìà ñ íåïðåäñêàçóåìûì îòêëèêîì íà àêòèíûå äåéñòâèÿ êàæäîãî èç èãðîêîâ. Äàæå îïûòíåéøèé øóëåð ìîæåò çäåñü ñäåëàòü íåâåðíûå õîäû. Íî â ðàñïîðÿæåíèè ìàñòåðîâ èãðû èìååòñÿ åùå îäèí ìîùíûé àïïàðàò - ôàêòîðíûé àíàëèç, ïîçâîëÿþùèé ýôôåêòèâíî êîððåêòèðîâàòü ïðîìàõè è ëó÷øå ïðåäñêàçûâòü ïîâåäåíèå ñëîæíûõ ñèñòåì. |
;8) è òåì íå ìåíåå, âûõîä åñòü! Äëÿ íà÷àëà, íàäî ðåàëüíî îñîçíàòü ñâîþ ïîçèöèþ â èãðå è íàâÿçàòü ñâîþ, àêòèâíóþ èãðó (êàæäûé íîâûé àêòèâíûé èãðîê óñëîæíÿåò ïàðòíåðàì àíàëèç èãðû). Ýòî ñëîæíî (ïðîùå áûòü áîëâàíîì), è ýòî òðåáóåò Âîëè è âîññîçäàíèÿ Ñìûñëîâ. |
;9) äàæå ñàìàÿ àêòèâíàÿ èãðà áóäåò ïðîñòûì áàðàõòàíüåì, åñëè íå ñòàâèòñÿ êîíå÷íàÿ öåëü. Òàêàÿ öåëü åñòü. Òî÷íåå - áûëà: ïðîåêò (à+á+). Åñëè åå âîññòàíîâèòü, ìû íå ïðîñòî âåðíåìñÿ ê àêòèâíîé èãðå - ìû ìîæåì ñôîðìèðîâàòü ìîùíóþ êîàëèöèþ àíòèïîñòìîäåðíèñòîâ. |
/kernel/branches/Kolibri-A/trunk/memmap.inc |
---|
67,9 → 67,9 |
; |
; 6F00 -> 6FFF free (256) |
; |
; 7000 -> 7FFF used CD driver |
; 7000 -> 7FFF unused? CD driver (4k) |
; |
; 8000 -> A3FF used FLOPPY driver |
; 8000 -> A3FF used? FLOPPY driver (4k) |
; |
; A400 -> B0FF free (3k3), unused ACTIVE_PROC_STACK |
143,14 → 143,14 |
; |
; 0x80010000 -> 6CBFF kernel, 32-bit run-time code (up to 371 Kb) |
; in the current version: |
; -> 00B37 16-bit code end |
; -> 00B3C 16-bit code end |
; -> 00C40 16-bit data end |
; -> 10C40 32-bit code start |
; -> 2D582 32-bit code end |
; -> 30918..end_of_kernel zero-filled zone after preinit_mem |
; -> 3421B uninitialized globals start |
; -> 3C40A end_of_kernel |
; -> 3D000 not used (194k) |
; -> 2D07E 32-bit code end |
; -> 30418..end_of_kernel zero-filled zone after preinit_mem |
; -> 33D63 uninitialized globals start |
; -> 3BF52 end_of_kernel |
; -> 3C000 not used (>200k) |
; 0x80050000 -> 090000 zero-filled zone after preinit_mem |
; 0x8006CC00 -> 6DBFF stack at boot time (4Kb) |
; |
/kernel/branches/Kolibri-A/trunk/video/graph32.inc |
---|
51,21 → 51,26 |
mov eax, [img_map_x] |
xor ecx, ecx |
cmp bl, byte[ebp] ; check the left tile first |
jz .new_tile |
bts ebx, 26 ; ebx[26] = 1 if edi/esi already pushed |
jc .seek_visible |
je .new_tile |
bts ebx, 26 ; ebx[26] = 1 if edi/esi pushed |
push edi |
push esi |
push [img_bitoffset] |
jmp .seek_visible |
.new_tile: |
inc ecx ; visible - scan the open space |
cmp ecx, eax |
jz .end_of_line |
cmp bl, byte[ebp+ecx] ; overlapped? draw the visible segment if so |
cmp bl, byte[ebp+ecx] |
je .new_tile |
; overlapped? draw the last visible segment if so |
bts ebx, 26 ; check if edi/esi already pushed |
jc @f |
push edi |
push esi |
push [img_bitoffset] |
@@: call [img_draw_core_fn] ; bpp-specific helper (see below) |
call [img_draw_core_fn] ; bpp-specific helper (see below) |
.seek_visible: |
inc ecx |
cmp ecx, eax |
76,8 → 81,17 |
sub eax, ecx |
shl ecx, 4 |
add edi, ecx ; shift the left edge |
bt ebx, 25 ; 1bpp? |
jc @f |
shr ecx, 2 |
imul ecx, [img_bytes_per_pix] |
jmp .new_visible |
@@: shr ecx, 8 ; 2 tiles = 1 byte |
jnc .new_visible |
rol [img_bitoffset], 4 |
jnc .new_visible |
inc ecx |
.new_visible: |
add esi, ecx |
xor ecx, ecx |
jmp .new_tile |
88,6 → 102,7 |
.next_line: |
bt ebx, 26 |
jnc @f |
pop [img_bitoffset] |
pop esi |
pop edi |
@@: inc edx |
117,7 → 132,7 |
pushad |
mov eax, [img_buf_line_size] |
mov bh, dl ; store the 1st tile offset |
bt ebx, 24 ; check if the 1st line odd |
btr ebx, 24 ; check if the 1st line odd |
jnc .new_tile |
cmp bl, byte[ebp] |
jne @f |
128,7 → 143,6 |
add edi, [BytesPerScanLine] |
add ebp, [_WinMapWidth] |
add esi, eax |
btr ebx, 24 |
.new_tile: |
cmp bl, byte[ebp] |
jne .skip_tile |
166,6 → 180,18 |
; bh = edx = tile offset (0, 4, 8 or 12 bytes) |
align 4 |
draw_edge_0bpp: |
push eax |
mov eax, [esi] |
.putpix: |
mov [edi+edx], eax |
sub dl, 4 |
jae .putpix |
.exit: |
movzx edx, bh |
pop eax |
ret |
align 4 |
draw_edge_32bpp: |
push eax |
.putpix: |
174,7 → 200,7 |
sub dl, 4 |
jae .putpix |
.exit: |
mov dl, bh |
movzx edx, bh |
pop eax |
ret |
align 4 |
185,8 → 211,8 |
mov eax, [esi] |
and eax, 0x00FFFFFF |
mov [edi+edx], eax |
test dl, bh |
jz .exit |
cmp dl, bh |
je .exit |
add dl, 4 |
add esi, 3 |
jmp .putpix |
202,8 → 228,8 |
movzx eax, byte[esi] |
mov eax, [ebp+eax*4] |
mov [edi+edx], eax |
test dl, bh |
jz .exit |
cmp dl, bh |
je .exit |
add dl, 4 |
inc esi |
jmp .putpix |
212,28 → 238,29 |
ret |
align 4 |
draw_edge_1bpp: |
push eax ecx ebx ebp |
pushad |
movzx edx, bh |
add edx, edi |
mov ebp, [img_palette] |
mov ebx, [ebp+4] ; forecolor |
mov ebp, [ebp] ; backcolor |
mov ecx, [img_edgeoffset] ; cl = 1 << left_edge_pix_num |
mov ebp, [esi] |
xor dl, dl |
mov eax, [esi] |
.testbit: |
test ebp, ecx |
test eax, ecx |
jnz @f |
mov eax, ebp |
jmp .putpix |
@@: mov eax, ebx |
.putpix: |
mov [edi+edx], eax |
test dl, bh |
jz .exit |
add dl, 4 |
shl ecx, 1 |
mov [edi], eax |
cmp edi, edx |
je .exit |
add edi, 4 |
rol ecx, 1 |
jmp .testbit |
.exit: |
pop ebp ebx ecx eax |
popad |
ret |
draw_edge_16bpp: |
242,35 → 269,46 |
;------------- |
; aligned core helpers |
; esi -> left point address (image) |
; esi -> left point address (buffer) |
; edi -> left point address (screen) |
; cx = number of tiles to draw |
; ecx = number of tiles to draw |
align 4 |
draw_core_0bpp: |
push eax ecx edi |
pushfd |
; cli |
cld |
mov eax, [esi] |
shl ecx, 2 |
rep stosd |
popfd |
pop edi ecx eax |
ret |
align 4 |
draw_core_32bpp: |
push ecx |
shl ecx, 1 |
dec ecx |
.putpix: |
fld qword[esi+ecx*8] ; 2 qwords = 1 tile |
fstp qword[edi+ecx*8] |
dec cx |
jnb .putpix |
pop ecx |
push ecx esi edi |
pushfd |
; cli |
cld |
shl ecx, 2 |
rep movsd |
popfd |
pop edi esi ecx |
ret |
align 4 |
draw_core_24bpp: |
push eax ecx |
shl ecx, 2 |
push eax ecx edx |
shl ecx, 2 ; ecx = numpixels |
dec ecx |
lea eax, [ecx*2+ecx] |
lea edx, [ecx*2+ecx] ; edx = buffer byte offset |
.putpix: |
mov eax, [esi+eax] |
mov eax, [esi+edx] |
and eax, 0x00FFFFFF |
mov [edi+ecx*4], eax |
sub dx, 3 |
dec cx |
dec ecx |
sub edx, 3 |
jnb .putpix |
pop ecx eax |
pop edx ecx eax |
ret |
align 4 |
draw_core_8bpp: |
289,7 → 327,7 |
jnz .putone |
add esi, edx ;-) |
add edi, 16 |
dec cx |
dec ecx |
jnz .putpix |
.exit: |
popad |
302,8 → 340,6 |
mov ebp, [ebp] ; background color |
mov ebx, [img_bitoffset] |
shl ecx, 2 ; 1 tyle = 4 pix |
dec ecx |
jb .exit |
.newblock: |
mov eax, [esi] |
.putpix: |
314,8 → 350,8 |
.bkcolor: |
mov [edi], ebp |
.nextpix: |
dec cx |
jb .exit |
dec ecx |
jz .exit |
rol ebx, 1 |
jc .nextblock |
add edi, 4 |
339,6 → 375,10 |
; ebx -> Buffer origin |
; ecx = packed size [x|y] |
; edx = packed coordinates [x|y] |
; static variables required: |
; [img_draw_core_fn], [img_draw_edge_fn] |
; [img_bytes_per_pix], [img_buf_line_size] |
; [img_palette] (1bpp and 8bpp only) |
_putimage: |
; call [_display.disable_mouse] |
356,14 → 396,15 |
and edx, 0xFFFF ; Ytop |
shr eax, 16 ; Xleft |
.calculate_abs_coords: |
mov ebx, [TASK_BASE-twdw + WDATA.box.left] |
mov ecx, [TASK_BASE-twdw + WDATA.box.top] |
mov edi, [TASK_BASE] |
mov ebx, [edi-twdw + WDATA.box.left] |
mov ecx, [edi-twdw + WDATA.box.top] |
add ebx, eax |
add ecx, edx |
mov [img_screen_x], ebx ; abs Xleft |
; mov [img_screen_y], ecx ; ecx = abs Ytop ; hold it ! |
.check_x_size: |
mov ebx, [TASK_BASE-twdw + WDATA.box.width] |
mov ebx, [edi-twdw + WDATA.box.width] |
inc ebx ; ebx = window Xsize |
sub ebx, eax ; eax = rel Xleft |
jbe .finish ; image is out of the window |
374,7 → 415,7 |
@@: dec eax |
mov [img_pix_x], eax |
.check_y_size: |
mov ebx, [TASK_BASE-twdw + WDATA.box.height] |
mov ebx, [edi-twdw + WDATA.box.height] |
inc ebx ; ebx = real window y-size |
sub ebx, edx ; edx = rel Ytop |
jbe .finish ; image isn't visible |
396,6 → 437,9 |
mov bl, byte [img_bytes_per_pix] |
or bl, bl |
jnz @f |
mov ecx, [img_buf_line_size] |
or cl, cl |
je @f |
bts ebx, 25 |
@@: mov bl, byte [CURRENT_TASK] ; get process number |
mov ebp, ecx ; ecx = absY |
407,9 → 451,10 |
mov ecx, eax ; eax = absX |
shr ecx, 2 |
add eax, [img_pix_x] |
inc eax |
shr eax, 2 |
add eax, ebp |
mov [img_map_right], eax ; right edge tile |
; mov [img_map_right], eax ; right edge tile |
add ebp, ecx ; left edge Map origin |
mov ecx, [img_pix_y] |
sub eax, ebp |
422,8 → 467,8 |
; ebp -> corner tile position |
; ecx = [img_pix_y] = image height |
; bl = task # |
; ebx[24] = 1 if the core Y is odd |
; ebx[25] = 1bpp image |
; ebx[24] = 1 if Ytop is odd |
; ebx[25] = 1 if 1bpp image |
.start: |
bt ebx, 25 |
434,10 → 479,10 |
mov [img_edgeoffset], eax |
@@: |
mov edx, edi |
and edx, 0x0C |
mov dh, 0x0C |
and dl, dh |
jz .go_right ; left edge already aligned |
.left_edge: |
mov dh, 0x0C |
sub dh, dl |
movzx edx, dh |
call draw_unaligned_edge |
481,19 → 526,19 |
mov eax, [img_pix_x] |
shl eax, 2 ; 1 pix = 4 bytes |
add eax, edi ; rightEdge last pix (LFB addr) |
shl edx, 4 |
add edi, edx ; rightEdge Screen origin |
movzx edx, al |
mov eax, [img_map_x] |
and dl, 0x0C |
jz .core_block ; rightEdge is already tile-aligned |
and al, 0xF0 |
mov edi, eax ; rightEdge Screen origin |
cmp dl, 0x0C |
je .core_block ; rightEdge is already tile-aligned |
.right_edge: |
call draw_unaligned_edge |
dec [img_map_x] |
.core_block: |
pop ebp |
mov eax, [img_map_x] |
or eax, eax ; empty central core? |
jz .finish |
mov ebp, [esp] |
mov edi, [img_lfb_origin] |
mov esi, [img_buf_origin] |
500,7 → 545,7 |
call draw_aligned_box |
.finish: |
add esp, putimg.stack_data |
add esp, (putimg.stack_data + 4) |
; call [_display.enable_mouse] |
popad |
ret |
509,19 → 554,81 |
mov edx, [img_pix_x] |
shl edx, 2 ; edx = rightmost tile offset (0, 4, 8, or 12 bytes) |
call draw_unaligned_edge |
jmp .finish |
add esp, putimg.stack_data |
popad |
ret |
align 64 |
img_test_struct: |
dd 0x00112233, 0x00223344, 0x00334455, 0x00445566 |
dd 0x00223344, 0x00334455, 0x00445566, 0x00334455 |
dd 0x00334455, 0x00445566, 0x00334455, 0x00223344 |
dd 0x00445566, 0x00334455, 0x00223344, 0x00112233 |
;align 64 |
;img_test_struct_32: ; 8 x 10 |
; dd 0x112233, 0x223344, 0x334455, 0x445566, 0x556677, 0x667788, 0x778899, 0x887766 |
; dd 0x223344, 0x334455, 0x445566, 0x556677, 0x667788, 0x777799, 0x887766, 0x997755 |
; dd 0x334455, 0x445566, 0x556677, 0x667788, 0x777799, 0x887766, 0x997755, 0xAA7744 |
; dd 0x445566, 0x556677, 0x667788, 0x777799, 0x887766, 0x997755, 0xAA7744, 0xBB7733 |
; dd 0x334455, 0x445566, 0x556677, 0x667788, 0x777799, 0x887766, 0x997755, 0xAA7744 |
; dd 0x223344, 0x334455, 0x445566, 0x556677, 0x667788, 0x777799, 0x887766, 0x997755 |
; dd 0x112233, 0x223344, 0x334455, 0x445566, 0x556677, 0x667788, 0x777799, 0x887766 |
; dd 0x001122, 0x112233, 0x223344, 0x334455, 0x445566, 0x556677, 0x667788, 0x777799 |
; dd 0x220000, 0x001122, 0x112233, 0x223344, 0x334455, 0x445566, 0x556677, 0x667788 |
; dd 0x441100, 0x220000, 0x001122, 0x112233, 0x223344, 0x334455, 0x445566, 0x556677 |
;align 64 |
;img_test_struct_24: ; 8 x 16 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
; dw 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211, 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB |
; dw 0xBBAA, 0xAACC, 0xCCBB, 0xBBAA, 0xAACC, 0xCCBB, 0x1100, 0x0022, 0x2211, 0x1100, 0x0022, 0x2211 |
;align 64 |
;img_test_struct_8: ; 20 x 10 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
; db 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0 |
;align 64 |
;img_test_struct_1: ; 16 x 10 |
; db 0x0F, 0xF0 |
; db 0x0F, 0xF0 |
; db 0x3C, 0xC3 |
; db 0x3C, 0xC3 |
; db 0xF0, 0x0F |
; db 0xF0, 0x0F |
; db 0x3C, 0xC3 |
; db 0x3C, 0xC3 |
; db 0x0F, 0xF0 |
; db 0x0F, 0xF0 |
;align 64 |
;img_test_palette: ; 6 colors |
; dd 0x00BB2233, 0xAA4466, 0x995555, 0x00339966, 0x00884455, 0x00775566, 0x00664455, 0x00553344, 0x0 |
;************************************************************************************** |
align 4 |
__sys_putpixel: |
push edx |
mov edx, [TASK_BASE] |
add eax, [edx-twdw+WDATA.box.left] |
add ebx, [edx-twdw+WDATA.box.top] |
pop edx |
_putpixel: |
; eax = x coordinate |
539,14 → 646,13 |
.not_forced: |
push ebx eax |
shr eax, 1 |
shr eax, 1 |
shr eax, 2 |
shr ebx, 1 |
imul ebx, [_WinMapWidth] ; win_map (X size)/2 |
add ebx, eax |
mov al, byte [CURRENT_TASK] |
mov bl, byte [_WinMapAddress+ebx] |
cmp bl, al |
mov ah, byte [_WinMapAddress+ebx] |
cmp ah, al |
pop eax ebx |
jne .exit0 |
.checked: |
565,15 → 671,15 |
align 4 |
put_pixel: ; left for compatibility with 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 |
mov [LFB_BASE+edi], ecx |
ret |
;align 4 |
;_put_pixel: ; left for compatibility with 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 |
; mov [LFB_BASE+edi], ecx |
; ret |
; DRAWLINE |
748,7 → 854,7 |
mov ecx, [ebp] ; check the line segment (16 pixels!) |
xor ecx, [CURRENT_TASK] |
; -- the line --- |
jmp dword [hline.drawtable + edi*4] ; a coolhack (C) Serge |
jmp dword [hline.drawtable + edi*4] ; (C) Serge, 2010 |
align 4 ; internal loop |
885,236 → 991,71 |
;************************************************* |
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 |
; eax xOrigin |
; ebx yOrigin |
; ecx xSize |
; edx ySize |
; edi color |
vesa20_drawbar: |
_drawbar: |
pushad |
call [_display.disable_mouse] |
sub esp, drbar.stack_data |
mov [drbar.color], edi |
sub edx, ebx |
jle .exit |
sub ecx, eax |
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 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 |
; note that WDATA.box.width is one pixel less than real window x-size |
inc ebx |
sub ebx, [drbar.bar_cx] |
ja @f |
.exit: |
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 |
inc ebx |
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, [Screen_Max_X] |
sub eax, [drbar.real_sx] |
inc eax |
shr eax, 1 ; <<<<<< |
shr eax, 1 |
mov [drbar.line_inc_map], eax ; vertical increment: map |
; line_inc_scr |
mov eax, [drbar.real_sx] |
shl eax, 1 |
shl eax, 1 |
neg eax |
add eax, [BytesPerScanLine] |
mov [drbar.line_inc_scr], eax ; vertical increment: screen |
; pointer to screen |
mov edx, [drbar.abs_cy] |
mov ebx, edx |
imul edx, [BytesPerScanLine] ; edx = LFB line offset |
mov eax, [drbar.abs_cx] |
shl eax, 1 |
shl eax, 1 |
add edx, eax ; edx = LFB corner offset |
; pointer to pixel map |
shr ebx, 1 |
imul ebx, [_WinMapWidth] ; eax = Wmap corner pos |
mov eax, [drbar.abs_cx] |
shr eax, 1 |
shr eax, 1 |
add eax, ebx |
add eax, [_WinMapAddress] |
xchg eax, ebp ; ebp = Wmap corner |
; get process number |
mov ebx, [CURRENT_TASK] |
sub esp, putimg.stack_data |
mov [img_bytes_per_pix], 0 |
mov [img_buf_line_size], 0 |
mov [img_draw_core_fn], draw_core_0bpp |
mov [img_draw_edge_fn], draw_edge_0bpp |
mov [putimg.image_sx], ecx |
mov [putimg.image_sy], edx |
mov edx, ebx |
mov [img_palette], edi |
mov esi, img_palette |
mov [img_buf_origin], esi |
; eax - RGB-color |
; bl - process num |
; ecx - pix counter (in a tile) |
; edx - pointer to screen |
; esi - counter |
; edi - counter |
jmp _putimage.calculate_abs_coords |
; ret |
mov eax, [drbar.color] ;; BBGGRR00 |
mov esi, 0 |
align 4 |
.new_y: |
mov edi, [drbar.real_sx] |
movzx ecx, dl |
shr cl, 2 ; pix# = edx/4 |
and cl, 3 ; pix position in a tile |
.new_tile: |
cmp byte [ebp], bl |
jne .skip |
.new_x: |
mov [LFB_BASE+edx], eax |
add edx, 4 |
dec edi |
jz .add_line |
inc cl |
and cl, 3 |
jnz .new_x |
jmp .new_tile |
.skip: |
add edx, 4*4 |
and dl, 0xF0 ; LFB align 16 |
inc ebp |
sub edi, 4 ; <<<<< |
add edi, ecx ; left tile may be 1,2 or 3px only |
jae .new_tile |
.add_line: |
add edx, [drbar.line_inc_scr] |
; gradient-filled bars |
test eax, 0x80000000 |
jz @f |
test al, al |
jz @f |
dec al |
@@: |
inc esi |
test esi, 1 |
jne @f |
add ebp, [drbar.line_inc_map] |
@@: |
cmp esi, [drbar.real_sy] |
jbe .new_y |
add esp, drbar.stack_data |
popad |
xor eax, eax |
ret |
align 4 |
;drawbackground: |
call [_display.disable_mouse] |
draw_background: |
pushad |
; External loop for all y from start to end |
mov ebx, [draw_data+32+RECT.top] ; y start |
.fill_line: |
mov edi, [draw_data+32+RECT.left] ; x start |
shl edi, 1 |
shl edi, 1 |
mov eax, [BytesPerScanLine] |
mul ebx |
xchg edi, eax |
add edi, eax |
add edi, LFB_BASE |
mov ebp, ebx |
shr ebp, 1 |
imul ebp, [_WinMapWidth] |
mov edx, eax |
pushfd |
cld ; increment edi here! |
mov ebp, [_WinMapAddress] |
mov eax, 0x00337766 ; bgndcolor |
mov bl, 1 |
mov edx, [Screen_Max_X] |
shr edx, 1 |
shr edx, 1 |
add ebp, edx |
add ebp, [_WinMapAddress] |
xor edx, edx |
inc edx |
mov esi, 0x0336677 ; <<< RGB |
; eax = x, ebx = y (screen coordinates) |
; ecx - aux. var |
; edx = 1 |
; esi = 0RGB, edi -> output |
; ebp = offset in WinMapAddress |
.fill_tile: |
cmp [ebp], dl |
jnz .next_tile |
mov [edi], esi |
mov [edi+4], esi |
mov [edi+8], esi |
mov [edi+12],esi |
mov ecx, [BytesPerScanLine] |
mov [ecx+edi], esi |
mov [ecx+edi+4], esi |
mov [ecx+edi+8], esi |
mov [ecx+edi+12],esi |
.next_tile: |
add edi, 4*4 |
add ebp, edx |
add ax, 4 |
mov ecx, [draw_data+32+RECT.right] |
shr ecx, 1 |
shr ecx, 1 |
cmp eax, ecx |
jbe .fill_tile |
mov edi, LFB_BASE |
mov esi, [BytesPerScanLine] |
.new_row: |
xor ecx, ecx |
.fill: |
cmp byte [ebp+ecx], bl |
jne .next |
.next_line: |
inc ebx |
mov ecx, [draw_data+32+RECT.bottom] |
shr ecx, 1 |
jbe .fill_line |
mov [edi+esi], eax ; fill all 8 pixels of this tile |
stosd |
mov [edi+esi], eax |
stosd |
mov [edi+esi], eax |
stosd |
mov [edi+esi], eax |
stosd |
.next: inc ecx |
cmp ecx, [_WinMapWidth] |
jb .fill |
dec edx |
jz .done |
add ebp, ecx ; += [_WinMapWidth] |
add edi, esi ; += [BytesPerScanLine] |
jmp .new_row |
.done: |
popfd |
popad |
ret |
; ---------- |
drawbackground_stretch: ; left for future development |
call drawbackground |
ret |
1128,109 → 1069,27 |
bgr_next_line rd 1920 |
endg |
smooth_line: |
mov al, [esi+2] |
shl eax, 16 |
mov ax, [esi] |
test ecx, ecx |
jz @f |
mov ebx, [esi+2] |
shr ebx, 8 |
call [overlapping_of_points_ptr] |
@@: |
stosd |
mov eax, [esp+20+8] |
inc eax |
mov [esp+20+8], eax |
cmp eax, [draw_data+32+RECT.right] |
ja @f |
add ecx, [esp+36+8] |
mov eax, edx |
adc edx, [esp+40+8] |
sub eax, edx |
lea eax, [eax*3] |
sub esi, eax |
jmp smooth_line |
@@: |
mov eax, [draw_data+32+RECT.left] |
mov [esp+20+8], eax |
ret |
align 16 |
overlapping_of_points: |
push ecx edx |
mov edx, eax |
push esi |
shr ecx, 26 |
mov esi, ecx |
mov ecx, ebx |
shl esi, 9 |
movzx ebx, dl |
movzx eax, cl |
sub eax, ebx |
movzx ebx, dh |
add dl, [BgrAuxTable+(eax+0x100)+esi] |
movzx eax, ch |
sub eax, ebx |
add dh, [BgrAuxTable+(eax+0x100)+esi] |
ror ecx, 16 |
ror edx, 16 |
movzx eax, cl |
movzx ebx, dl |
sub eax, ebx |
add dl, [BgrAuxTable+(eax+0x100)+esi] |
pop esi |
mov eax, edx |
pop edx |
ror eax, 16 |
pop ecx |
_init_background: |
; mov edi, BgrAuxTable |
; xor edx, edx |
;.loop2: |
; mov eax, edx |
; shl eax, 8 |
; neg eax |
; mov ecx, 0x200 |
;.loop1: |
; mov byte [edi], ah |
; inc edi |
; add eax, edx |
; loop .loop1 |
; add dl, 4 |
; jnz .loop2 |
mov byte [REDRAW_BACKGROUND], 1 |
; mov dword[BgrAuxTable], 0x00337766 |
ret |
iglobal |
align 4 |
overlapping_of_points_ptr dd overlapping_of_points |
endg |
init_background: |
mov edi, BgrAuxTable |
xor edx, edx |
.loop2: |
mov eax, edx |
shl eax, 8 |
neg eax |
mov ecx, 0x200 |
.loop1: |
mov byte [edi], ah |
inc edi |
add eax, edx |
loop .loop1 |
add dl, 4 |
jnz .loop2 |
test byte [cpu_caps+(CAPS_MMX/8)], 1 shl (CAPS_MMX mod 8) |
jz @f |
mov [overlapping_of_points_ptr], overlapping_of_points_mmx |
@@: |
ret |
align 16 |
overlapping_of_points_mmx: |
movd mm0, eax |
movd mm4, eax |
movd mm1, ebx |
pxor mm2, mm2 |
punpcklbw mm0, mm2 |
punpcklbw mm1, mm2 |
psubw mm1, mm0 |
movd mm3, ecx |
psrld mm3, 24 |
packuswb mm3, mm3 |
packuswb mm3, mm3 |
pmullw mm1, mm3 |
psrlw mm1, 8 |
packuswb mm1, mm2 |
paddb mm4, mm1 |
movd eax, mm4 |
ret |
diff16 "GRAPH32 code end ",0,$ |
diff10 "GRAPH32 code size",get_pixel,$ |