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

Rev	Author	Line No.	Line
425	victor	1	$Revision: 473 $
431	serge	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		3	;; ;;
		4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
		5	;; Distributed under terms of the GNU General Public License ;;
		6	;; ;;
		7	;; VESA20.INC ;;
		8	;; ;;
		9	;; Vesa 2.0 functions for MenuetOS ;;
		10	;; ;;
		11	;; Copyright 2002 Ville Turjanmaa ;;
		12	;; Alexey, kgaz@crosswindws.net ;;
		13	;; - Voodoo compatible graphics ;;
		14	;; Juan M. Caravaca ;;
		15	;; - Graphics optimimizations eg. drawline ;;
		16	;; ;;
		17	;; See file COPYING for details ;;
		18	;; ;;
		19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1	ha	20
		21	; If you're planning to write your own video driver I suggest
		22	; you replace the VESA12.INC file and see those instructions.
		23
381	serge	24	;ScreenWidth equ 0xfe00
		25	;ScreenHeight equ 0xfe04
		26	;BytesPerScanLine equ 0xfe08
		27	;LFBAddress equ 0xfe80
		28	;ScreenBPP equ 0xfbf1
		29	;WinMapAddress equ 0x460000
1	ha	30
		31
		32
		33	;*************************************************
		34	; getpixel
		35	;
		36	; in:
		37	; eax = x coordinate
		38	; ebx = y coordinate
		39	;
		40	; ret:
		41	; ecx = 00 RR GG BB
		42
		43	getpixel:
469	serge	44	push eax ebx edx edi
		45	call dword [GETPIXEL]
		46	pop edi edx ebx eax
		47	ret
1	ha	48
		49	Vesa20_getpixel24:
469	serge	50	; eax = x
		51	; ebx = y
		52	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
		53	lea edi, [eax+eax2] ; edi = x3
		54	add edi, ebx ; edi = x3+(yy multiplier)
		55	add edi, [LFBAddress] ; ebx = where pixel is in memory
		56	mov ecx, [edi]
		57	and ecx, 0xffffff
		58	ret
1	ha	59
		60	Vesa20_getpixel32:
469	serge	61	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
		62	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
		63	add edi, [LFBAddress] ; ebx = where pixel is in memory
		64	mov ecx, [edi]
		65	and ecx, 0xffffff
		66	ret
1	ha	67
		68	;*************************************************
		69
		70	virtual at esp
		71	putimg:
		72	.real_sx dd ?
		73	.real_sy dd ?
		74	.image_sx dd ?
		75	.image_sy dd ?
		76	.image_cx dd ?
		77	.image_cy dd ?
		78	.pti dd ?
		79	.abs_cx dd ?
		80	.abs_cy dd ?
		81	.line_increment dd ?
		82	.winmap_newline dd ?
		83	.screen_newline dd ?
283	diamond	84	.stack_data = 4*12
		85	.edi dd ?
		86	.esi dd ?
		87	.ebp dd ?
314	diamond	88	.esp dd ?
		89	.ebx dd ?
		90	.edx dd ?
		91	.ecx dd ?
		92	.eax dd ?
		93	.ret_addr dd ?
		94	.arg_0 dd ?
1	ha	95	end virtual
		96
283	diamond	97	align 16
1	ha	98	; ebx = pointer
		99	; ecx = size [x\|y]
		100	; edx = coordinates [x\|y]
283	diamond	101	; ebp = pointer to 'get' function
		102	; esi = pointer to 'init' function
		103	; edi = parameter for 'get' function
469	serge	104
1	ha	105	vesa20_putimage:
469	serge	106	pushad
		107	call [disable_mouse]
		108	sub esp, putimg.stack_data
		109	; save pointer to image
		110	mov [putimg.pti], ebx
		111	; unpack the size
		112	mov eax, ecx
		113	and ecx, 0xFFFF
		114	shr eax, 16
		115	mov [putimg.image_sx], eax
		116	mov [putimg.image_sy], ecx
		117	; unpack the coordinates
		118	mov eax, edx
		119	and edx, 0xFFFF
		120	shr eax, 16
		121	mov [putimg.image_cx], eax
		122	mov [putimg.image_cy], edx
		123	; calculate absolute (i.e. screen) coordinates
		124	mov eax, [TASK_BASE]
		125	mov ebx, [eax-twdw + WDATA.box.left]
		126	add ebx, [putimg.image_cx]
		127	mov [putimg.abs_cx], ebx
		128	mov ebx, [eax-twdw + WDATA.box.top]
		129	add ebx, [putimg.image_cy]
		130	mov [putimg.abs_cy], ebx
		131	; real_sx = MIN(wnd_sx-image_cx, image_sx);
		132	mov ebx, [eax-twdw + WDATA.box.width] ; ebx = wnd_sx
133	diamond	133	; \begin{diamond}[20.08.2006]
		134	; note that WDATA.box.width is one pixel less than real window x-size
469	serge	135	inc ebx
133	diamond	136	; \end{diamond}[20.08.2006]
469	serge	137	sub ebx, [putimg.image_cx]
		138	ja @f
		139	add esp, putimg.stack_data
		140	popad
		141	ret
		142	@@:
		143	cmp ebx, [putimg.image_sx]
		144	jbe .end_x
		145	mov ebx, [putimg.image_sx]
		146	.end_x:
		147	mov [putimg.real_sx], ebx
		148	; init real_sy
		149	mov ebx, [eax-twdw + WDATA.box.height] ; ebx = wnd_sy
133	diamond	150	; \begin{diamond}[20.08.2006]
469	serge	151	inc ebx
133	diamond	152	; \end{diamond}[20.08.2006]
469	serge	153	sub ebx, [putimg.image_cy]
		154	ja @f
		155	add esp, putimg.stack_data
		156	popad
		157	ret
		158	@@:
		159	cmp ebx, [putimg.image_sy]
		160	jbe .end_y
		161	mov ebx, [putimg.image_sy]
		162	.end_y:
		163	mov [putimg.real_sy], ebx
		164	; line increment
		165	mov eax, [putimg.image_sx]
		166	sub eax, [putimg.real_sx]
		167	;; imul eax, [putimg.source_bpp]
		168	; lea eax, [eax + eax * 2]
		169	call esi
		170	add eax, [putimg.arg_0]
		171	mov [putimg.line_increment], eax
		172	; winmap new line increment
		173	mov eax, [ScreenWidth]
		174	inc eax
		175	sub eax, [putimg.real_sx]
		176	mov [putimg.winmap_newline], eax
		177	; screen new line increment
		178	mov eax, [BytesPerScanLine]
		179	mov ecx, [putimg.real_sx]
		180	movzx ebx, byte [ScreenBPP]
		181	shr ebx, 3
		182	imul ecx, ebx
		183	sub eax, ecx
		184	mov [putimg.screen_newline], eax
		185	; pointer to image
		186	mov esi, [putimg.pti]
		187	; pointer to screen
		188	mov edx, [putimg.abs_cy]
		189	imul edx, [BytesPerScanLine]
		190	mov eax, [putimg.abs_cx]
		191	movzx ebx, byte [ScreenBPP]
		192	shr ebx, 3
		193	imul eax, ebx
		194	add edx, eax
		195	add edx, [LFBAddress]
		196	; pointer to pixel map
		197	mov eax, [putimg.abs_cy]
		198	imul eax, [ScreenWidth]
		199	add eax, [putimg.abs_cy]
		200	add eax, [putimg.abs_cx]
		201	add eax, WinMapAddress
		202	xchg eax, ebp
		203	; get process number
		204	mov ebx, [CURRENT_TASK]
		205	cmp byte [ScreenBPP], 32
		206	je put_image_end_32
1	ha	207	;put_image_end_24:
469	serge	208	mov edi, [putimg.real_sy]
		209	align 4
		210	.new_line:
		211	mov ecx, [putimg.real_sx]
		212	; push ebp edx
		213	align 4
		214	.new_x:
		215	push [putimg.edi]
		216	mov eax, [putimg.ebp+4]
		217	call eax
		218	cmp [ebp], bl
		219	jne .skip
		220	; mov eax, [esi] ; eax = RRBBGGRR
		221	mov [edx], ax
		222	shr eax, 16
		223	mov [edx+2], al
		224	.skip:
		225	; add esi, 3 ;[putimg.source_bpp]
		226	add edx, 3
		227	inc ebp
		228	dec ecx
		229	jnz .new_x
		230	; pop edx ebp
		231	add esi, [putimg.line_increment]
		232	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
		233	add ebp, [putimg.winmap_newline] ;[ScreenWidth]
		234	; inc ebp
		235	dec edi
		236	jnz .new_line
		237	.finish:
		238	add esp, putimg.stack_data
		239	popad
		240	ret
1	ha	241
		242	put_image_end_32:
469	serge	243	mov edi, [putimg.real_sy]
		244	align 4
		245	.new_line:
		246	mov ecx, [putimg.real_sx]
		247	; push ebp edx
		248	align 4
		249	.new_x:
		250	push [putimg.edi]
		251	mov eax, [putimg.ebp+4]
		252	call eax
		253	cmp [ebp], bl
		254	jne .skip
		255	; mov eax, [esi] ; ecx = RRBBGGRR
		256	mov [edx], eax
		257	.skip:
		258	; add esi, [putimg.source_bpp]
		259	add edx, 4
		260	inc ebp
		261	dec ecx
		262	jnz .new_x
		263	; pop edx ebp
		264	add esi, [putimg.line_increment]
		265	add edx, [putimg.screen_newline] ;[BytesPerScanLine]
		266	add ebp, [putimg.winmap_newline] ;[ScreenWidth]
		267	; inc ebp
		268	dec edi
		269	jnz .new_line
		270	.finish:
		271	add esp, putimg.stack_data
		272	popad
		273	call VGA__putimage
		274	mov [EGA_counter],1
		275	ret
1	ha	276
		277
		278	;*************************************************
		279	align 4
		280	__sys_putpixel:
		281
		282	; eax = x coordinate
		283	; ebx = y coordinate
		284	; ecx = ?? RR GG BB ; 0x01000000 negation
		285	; edi = 0x00000001 force
		286
		287	;;; mov [novesachecksum], dword 0
469	serge	288	pushad
		289	test edi,1 ; force ?
		290	jnz .forced
		291	; not forced:
		292	push ecx ; save 24th bit in case negative pixel wanted
		293	call checkpixel
		294	test ecx,ecx
		295	pop ecx
		296	jnz .exit
		297	.forced:
		298	cmp [ScreenWidth], eax
		299	jb .exit
		300	cmp [ScreenHeight], ebx
		301	jb .exit
		302	.ok:
		303	; check if negation
		304	test ecx,0x01000000
		305	jz .noneg
		306	call getpixel
		307	not ecx
		308	mov [esp+32-8],ecx
		309	.noneg:
		310	; OK to set pixel
		311	call dword [PUTPIXEL] ; call the real put_pixel function
		312	.exit:
		313	popad
		314	ret
1	ha	315
		316	align 4
		317	Vesa20_putpixel24:
469	serge	318	; eax = x
		319	; ebx = y
		320	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
		321	lea edi, [eax+eax2] ; edi = x3
		322	mov eax, [esp+32-8+4]
		323	add edi, [LFBAddress]
		324	add edi, ebx ; ebx = where to put pixel in memory
		325	mov [edi], ax
		326	shr eax, 16
		327	mov [edi+2], al
		328	ret
1	ha	329
		330
		331	align 4
		332	Vesa20_putpixel32:
469	serge	333	; eax = x
		334	; ebx = y
		335	imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
		336	lea edi, [ebx+eax4] ; edi = x4+(y*y multiplier)
		337	mov eax, [esp+32-8+4] ; eax = color
		338	add edi, [LFBAddress] ; ebx = where to put pixel in memory
		339	mov [edi], eax
		340	ret
1	ha	341
		342	;*************************************************
		343
		344	;align 4
		345	calculate_edi:
469	serge	346	mov edi, ebx
		347	imul edi, [ScreenWidth]
		348	add edi, ebx
		349	add edi, eax
		350	ret
1	ha	351
		352	;*************************************************
		353
		354	; DRAWLINE
		355
		356	align 4
		357	__sys_draw_line:
36	mario79	358	; inc [mouse_pause]
469	serge	359	call [disable_mouse]
1	ha	360
		361	; draw a line
		362	; eax = HIWORD = x1
		363	; LOWORD = x2
		364	; ebx = HIWORD = y1
		365	; LOWORD = y2
		366	; ecx = color
		367	; edi = force ?
		368	pusha
		369
		370	dl_x1 equ esp+20
		371	dl_y1 equ esp+16
		372	dl_x2 equ esp+12
		373	dl_y2 equ esp+8
		374	dl_dx equ esp+4
		375	dl_dy equ esp+0
		376
469	serge	377	xor edx, edx ; clear edx
		378	xor esi, esi ; unpack arguments
		379	xor ebp, ebp
		380	mov si, ax ; esi = x2
		381	mov bp, bx ; ebp = y2
		382	shr eax, 16 ; eax = x1
		383	shr ebx, 16 ; ebx = y1
		384	push eax ; save x1
		385	push ebx ; save y1
		386	push esi ; save x2
		387	push ebp ; save y2
		388	; checking x-axis...
		389	sub esi, eax ; esi = x2-x1
		390	push esi ; save y2-y1
		391	jl .x2lx1 ; is x2 less than x1 ?
		392	jg .no_vline ; x1 > x2 ?
		393	mov edx, ebp ; else (if x1=x2)
		394	call vline
		395	push edx ; necessary to rightly restore stack frame at .exit
		396	jmp .exit
1	ha	397	.x2lx1:
469	serge	398	neg esi ; get esi absolute value
1	ha	399	.no_vline:
469	serge	400	; checking y-axis...
		401	sub ebp, ebx ; ebp = y2-y1
		402	push ebp ; save y2-y1
		403	jl .y2ly1 ; is y2 less than y1 ?
		404	jg .no_hline ; y1 > y2 ?
		405	mov edx, [dl_x2] ; else (if y1=y2)
		406	call hline
		407	jmp .exit
1	ha	408
		409	.y2ly1:
469	serge	410	neg ebp ; get ebp absolute value
1	ha	411	.no_hline:
469	serge	412	cmp ebp, esi
		413	jle .x_rules ; \|y2-y1\| < \|x2-x1\| ?
		414	cmp [dl_y2], ebx ; make sure y1 is at the begining
		415	jge .no_reverse1
		416	neg dword [dl_dx]
		417	mov edx, [dl_x2]
		418	mov [dl_x2], eax
		419	mov [dl_x1], edx
		420	mov edx, [dl_y2]
		421	mov [dl_y2], ebx
		422	mov [dl_y1], edx
1	ha	423	.no_reverse1:
469	serge	424	mov eax, [dl_dx]
		425	cdq ; extend eax sing to edx
		426	shl eax, 16 ; using 16bit fix-point maths
		427	idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)
		428	mov edx, ebp ; edx = counter (number of pixels to draw)
		429	mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0
		430	mov esi, eax ; esi = dx
		431	jmp .y_rules
1	ha	432
		433	.x_rules:
469	serge	434	cmp [dl_x2], eax ; make sure x1 is at the begining
		435	jge .no_reverse2
		436	neg dword [dl_dy]
		437	mov edx, [dl_x2]
		438	mov [dl_x2], eax
		439	mov [dl_x1], edx
		440	mov edx, [dl_y2]
		441	mov [dl_y2], ebx
		442	mov [dl_y1], edx
1	ha	443	.no_reverse2:
469	serge	444	xor edx, edx
		445	mov eax, [dl_dy]
		446	cdq ; extend eax sing to edx
		447	shl eax, 16 ; using 16bit fix-point maths
		448	idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)
		449	mov edx, esi ; edx = counter (number of pixels to draw)
		450	mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0
		451	mov ebp, eax ; ebp = dy
1	ha	452	.y_rules:
469	serge	453	mov eax, [dl_x1]
		454	mov ebx, [dl_y1]
		455	shl eax, 16
		456	shl ebx, 16
1	ha	457	align 4
		458	.draw:
469	serge	459	push eax ebx
		460	shr eax, 16
		461	shr ebx, 16
		462	call [putpixel]
		463	pop ebx eax
		464	add ebx, ebp ; y = y+dy
		465	add eax, esi ; x = x+dx
		466	dec edx
		467	jnz .draw
		468	; force last drawn pixel to be at (x2,y2)
		469	mov eax, [dl_x2]
		470	mov ebx, [dl_y2]
		471	call [putpixel]
1	ha	472	.exit:
469	serge	473	add esp, 6*4
		474	popa
36	mario79	475	; dec [mouse_pause]
		476	call [draw_pointer]
469	serge	477	ret
1	ha	478
		479
		480	hline:
		481	; draw an horizontal line
		482	; eax = x1
		483	; edx = x2
		484	; ebx = y
		485	; ecx = color
		486	; edi = force ?
469	serge	487	push eax edx
		488	cmp edx, eax ; make sure x2 is above x1
		489	jge @f
		490	xchg eax, edx
		491	align 4
		492	@@:
		493	call [putpixel]
		494	inc eax
		495	cmp eax, edx
		496	jle @b
		497	pop edx eax
		498	ret
1	ha	499
		500
		501	vline:
		502	; draw a vertical line
		503	; eax = x
		504	; ebx = y1
		505	; edx = y2
		506	; ecx = color
		507	; edi = force ?
469	serge	508	push ebx edx
		509	cmp edx, ebx ; make sure y2 is above y1
		510	jge @f
		511	xchg ebx, edx
		512	align 4
		513	@@:
		514	call [putpixel]
		515	inc ebx
		516	cmp ebx, edx
		517	jle @b
		518	pop edx ebx
		519	ret
1	ha	520
		521
		522	;*************************************************
		523
		524
		525	virtual at esp
469	serge	526	drbar:
		527	.bar_sx dd ?
		528	.bar_sy dd ?
		529	.bar_cx dd ?
		530	.bar_cy dd ?
		531	.abs_cx dd ?
		532	.abs_cy dd ?
		533	.real_sx dd ?
		534	.real_sy dd ?
		535	.color dd ?
		536	.line_inc_scr dd ?
		537	.line_inc_map dd ?
		538	.stack_data = 4*11
1	ha	539	end virtual
		540
		541	align 4
		542	; eax cx
		543	; ebx cy
		544	; ecx xe
		545	; edx ye
		546	; edi color
		547	vesa20_drawbar:
469	serge	548	pushad
		549	call [disable_mouse]
		550	sub esp, drbar.stack_data
		551	mov [drbar.color], edi
		552	sub edx, ebx
		553	jle .exit ;// mike.dld, 2005-01-29
		554	sub ecx, eax
		555	jle .exit ;// mike.dld, 2005-01-29
		556	mov [drbar.bar_sy], edx
		557	mov [drbar.bar_sx], ecx
		558	mov [drbar.bar_cx], eax
		559	mov [drbar.bar_cy], ebx
		560	mov edi, [TASK_BASE]
		561	add eax, [edi-twdw + WDATA.box.left] ; win_cx
		562	add ebx, [edi-twdw + WDATA.box.top] ; win_cy
		563	mov [drbar.abs_cx], eax
		564	mov [drbar.abs_cy], ebx
		565	; real_sx = MIN(wnd_sx-bar_cx, bar_sx);
		566	mov ebx, [edi-twdw + WDATA.box.width] ; ebx = wnd_sx
133	diamond	567	; \begin{diamond}[20.08.2006]
		568	; note that WDATA.box.width is one pixel less than real window x-size
469	serge	569	inc ebx
133	diamond	570	; \end{diamond}[20.08.2006]
469	serge	571	sub ebx, [drbar.bar_cx]
		572	ja @f
		573	.exit: ;// mike.dld, 2005-01-29
		574	add esp, drbar.stack_data
		575	popad
		576	xor eax, eax
		577	inc eax
		578	ret
		579	@@:
		580	cmp ebx, [drbar.bar_sx]
		581	jbe .end_x
		582	mov ebx, [drbar.bar_sx]
		583	.end_x:
		584	mov [drbar.real_sx], ebx
		585	; real_sy = MIN(wnd_sy-bar_cy, bar_sy);
		586	mov ebx, [edi-twdw + WDATA.box.height] ; ebx = wnd_sy
133	diamond	587	; \begin{diamond}[20.08.2006]
469	serge	588	inc ebx
133	diamond	589	; \end{diamond}
469	serge	590	sub ebx, [drbar.bar_cy]
		591	ja @f
		592	add esp, drbar.stack_data
		593	popad
		594	xor eax, eax
		595	inc eax
		596	ret
		597	@@:
		598	cmp ebx, [drbar.bar_sy]
		599	jbe .end_y
		600	mov ebx, [drbar.bar_sy]
		601	.end_y:
		602	mov [drbar.real_sy], ebx
		603	; line_inc_map
		604	mov eax, [ScreenWidth]
		605	sub eax, [drbar.real_sx]
		606	inc eax
		607	mov [drbar.line_inc_map], eax
		608	; line_inc_scr
		609	mov eax, [drbar.real_sx]
		610	movzx ebx, byte [ScreenBPP]
		611	shr ebx, 3
		612	imul eax, ebx
		613	neg eax
		614	add eax, [BytesPerScanLine]
		615	mov [drbar.line_inc_scr], eax
		616	; pointer to screen
		617	mov edx, [drbar.abs_cy]
		618	imul edx, [BytesPerScanLine]
		619	mov eax, [drbar.abs_cx]
		620	; movzx ebx, byte [ScreenBPP]
		621	; shr ebx, 3
		622	imul eax, ebx
		623	add edx, eax
		624	add edx, [LFBAddress]
		625	; pointer to pixel map
		626	mov eax, [drbar.abs_cy]
		627	imul eax, [ScreenWidth]
		628	add eax, [drbar.abs_cy]
		629	add eax, [drbar.abs_cx]
		630	add eax, WinMapAddress
		631	xchg eax, ebp
		632	; get process number
		633	mov ebx, [CURRENT_TASK]
		634	cmp byte [ScreenBPP], 24
		635	jne draw_bar_end_32
1	ha	636	draw_bar_end_24:
469	serge	637	mov eax, [drbar.color] ;; BBGGRR00
		638	mov bh, al ;; bh = BB
		639	shr eax, 8 ;; eax = RRGG
1	ha	640	; eax - color high RRGG
		641	; bl - process num
		642	; bh - color low BB
		643	; ecx - temp
		644	; edx - pointer to screen
		645	; esi - counter
		646	; edi - counter
469	serge	647	mov esi, [drbar.real_sy]
		648	align 4
		649	.new_y:
		650	mov edi, [drbar.real_sx]
		651	align 4
		652	.new_x:
		653	cmp byte [ebp], bl
		654	jne .skip
		655	mov [edx], bh
		656	mov [edx + 1], ax
		657	.skip:
		658	; add pixel
		659	add edx, 3
		660	inc ebp
		661	dec edi
		662	jnz .new_x
		663	; add line
		664	add edx, [drbar.line_inc_scr]
		665	add ebp, [drbar.line_inc_map]
		666	; drawing gradient bars
		667	test eax, 0x00800000
		668	jz @f
		669	test bh, bh
		670	jz @f
		671	dec bh
		672	@@:
		673	;
		674	dec esi
		675	jnz .new_y
		676	add esp, drbar.stack_data
		677	popad
		678	xor eax, eax
		679	ret
1	ha	680
		681	draw_bar_end_32:
469	serge	682	mov eax, [drbar.color] ;; BBGGRR00
		683	mov esi, [drbar.real_sy]
		684	align 4
		685	.new_y:
		686	mov edi, [drbar.real_sx]
		687	align 4
		688	.new_x:
		689	cmp byte [ebp], bl
		690	jne .skip
		691	mov [edx], eax
		692	.skip:
		693	; add pixel
		694	add edx, 4
		695	inc ebp
		696	dec edi
		697	jnz .new_x
		698	; add line
		699	add edx, [drbar.line_inc_scr]
		700	add ebp, [drbar.line_inc_map]
		701	; drawing gradient bars
		702	test eax, 0x80000000
		703	jz @f
		704	test al, al
		705	jz @f
		706	dec al
		707	@@:
		708	;
		709	dec esi
		710	jnz .new_y
		711	add esp, drbar.stack_data
		712	popad
		713	call VGA_draw_bar
		714	xor eax, eax
		715	mov [EGA_counter],1
		716	ret
1	ha	717
		718	;voodoodbcplimit:
		719
		720	; ebp:=(y+Ywin)*(ScreenXSize+1)+(x+Xwin)+AddrBuffer
		721
		722
		723	; pusha
		724
		725	; xor edx,edx
		726	; mov eax,ebp
		727	; mov ebx,[ScreenWidth] ; Screen_X_size
		728	; inc ebx ; +1
		729	; sub eax,WinMapAddress ; -AddrBuffer
		730	; div ebx ;
		731	; mov ebx,eax ; ebx:=Y
		732	; mov eax,edx ; eax:=X
		733	; call cplimit
		734
		735	; test ecx,ecx
		736	; jne dbcpl12
		737	; popa
		738	; clc
		739	; ret
		740	; dbcpl12:
		741	; popa
		742	; stc
		743	; ret
		744
		745
		746
		747
		748	;dbcplimit:
		749
		750	; pusha
		751
		752	; xor edx,edx
		753	; mov ebx,[ScreenWidth]
		754	; inc ebx
		755	; sub eax,WinMapAddress
		756	; div ebx
		757	; mov ebx,eax
		758	; mov eax,edx
		759	; call cplimit
		760
		761	; test ecx,ecx
		762	; jne dbcpl1
		763	; popa
		764	; clc
		765	; ret
		766	; dbcpl1:
		767	; popa
		768	; stc
		769	; ret
		770
		771
		772
		773
		774
		775
		776	;--------------vbe voodoo ------------------------------------------------
		777	vesa20_drawbackground_tiled:
		778	call [disable_mouse]
		779	push ebp
		780	push eax
		781	push ebx
		782	push ecx
		783	push edx
		784	mov edx,dword [WinMapAddress-8] ; B
		785	add edx,dword [WinMapAddress-8] ; +B
		786	add edx,dword [WinMapAddress-8] ; +B
		787	push edx
115	poddubny	788	mov ebp,[draw_data+32+RECT.left] ; x start:=(x+Xwin)
		789	mov ebx,[draw_data+32+RECT.top] ; y start:=(y+Ywin)
1	ha	790	mov eax,[BytesPerScanLine]
		791	mul ebx
		792	xchg ebp, eax ; BytesPerScanLine*(Ywin+y)
		793	add ebp, eax ; +X
		794	add ebp, eax ; +X
		795	add ebp, eax ; +X
		796	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		797	jz @f
		798	add ebp,eax ; +X
469	serge	799	@@:
1	ha	800	add ebp,[LFBAddress] ; +LFB
469	serge	801	; ebp:=YBytesPerScanLine+XBytesPerPixel+AddrLFB
1	ha	802	call calculate_edi
469	serge	803	dp3: ; MAIN LOOP
1	ha	804	cmp [edi+WinMapAddress],byte 1 ; ptrBuffer^<>byte(1)
		805	jne nbgp
		806	push eax
		807	push ebx
		808	mov ecx,dword [WinMapAddress-8] ; B
		809	xor edx,edx ; edx:=0
		810	div ecx ; Xstart/B
469	serge	811	; eax=Int(qn) edx:=Rem
1	ha	812	lea esi,[edx+edx2] ; esi:=edx3
		813	mov ecx,dword [WinMapAddress-4] ; ecx:=H
		814	mov eax,[esp+0] ; eax:=Ystart
		815	xor edx,edx ;
		816	div ecx ; Ystart/H
		817	mov eax,edx ; eax:=Rem
		818	xor edx,edx ;
		819	mov ebx,[esp+8] ; ebx:=B*3
		820	mul ebx ;
		821	add esi,eax ;
469	serge	822	; mov eax,[esi+IMG_BACKGROUND]
		823	mov eax,[img_background]
		824	mov eax,[esi+eax]
1	ha	825	and eax,0xffffff
		826	xchg edi, ebp
		827	stosw
		828	shr eax,16
		829	stosb
		830	xchg ebp, edi ; ebp+=3
		831	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		832	jz @f
		833	inc ebp ; +1
469	serge	834	@@:
1	ha	835	pop ebx
		836	pop eax
		837	jmp hook1
469	serge	838	nbgp:
1	ha	839	add ebp,3 ; +3
		840	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		841	jz @f
		842	inc ebp ; +1
469	serge	843	@@:
		844	hook1:
1	ha	845	inc edi ; ptrBuffer++
		846	add esi,3 ; ptrImage+=3
		847	inc eax
115	poddubny	848	cmp eax,[draw_data+32+RECT.right] ; X > xend?
1	ha	849	jle dp3
115	poddubny	850	mov ebp,[draw_data+32+RECT.left]
1	ha	851	inc ebx
		852	mov eax,[BytesPerScanLine]
		853	mul ebx
		854	xchg ebp, eax ; BytesPerScanLine*(Ywin+y)
		855	add ebp, eax ; +X
		856	add ebp, eax ; +X=X*2
		857	add ebp, eax ; +X=X*3
		858	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		859	jz @f
		860	add ebp,eax ; +X=X*4
469	serge	861	@@:
1	ha	862	add ebp,[LFBAddress] ; +LFB
469	serge	863	; ebp:=YBytesPerScanLine+XBytesPerPixel+AddrLFB
1	ha	864	call calculate_edi
115	poddubny	865	cmp ebx,[draw_data+32+RECT.bottom]
1	ha	866	jle dp3
		867	add esp,4
		868	pop edx
		869	pop ecx
		870	pop ebx
		871	pop eax
		872	pop ebp
117	mario79	873	mov [EGA_counter],1
		874	call VGA_drawbackground
1	ha	875	ret
		876
		877	; ----------
		878
		879
		880	vesa20_drawbackground_stretch:
		881	call [disable_mouse]
		882	push ebp
		883	push eax
		884	push ebx
		885	push ecx
		886	push edx
		887	mov edx,dword [WinMapAddress-8] ; B
		888	add edx,dword [WinMapAddress-8] ; +B
		889	add edx,dword [WinMapAddress-8] ; +B
		890	push edx
115	poddubny	891	mov ebp,[draw_data+32+RECT.left] ; x start:=(x+Xwin)
		892	mov ebx,[draw_data+32+RECT.top] ; y start:=(y+Ywin)
1	ha	893	mov eax,[BytesPerScanLine]
		894	mul ebx
		895	xchg ebp, eax ; BytesPerScanLine*(Ywin+y)
		896	add ebp, eax ; +X
		897	add ebp, eax ; +X
		898	add ebp, eax ; +X
		899	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		900	jz @f
		901	add ebp,eax ; +X
469	serge	902	@@:
1	ha	903	add ebp,[LFBAddress] ; +LFB
469	serge	904	; ebp:=YBytesPerScanLine+XBytesPerPixel+AddrLFB
		905	call calculate_edi
1	ha	906
469	serge	907	sdp3: ; MAIN LOOP
		908	cmp [edi+WinMapAddress],byte 1 ; ptrBuffer^<>byte(1)
		909	jne snbgp
		910	push eax
		911	push ebx
		912	mov eax,dword [WinMapAddress-8]
		913	imul eax, [esp+4] ;4
		914	xor edx,edx
		915	mov ebx,[ScreenWidth]
		916	div ebx
		917	mov cx,dx
		918	lea esi,[eax+eax*2]
		919	mov eax,dword [WinMapAddress-4]
		920	imul eax, [esp+0] ;0
		921	xor edx,edx
		922	mov ebx,[ScreenHeight]
		923	div ebx
		924	shl ecx,16
		925	mov cx,dx
		926	imul eax, [esp+8] ;8
		927	add esi,eax
		928	; mov eax,[esi+IMG_BACKGROUND]
		929	mov eax,[img_background]
1	ha	930
469	serge	931	push eax
		932	mov eax,[display_data-4]
		933	imul eax,[display_data-8]
		934	imul eax,3
		935	sub eax,3
		936	cmp eax,esi
		937	pop eax
		938	jbe @f
1	ha	939
469	serge	940	mov eax,[esi+eax]
		941	@@:
		942	push eax
		943	ror ecx,16
		944	xor eax,eax
		945	mov ax,cx
		946	shl eax,1 ; �� 2
		947	lea eax,[eax+eax*4] ; �� 5
		948	xor edx,edx
		949	mov ebx,[ScreenWidth]
		950	div ebx
		951	cmp eax,5
		952	pop eax
		953	jb @f
		954	; mov ebx,[esi+IMG_BACKGROUND+3]
		955	mov ebx,[img_background]
1	ha	956
469	serge	957	push eax
		958	mov eax,[display_data-4]
		959	imul eax,[display_data-8]
		960	imul eax,3
		961	sub eax,3
		962	cmp eax,esi
		963	pop eax
		964	jbe @f
		965
		966	mov ebx,[esi+ebx+3]
		967
		968	call overlapping_of_points
379	serge	969	@@:
469	serge	970	push eax
		971	ror ecx,16
		972	xor eax,eax
		973	mov ax,cx
		974	shl eax,1 ; �� 2
		975	lea eax,[eax+eax*4] ; ��
		976	xor edx,edx
		977	mov ebx,[ScreenHeight]
		978	div ebx
		979	cmp eax,5
		980	pop eax
		981	jb @f
		982	mov ebx,[display_data-8]
		983	shl ebx,1
		984	add ebx,[display_data-8]
		985	add ebx,[img_background] ;IMG_BACKGROUND
		986
		987	push eax
		988	mov eax,[display_data-4]
		989	imul eax,[display_data-8]
		990	imul eax,3
		991	cmp eax,esi
		992	pop eax
		993	jbe @f
		994
		995	add ebx,esi
		996	mov ebx,[ebx]
		997	call overlapping_of_points
379	serge	998	@@:
469	serge	999	and eax,0xffffff
		1000	xchg edi, ebp
		1001	stosw
		1002	shr eax,16
		1003	stosb
		1004	xchg ebp, edi ; ebp+=3
		1005	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		1006	jz @f
		1007	inc ebp ; +1
379	serge	1008	@@:
469	serge	1009	pop ebx
		1010	pop eax
		1011	jmp shook1
1	ha	1012
379	serge	1013	overlapping_of_points:
469	serge	1014	push ecx edi
		1015	mov ecx,eax
		1016	mov edx,ebx
		1017	xor eax,eax
		1018	mov al,cl
		1019	xor ebx,ebx
		1020	mov bl,dl
		1021	add eax,ebx
		1022	rcr eax,1
		1023	xor edi,edi
		1024	mov di,ax
		1025	xor eax,eax
		1026	mov al,ch
		1027	xor ebx,ebx
		1028	mov bl,dh
		1029	add eax,ebx
		1030	rcr eax,1
		1031	ror edi,8
		1032	add edi,eax
		1033	ror ecx,8
		1034	ror edx,8
		1035	xor eax,eax
		1036	mov al,ch
		1037	xor ebx,ebx
		1038	mov bl,dh
		1039	add eax,ebx
		1040	rcr eax,1
		1041	ror edi,8
		1042	add eax,edi
		1043	ror eax,16
		1044	pop edi ecx
		1045	ret
1	ha	1046
469	serge	1047	snbgp:
1	ha	1048	add ebp,3 ; +3
		1049	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		1050	jz @f
		1051	inc ebp ; +1
469	serge	1052	@@:
1	ha	1053
469	serge	1054	shook1:
1	ha	1055	inc edi ; ptrBuffer++
		1056	add esi,3 ; ptrImage+=3
		1057	inc eax
115	poddubny	1058	cmp eax,[draw_data+32+RECT.right] ; X > xend?
1	ha	1059	jle sdp3
469	serge	1060	; jbe sdp3
1	ha	1061
115	poddubny	1062	mov ebp,[draw_data+32+RECT.left]
1	ha	1063
		1064	inc ebx
		1065
		1066	mov eax,[BytesPerScanLine]
		1067	mul ebx
		1068	xchg ebp, eax ; BytesPerScanLine*(Ywin+y)
		1069	add ebp, eax ; +X
		1070	add ebp, eax ; +X=X*2
		1071	add ebp, eax ; +X=X*3
		1072	cmp [ScreenBPP],byte 24 ; 24 or 32 bpp ? - x size
		1073	jz @f
		1074	add ebp,eax ; +X=X*4
469	serge	1075	@@:
1	ha	1076	add ebp,[LFBAddress] ; +LFB
		1077
		1078	; ebp:=YBytesPerScanLine+XBytesPerPixel+AddrLFB
		1079
		1080	call calculate_edi
		1081
469	serge	1082	; cmp ebx,[ScreenHeight]
		1083	; ja @f
		1084
115	poddubny	1085	cmp ebx,[draw_data+32+RECT.bottom]
1	ha	1086	jle sdp3
469	serge	1087	; jbe sdp3
		1088	@@:
1	ha	1089	add esp,4
		1090
		1091	pop edx
		1092	pop ecx
		1093	pop ebx
		1094	pop eax
		1095	pop ebp
117	mario79	1096	mov [EGA_counter],1
		1097	call VGA_drawbackground
1	ha	1098	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/video/vesa20.inc – Rev 473