WebSVN – Kolibri OS – Blame – /contrib/other/sdlquake-1.0.9/d_draw16.S

Rev	Author	Line No.	Line
5131	clevermous	1	/*
		2	Copyright (C) 1996-1997 Id Software, Inc.
		3
		4	This program is free software; you can redistribute it and/or
		5	modify it under the terms of the GNU General Public License
		6	as published by the Free Software Foundation; either version 2
		7	of the License, or (at your option) any later version.
		8
		9	This program is distributed in the hope that it will be useful,
		10	but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
		12
		13	See the GNU General Public License for more details.
		14
		15	You should have received a copy of the GNU General Public License
		16	along with this program; if not, write to the Free Software
		17	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		18
		19	*/
		20	//
		21	// d_draw16.s
		22	// x86 assembly-language horizontal 8-bpp span-drawing code, with 16-pixel
		23	// subdivision.
		24	//
		25
		26	#include "asm_i386.h"
		27	#include "quakeasm.h"
		28	#include "asm_draw.h"
		29	#include "d_ifacea.h"
		30
		31	#if id386
		32
		33	//----------------------------------------------------------------------
		34	// 8-bpp horizontal span drawing code for polygons, with no transparency and
		35	// 16-pixel subdivision.
		36	//
		37	// Assumes there is at least one span in pspans, and that every span
		38	// contains at least one pixel
		39	//----------------------------------------------------------------------
		40
		41	.data
		42
		43	.text
		44
		45	// out-of-line, rarely-needed clamping code
		46
		47	LClampHigh0:
		48	movl C(bbextents),%esi
		49	jmp LClampReentry0
		50	LClampHighOrLow0:
		51	jg LClampHigh0
		52	xorl %esi,%esi
		53	jmp LClampReentry0
		54
		55	LClampHigh1:
		56	movl C(bbextentt),%edx
		57	jmp LClampReentry1
		58	LClampHighOrLow1:
		59	jg LClampHigh1
		60	xorl %edx,%edx
		61	jmp LClampReentry1
		62
		63	LClampLow2:
		64	movl $4096,%ebp
		65	jmp LClampReentry2
		66	LClampHigh2:
		67	movl C(bbextents),%ebp
		68	jmp LClampReentry2
		69
		70	LClampLow3:
		71	movl $4096,%ecx
		72	jmp LClampReentry3
		73	LClampHigh3:
		74	movl C(bbextentt),%ecx
		75	jmp LClampReentry3
		76
		77	LClampLow4:
		78	movl $4096,%eax
		79	jmp LClampReentry4
		80	LClampHigh4:
		81	movl C(bbextents),%eax
		82	jmp LClampReentry4
		83
		84	LClampLow5:
		85	movl $4096,%ebx
		86	jmp LClampReentry5
		87	LClampHigh5:
		88	movl C(bbextentt),%ebx
		89	jmp LClampReentry5
		90
		91
		92	#define pspans 4+16
		93
		94	.align 4
		95	.globl C(D_DrawSpans16)
		96	C(D_DrawSpans16):
		97	pushl %ebp // preserve caller's stack frame
		98	pushl %edi
		99	pushl %esi // preserve register variables
		100	pushl %ebx
		101
		102	//
		103	// set up scaled-by-16 steps, for 16-long segments; also set up cacheblock
		104	// and span list pointers
		105	//
		106	// TODO: any overlap from rearranging?
		107	flds C(d_sdivzstepu)
		108	fmuls fp_16
		109	movl C(cacheblock),%edx
		110	flds C(d_tdivzstepu)
		111	fmuls fp_16
		112	movl pspans(%esp),%ebx // point to the first span descriptor
		113	flds C(d_zistepu)
		114	fmuls fp_16
		115	movl %edx,pbase // pbase = cacheblock
		116	fstps zi16stepu
		117	fstps tdivz16stepu
		118	fstps sdivz16stepu
		119
		120	LSpanLoop:
		121	//
		122	// set up the initial s/z, t/z, and 1/z on the FP stack, and generate the
		123	// initial s and t values
		124	//
		125	// FIXME: pipeline FILD?
		126	fildl espan_t_v(%ebx)
		127	fildl espan_t_u(%ebx)
		128
		129	fld %st(1) // dv \| du \| dv
		130	fmuls C(d_sdivzstepv) // dv*d_sdivzstepv \| du \| dv
		131	fld %st(1) // du \| dv*d_sdivzstepv \| du \| dv
		132	fmuls C(d_sdivzstepu) // dud_sdivzstepu \| dvd_sdivzstepv \| du \| dv
		133	fld %st(2) // du \| dud_sdivzstepu \| dvd_sdivzstepv \| du \| dv
		134	fmuls C(d_tdivzstepu) // dud_tdivzstepu \| dud_sdivzstepu \|
		135	// dv*d_sdivzstepv \| du \| dv
		136	fxch %st(1) // dud_sdivzstepu \| dud_tdivzstepu \|
		137	// dv*d_sdivzstepv \| du \| dv
		138	faddp %st(0),%st(2) // du*d_tdivzstepu \|
		139	// dud_sdivzstepu + dvd_sdivzstepv \| du \| dv
		140	fxch %st(1) // dud_sdivzstepu + dvd_sdivzstepv \|
		141	// du*d_tdivzstepu \| du \| dv
		142	fld %st(3) // dv \| dud_sdivzstepu + dvd_sdivzstepv \|
		143	// du*d_tdivzstepu \| du \| dv
		144	fmuls C(d_tdivzstepv) // dv*d_tdivzstepv \|
		145	// dud_sdivzstepu + dvd_sdivzstepv \|
		146	// du*d_tdivzstepu \| du \| dv
		147	fxch %st(1) // dud_sdivzstepu + dvd_sdivzstepv \|
		148	// dvd_tdivzstepv \| dud_tdivzstepu \| du \| dv
		149	fadds C(d_sdivzorigin) // sdivz = d_sdivzorigin + dv*d_sdivzstepv +
		150	// du*d_sdivzstepu; stays in %st(2) at end
		151	fxch %st(4) // dv \| dvd_tdivzstepv \| dud_tdivzstepu \| du \|
		152	// s/z
		153	fmuls C(d_zistepv) // dvd_zistepv \| dvd_tdivzstepv \|
		154	// du*d_tdivzstepu \| du \| s/z
		155	fxch %st(1) // dvd_tdivzstepv \| dvd_zistepv \|
		156	// du*d_tdivzstepu \| du \| s/z
		157	faddp %st(0),%st(2) // dv*d_zistepv \|
		158	// dvd_tdivzstepv + dud_tdivzstepu \| du \| s/z
		159	fxch %st(2) // du \| dvd_tdivzstepv + dud_tdivzstepu \|
		160	// dv*d_zistepv \| s/z
		161	fmuls C(d_zistepu) // du*d_zistepu \|
		162	// dvd_tdivzstepv + dud_tdivzstepu \|
		163	// dv*d_zistepv \| s/z
		164	fxch %st(1) // dvd_tdivzstepv + dud_tdivzstepu \|
		165	// dud_zistepu \| dvd_zistepv \| s/z
		166	fadds C(d_tdivzorigin) // tdivz = d_tdivzorigin + dv*d_tdivzstepv +
		167	// du*d_tdivzstepu; stays in %st(1) at end
		168	fxch %st(2) // dvd_zistepv \| dud_zistepu \| t/z \| s/z
		169	faddp %st(0),%st(1) // dvd_zistepv + dud_zistepu \| t/z \| s/z
		170
		171	flds fp_64k // fp_64k \| dvd_zistepv + dud_zistepu \| t/z \| s/z
		172	fxch %st(1) // dvd_zistepv + dud_zistepu \| fp_64k \| t/z \| s/z
		173	fadds C(d_ziorigin) // zi = d_ziorigin + dv*d_zistepv +
		174	// du*d_zistepu; stays in %st(0) at end
		175	// 1/z \| fp_64k \| t/z \| s/z
		176	//
		177	// calculate and clamp s & t
		178	//
		179	fdivr %st(0),%st(1) // 1/z \| z*64k \| t/z \| s/z
		180
		181	//
		182	// point %edi to the first pixel in the span
		183	//
		184	movl C(d_viewbuffer),%ecx
		185	movl espan_t_v(%ebx),%eax
		186	movl %ebx,pspantemp // preserve spans pointer
		187
		188	movl C(tadjust),%edx
		189	movl C(sadjust),%esi
		190	movl C(d_scantable)(,%eax,4),%edi // v * screenwidth
		191	addl %ecx,%edi
		192	movl espan_t_u(%ebx),%ecx
		193	addl %ecx,%edi // pdest = &pdestspan[scans->u];
		194	movl espan_t_count(%ebx),%ecx
		195
		196	//
		197	// now start the FDIV for the end of the span
		198	//
		199	cmpl $16,%ecx
		200	ja LSetupNotLast1
		201
		202	decl %ecx
		203	jz LCleanup1 // if only one pixel, no need to start an FDIV
		204	movl %ecx,spancountminus1
		205
		206	// finish up the s and t calcs
		207	fxch %st(1) // z*64k \| 1/z \| t/z \| s/z
		208
		209	fld %st(0) // z64k \| z64k \| 1/z \| t/z \| s/z
		210	fmul %st(4),%st(0) // s \| z*64k \| 1/z \| t/z \| s/z
		211	fxch %st(1) // z*64k \| s \| 1/z \| t/z \| s/z
		212	fmul %st(3),%st(0) // t \| s \| 1/z \| t/z \| s/z
		213	fxch %st(1) // s \| t \| 1/z \| t/z \| s/z
		214	fistpl s // 1/z \| t \| t/z \| s/z
		215	fistpl t // 1/z \| t/z \| s/z
		216
		217	fildl spancountminus1
		218
		219	flds C(d_tdivzstepu) // C(d_tdivzstepu) \| spancountminus1
		220	flds C(d_zistepu) // C(d_zistepu) \| C(d_tdivzstepu) \| spancountminus1
		221	fmul %st(2),%st(0) // C(d_zistepu)*scm1 \| C(d_tdivzstepu) \| scm1
		222	fxch %st(1) // C(d_tdivzstepu) \| C(d_zistepu)*scm1 \| scm1
		223	fmul %st(2),%st(0) // C(d_tdivzstepu)scm1 \| C(d_zistepu)scm1 \| scm1
		224	fxch %st(2) // scm1 \| C(d_zistepu)scm1 \| C(d_tdivzstepu)scm1
		225	fmuls C(d_sdivzstepu) // C(d_sdivzstepu)scm1 \| C(d_zistepu)scm1 \|
		226	// C(d_tdivzstepu)*scm1
		227	fxch %st(1) // C(d_zistepu)scm1 \| C(d_sdivzstepu)scm1 \|
		228	// C(d_tdivzstepu)*scm1
		229	faddp %st(0),%st(3) // C(d_sdivzstepu)scm1 \| C(d_tdivzstepu)scm1
		230	fxch %st(1) // C(d_tdivzstepu)scm1 \| C(d_sdivzstepu)scm1
		231	faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1
		232	faddp %st(0),%st(3)
		233
		234	flds fp_64k
		235	fdiv %st(1),%st(0) // this is what we've gone to all this trouble to
		236	// overlap
		237	jmp LFDIVInFlight1
		238
		239	LCleanup1:
		240	// finish up the s and t calcs
		241	fxch %st(1) // z*64k \| 1/z \| t/z \| s/z
		242
		243	fld %st(0) // z64k \| z64k \| 1/z \| t/z \| s/z
		244	fmul %st(4),%st(0) // s \| z*64k \| 1/z \| t/z \| s/z
		245	fxch %st(1) // z*64k \| s \| 1/z \| t/z \| s/z
		246	fmul %st(3),%st(0) // t \| s \| 1/z \| t/z \| s/z
		247	fxch %st(1) // s \| t \| 1/z \| t/z \| s/z
		248	fistpl s // 1/z \| t \| t/z \| s/z
		249	fistpl t // 1/z \| t/z \| s/z
		250	jmp LFDIVInFlight1
		251
		252	.align 4
		253	LSetupNotLast1:
		254	// finish up the s and t calcs
		255	fxch %st(1) // z*64k \| 1/z \| t/z \| s/z
		256
		257	fld %st(0) // z64k \| z64k \| 1/z \| t/z \| s/z
		258	fmul %st(4),%st(0) // s \| z*64k \| 1/z \| t/z \| s/z
		259	fxch %st(1) // z*64k \| s \| 1/z \| t/z \| s/z
		260	fmul %st(3),%st(0) // t \| s \| 1/z \| t/z \| s/z
		261	fxch %st(1) // s \| t \| 1/z \| t/z \| s/z
		262	fistpl s // 1/z \| t \| t/z \| s/z
		263	fistpl t // 1/z \| t/z \| s/z
		264
		265	fadds zi16stepu
		266	fxch %st(2)
		267	fadds sdivz16stepu
		268	fxch %st(2)
		269	flds tdivz16stepu
		270	faddp %st(0),%st(2)
		271	flds fp_64k
		272	fdiv %st(1),%st(0) // z = 1/1/z
		273	// this is what we've gone to all this trouble to
		274	// overlap
		275	LFDIVInFlight1:
		276
		277	addl s,%esi
		278	addl t,%edx
		279	movl C(bbextents),%ebx
		280	movl C(bbextentt),%ebp
		281	cmpl %ebx,%esi
		282	ja LClampHighOrLow0
		283	LClampReentry0:
		284	movl %esi,s
		285	movl pbase,%ebx
		286	shll $16,%esi
		287	cmpl %ebp,%edx
		288	movl %esi,sfracf
		289	ja LClampHighOrLow1
		290	LClampReentry1:
		291	movl %edx,t
		292	movl s,%esi // sfrac = scans->sfrac;
		293	shll $16,%edx
		294	movl t,%eax // tfrac = scans->tfrac;
		295	sarl $16,%esi
		296	movl %edx,tfracf
		297
		298	//
		299	// calculate the texture starting address
		300	//
		301	sarl $16,%eax
		302	movl C(cachewidth),%edx
		303	imull %edx,%eax // (tfrac >> 16) * cachewidth
		304	addl %ebx,%esi
		305	addl %eax,%esi // psource = pbase + (sfrac >> 16) +
		306	// ((tfrac >> 16) * cachewidth);
		307	//
		308	// determine whether last span or not
		309	//
		310	cmpl $16,%ecx
		311	jna LLastSegment
		312
		313	//
		314	// not the last segment; do full 16-wide segment
		315	//
		316	LNotLastSegment:
		317
		318	//
		319	// advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
		320	// get there
		321	//
		322
		323	// pick up after the FDIV that was left in flight previously
		324
		325	fld %st(0) // duplicate it
		326	fmul %st(4),%st(0) // s = s/z * z
		327	fxch %st(1)
		328	fmul %st(3),%st(0) // t = t/z * z
		329	fxch %st(1)
		330	fistpl snext
		331	fistpl tnext
		332	movl snext,%eax
		333	movl tnext,%edx
		334
		335	movb (%esi),%bl // get first source texel
		336	subl $16,%ecx // count off this segments' pixels
		337	movl C(sadjust),%ebp
		338	movl %ecx,counttemp // remember count of remaining pixels
		339
		340	movl C(tadjust),%ecx
		341	movb %bl,(%edi) // store first dest pixel
		342
		343	addl %eax,%ebp
		344	addl %edx,%ecx
		345
		346	movl C(bbextents),%eax
		347	movl C(bbextentt),%edx
		348
		349	cmpl $4096,%ebp
		350	jl LClampLow2
		351	cmpl %eax,%ebp
		352	ja LClampHigh2
		353	LClampReentry2:
		354
		355	cmpl $4096,%ecx
		356	jl LClampLow3
		357	cmpl %edx,%ecx
		358	ja LClampHigh3
		359	LClampReentry3:
		360
		361	movl %ebp,snext
		362	movl %ecx,tnext
		363
		364	subl s,%ebp
		365	subl t,%ecx
		366
		367	//
		368	// set up advancetable
		369	//
		370	movl %ecx,%eax
		371	movl %ebp,%edx
		372	sarl $20,%eax // tstep >>= 16;
		373	jz LZero
		374	sarl $20,%edx // sstep >>= 16;
		375	movl C(cachewidth),%ebx
		376	imull %ebx,%eax
		377	jmp LSetUp1
		378
		379	LZero:
		380	sarl $20,%edx // sstep >>= 16;
		381	movl C(cachewidth),%ebx
		382
		383	LSetUp1:
		384
		385	addl %edx,%eax // add in sstep
		386	// (tstep >> 16) * cachewidth + (sstep >> 16);
		387	movl tfracf,%edx
		388	movl %eax,advancetable+4 // advance base in t
		389	addl %ebx,%eax // ((tstep >> 16) + 1) * cachewidth +
		390	// (sstep >> 16);
		391	shll $12,%ebp // left-justify sstep fractional part
		392	movl sfracf,%ebx
		393	shll $12,%ecx // left-justify tstep fractional part
		394	movl %eax,advancetable // advance extra in t
		395
		396	movl %ecx,tstep
		397	addl %ecx,%edx // advance tfrac fractional part by tstep frac
		398
		399	sbbl %ecx,%ecx // turn tstep carry into -1 (0 if none)
		400	addl %ebp,%ebx // advance sfrac fractional part by sstep frac
		401	adcl advancetable+4(,%ecx,4),%esi // point to next source texel
		402
		403	addl tstep,%edx
		404	sbbl %ecx,%ecx
		405	movb (%esi),%al
		406	addl %ebp,%ebx
		407	movb %al,1(%edi)
		408	adcl advancetable+4(,%ecx,4),%esi
		409
		410	addl tstep,%edx
		411	sbbl %ecx,%ecx
		412	addl %ebp,%ebx
		413	movb (%esi),%al
		414	adcl advancetable+4(,%ecx,4),%esi
		415
		416	addl tstep,%edx
		417	sbbl %ecx,%ecx
		418	movb %al,2(%edi)
		419	addl %ebp,%ebx
		420	movb (%esi),%al
		421	adcl advancetable+4(,%ecx,4),%esi
		422
		423	addl tstep,%edx
		424	sbbl %ecx,%ecx
		425	movb %al,3(%edi)
		426	addl %ebp,%ebx
		427	movb (%esi),%al
		428	adcl advancetable+4(,%ecx,4),%esi
		429
		430	addl tstep,%edx
		431	sbbl %ecx,%ecx
		432	movb %al,4(%edi)
		433	addl %ebp,%ebx
		434	movb (%esi),%al
		435	adcl advancetable+4(,%ecx,4),%esi
		436
		437	addl tstep,%edx
		438	sbbl %ecx,%ecx
		439	movb %al,5(%edi)
		440	addl %ebp,%ebx
		441	movb (%esi),%al
		442	adcl advancetable+4(,%ecx,4),%esi
		443
		444	addl tstep,%edx
		445	sbbl %ecx,%ecx
		446	movb %al,6(%edi)
		447	addl %ebp,%ebx
		448	movb (%esi),%al
		449	adcl advancetable+4(,%ecx,4),%esi
		450
		451	addl tstep,%edx
		452	sbbl %ecx,%ecx
		453	movb %al,7(%edi)
		454	addl %ebp,%ebx
		455	movb (%esi),%al
		456	adcl advancetable+4(,%ecx,4),%esi
		457
		458
		459	//
		460	// start FDIV for end of next segment in flight, so it can overlap
		461	//
		462	movl counttemp,%ecx
		463	cmpl $16,%ecx // more than one segment after this?
		464	ja LSetupNotLast2 // yes
		465
		466	decl %ecx
		467	jz LFDIVInFlight2 // if only one pixel, no need to start an FDIV
		468	movl %ecx,spancountminus1
		469	fildl spancountminus1
		470
		471	flds C(d_zistepu) // C(d_zistepu) \| spancountminus1
		472	fmul %st(1),%st(0) // C(d_zistepu)*scm1 \| scm1
		473	flds C(d_tdivzstepu) // C(d_tdivzstepu) \| C(d_zistepu)*scm1 \| scm1
		474	fmul %st(2),%st(0) // C(d_tdivzstepu)scm1 \| C(d_zistepu)scm1 \| scm1
		475	fxch %st(1) // C(d_zistepu)scm1 \| C(d_tdivzstepu)scm1 \| scm1
		476	faddp %st(0),%st(3) // C(d_tdivzstepu)*scm1 \| scm1
		477	fxch %st(1) // scm1 \| C(d_tdivzstepu)*scm1
		478	fmuls C(d_sdivzstepu) // C(d_sdivzstepu)scm1 \| C(d_tdivzstepu)scm1
		479	fxch %st(1) // C(d_tdivzstepu)scm1 \| C(d_sdivzstepu)scm1
		480	faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1
		481	flds fp_64k // 64k \| C(d_sdivzstepu)*scm1
		482	fxch %st(1) // C(d_sdivzstepu)*scm1 \| 64k
		483	faddp %st(0),%st(4) // 64k
		484
		485	fdiv %st(1),%st(0) // this is what we've gone to all this trouble to
		486	// overlap
		487	jmp LFDIVInFlight2
		488
		489	.align 4
		490	LSetupNotLast2:
		491	fadds zi16stepu
		492	fxch %st(2)
		493	fadds sdivz16stepu
		494	fxch %st(2)
		495	flds tdivz16stepu
		496	faddp %st(0),%st(2)
		497	flds fp_64k
		498	fdiv %st(1),%st(0) // z = 1/1/z
		499	// this is what we've gone to all this trouble to
		500	// overlap
		501	LFDIVInFlight2:
		502	movl %ecx,counttemp
		503
		504	addl tstep,%edx
		505	sbbl %ecx,%ecx
		506	movb %al,8(%edi)
		507	addl %ebp,%ebx
		508	movb (%esi),%al
		509	adcl advancetable+4(,%ecx,4),%esi
		510
		511	addl tstep,%edx
		512	sbbl %ecx,%ecx
		513	movb %al,9(%edi)
		514	addl %ebp,%ebx
		515	movb (%esi),%al
		516	adcl advancetable+4(,%ecx,4),%esi
		517
		518	addl tstep,%edx
		519	sbbl %ecx,%ecx
		520	movb %al,10(%edi)
		521	addl %ebp,%ebx
		522	movb (%esi),%al
		523	adcl advancetable+4(,%ecx,4),%esi
		524
		525	addl tstep,%edx
		526	sbbl %ecx,%ecx
		527	movb %al,11(%edi)
		528	addl %ebp,%ebx
		529	movb (%esi),%al
		530	adcl advancetable+4(,%ecx,4),%esi
		531
		532	addl tstep,%edx
		533	sbbl %ecx,%ecx
		534	movb %al,12(%edi)
		535	addl %ebp,%ebx
		536	movb (%esi),%al
		537	adcl advancetable+4(,%ecx,4),%esi
		538
		539	addl tstep,%edx
		540	sbbl %ecx,%ecx
		541	movb %al,13(%edi)
		542	addl %ebp,%ebx
		543	movb (%esi),%al
		544	adcl advancetable+4(,%ecx,4),%esi
		545
		546	addl tstep,%edx
		547	sbbl %ecx,%ecx
		548	movb %al,14(%edi)
		549	addl %ebp,%ebx
		550	movb (%esi),%al
		551	adcl advancetable+4(,%ecx,4),%esi
		552
		553	addl $16,%edi
		554	movl %edx,tfracf
		555	movl snext,%edx
		556	movl %ebx,sfracf
		557	movl tnext,%ebx
		558	movl %edx,s
		559	movl %ebx,t
		560
		561	movl counttemp,%ecx // retrieve count
		562
		563	//
		564	// determine whether last span or not
		565	//
		566	cmpl $16,%ecx // are there multiple segments remaining?
		567	movb %al,-1(%edi)
		568	ja LNotLastSegment // yes
		569
		570	//
		571	// last segment of scan
		572	//
		573	LLastSegment:
		574
		575	//
		576	// advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
		577	// get there. The number of pixels left is variable, and we want to land on the
		578	// last pixel, not step one past it, so we can't run into arithmetic problems
		579	//
		580	testl %ecx,%ecx
		581	jz LNoSteps // just draw the last pixel and we're done
		582
		583	// pick up after the FDIV that was left in flight previously
		584
		585
		586	fld %st(0) // duplicate it
		587	fmul %st(4),%st(0) // s = s/z * z
		588	fxch %st(1)
		589	fmul %st(3),%st(0) // t = t/z * z
		590	fxch %st(1)
		591	fistpl snext
		592	fistpl tnext
		593
		594	movb (%esi),%al // load first texel in segment
		595	movl C(tadjust),%ebx
		596	movb %al,(%edi) // store first pixel in segment
		597	movl C(sadjust),%eax
		598
		599	addl snext,%eax
		600	addl tnext,%ebx
		601
		602	movl C(bbextents),%ebp
		603	movl C(bbextentt),%edx
		604
		605	cmpl $4096,%eax
		606	jl LClampLow4
		607	cmpl %ebp,%eax
		608	ja LClampHigh4
		609	LClampReentry4:
		610	movl %eax,snext
		611
		612	cmpl $4096,%ebx
		613	jl LClampLow5
		614	cmpl %edx,%ebx
		615	ja LClampHigh5
		616	LClampReentry5:
		617
		618	cmpl $1,%ecx // don't bother
		619	je LOnlyOneStep // if two pixels in segment, there's only one step,
		620	// of the segment length
		621	subl s,%eax
		622	subl t,%ebx
		623
		624	addl %eax,%eax // convert to 15.17 format so multiply by 1.31
		625	addl %ebx,%ebx // reciprocal yields 16.48
		626
		627	imull reciprocal_table_16-8(,%ecx,4) // sstep = (snext - s) /
		628	// (spancount-1)
		629	movl %edx,%ebp
		630
		631	movl %ebx,%eax
		632	imull reciprocal_table_16-8(,%ecx,4) // tstep = (tnext - t) /
		633	// (spancount-1)
		634	LSetEntryvec:
		635	//
		636	// set up advancetable
		637	//
		638	movl entryvec_table_16(,%ecx,4),%ebx
		639	movl %edx,%eax
		640	movl %ebx,jumptemp // entry point into code for RET later
		641	movl %ebp,%ecx
		642	sarl $16,%edx // tstep >>= 16;
		643	movl C(cachewidth),%ebx
		644	sarl $16,%ecx // sstep >>= 16;
		645	imull %ebx,%edx
		646
		647	addl %ecx,%edx // add in sstep
		648	// (tstep >> 16) * cachewidth + (sstep >> 16);
		649	movl tfracf,%ecx
		650	movl %edx,advancetable+4 // advance base in t
		651	addl %ebx,%edx // ((tstep >> 16) + 1) * cachewidth +
		652	// (sstep >> 16);
		653	shll $16,%ebp // left-justify sstep fractional part
		654	movl sfracf,%ebx
		655	shll $16,%eax // left-justify tstep fractional part
		656	movl %edx,advancetable // advance extra in t
		657
		658	movl %eax,tstep
		659	movl %ecx,%edx
		660	addl %eax,%edx
		661	sbbl %ecx,%ecx
		662	addl %ebp,%ebx
		663	adcl advancetable+4(,%ecx,4),%esi
		664
		665	jmp *jumptemp // jump to the number-of-pixels handler
		666
		667	//----------------------------------------
		668
		669	LNoSteps:
		670	movb (%esi),%al // load first texel in segment
		671	subl $15,%edi // adjust for hardwired offset
		672	jmp LEndSpan
		673
		674
		675	LOnlyOneStep:
		676	subl s,%eax
		677	subl t,%ebx
		678	movl %eax,%ebp
		679	movl %ebx,%edx
		680	jmp LSetEntryvec
		681
		682	//----------------------------------------
		683
		684	.globl Entry2_16, Entry3_16, Entry4_16, Entry5_16
		685	.globl Entry6_16, Entry7_16, Entry8_16, Entry9_16
		686	.globl Entry10_16, Entry11_16, Entry12_16, Entry13_16
		687	.globl Entry14_16, Entry15_16, Entry16_16
		688
		689	Entry2_16:
		690	subl $14,%edi // adjust for hardwired offsets
		691	movb (%esi),%al
		692	jmp LEntry2_16
		693
		694	//----------------------------------------
		695
		696	Entry3_16:
		697	subl $13,%edi // adjust for hardwired offsets
		698	addl %eax,%edx
		699	movb (%esi),%al
		700	sbbl %ecx,%ecx
		701	addl %ebp,%ebx
		702	adcl advancetable+4(,%ecx,4),%esi
		703	jmp LEntry3_16
		704
		705	//----------------------------------------
		706
		707	Entry4_16:
		708	subl $12,%edi // adjust for hardwired offsets
		709	addl %eax,%edx
		710	movb (%esi),%al
		711	sbbl %ecx,%ecx
		712	addl %ebp,%ebx
		713	adcl advancetable+4(,%ecx,4),%esi
		714	addl tstep,%edx
		715	jmp LEntry4_16
		716
		717	//----------------------------------------
		718
		719	Entry5_16:
		720	subl $11,%edi // adjust for hardwired offsets
		721	addl %eax,%edx
		722	movb (%esi),%al
		723	sbbl %ecx,%ecx
		724	addl %ebp,%ebx
		725	adcl advancetable+4(,%ecx,4),%esi
		726	addl tstep,%edx
		727	jmp LEntry5_16
		728
		729	//----------------------------------------
		730
		731	Entry6_16:
		732	subl $10,%edi // adjust for hardwired offsets
		733	addl %eax,%edx
		734	movb (%esi),%al
		735	sbbl %ecx,%ecx
		736	addl %ebp,%ebx
		737	adcl advancetable+4(,%ecx,4),%esi
		738	addl tstep,%edx
		739	jmp LEntry6_16
		740
		741	//----------------------------------------
		742
		743	Entry7_16:
		744	subl $9,%edi // adjust for hardwired offsets
		745	addl %eax,%edx
		746	movb (%esi),%al
		747	sbbl %ecx,%ecx
		748	addl %ebp,%ebx
		749	adcl advancetable+4(,%ecx,4),%esi
		750	addl tstep,%edx
		751	jmp LEntry7_16
		752
		753	//----------------------------------------
		754
		755	Entry8_16:
		756	subl $8,%edi // adjust for hardwired offsets
		757	addl %eax,%edx
		758	movb (%esi),%al
		759	sbbl %ecx,%ecx
		760	addl %ebp,%ebx
		761	adcl advancetable+4(,%ecx,4),%esi
		762	addl tstep,%edx
		763	jmp LEntry8_16
		764
		765	//----------------------------------------
		766
		767	Entry9_16:
		768	subl $7,%edi // adjust for hardwired offsets
		769	addl %eax,%edx
		770	movb (%esi),%al
		771	sbbl %ecx,%ecx
		772	addl %ebp,%ebx
		773	adcl advancetable+4(,%ecx,4),%esi
		774	addl tstep,%edx
		775	jmp LEntry9_16
		776
		777	//----------------------------------------
		778
		779	Entry10_16:
		780	subl $6,%edi // adjust for hardwired offsets
		781	addl %eax,%edx
		782	movb (%esi),%al
		783	sbbl %ecx,%ecx
		784	addl %ebp,%ebx
		785	adcl advancetable+4(,%ecx,4),%esi
		786	addl tstep,%edx
		787	jmp LEntry10_16
		788
		789	//----------------------------------------
		790
		791	Entry11_16:
		792	subl $5,%edi // adjust for hardwired offsets
		793	addl %eax,%edx
		794	movb (%esi),%al
		795	sbbl %ecx,%ecx
		796	addl %ebp,%ebx
		797	adcl advancetable+4(,%ecx,4),%esi
		798	addl tstep,%edx
		799	jmp LEntry11_16
		800
		801	//----------------------------------------
		802
		803	Entry12_16:
		804	subl $4,%edi // adjust for hardwired offsets
		805	addl %eax,%edx
		806	movb (%esi),%al
		807	sbbl %ecx,%ecx
		808	addl %ebp,%ebx
		809	adcl advancetable+4(,%ecx,4),%esi
		810	addl tstep,%edx
		811	jmp LEntry12_16
		812
		813	//----------------------------------------
		814
		815	Entry13_16:
		816	subl $3,%edi // adjust for hardwired offsets
		817	addl %eax,%edx
		818	movb (%esi),%al
		819	sbbl %ecx,%ecx
		820	addl %ebp,%ebx
		821	adcl advancetable+4(,%ecx,4),%esi
		822	addl tstep,%edx
		823	jmp LEntry13_16
		824
		825	//----------------------------------------
		826
		827	Entry14_16:
		828	subl $2,%edi // adjust for hardwired offsets
		829	addl %eax,%edx
		830	movb (%esi),%al
		831	sbbl %ecx,%ecx
		832	addl %ebp,%ebx
		833	adcl advancetable+4(,%ecx,4),%esi
		834	addl tstep,%edx
		835	jmp LEntry14_16
		836
		837	//----------------------------------------
		838
		839	Entry15_16:
		840	decl %edi // adjust for hardwired offsets
		841	addl %eax,%edx
		842	movb (%esi),%al
		843	sbbl %ecx,%ecx
		844	addl %ebp,%ebx
		845	adcl advancetable+4(,%ecx,4),%esi
		846	addl tstep,%edx
		847	jmp LEntry15_16
		848
		849	//----------------------------------------
		850
		851	Entry16_16:
		852	addl %eax,%edx
		853	movb (%esi),%al
		854	sbbl %ecx,%ecx
		855	addl %ebp,%ebx
		856	adcl advancetable+4(,%ecx,4),%esi
		857
		858	addl tstep,%edx
		859	sbbl %ecx,%ecx
		860	movb %al,1(%edi)
		861	addl %ebp,%ebx
		862	movb (%esi),%al
		863	adcl advancetable+4(,%ecx,4),%esi
		864	addl tstep,%edx
		865	LEntry15_16:
		866	sbbl %ecx,%ecx
		867	movb %al,2(%edi)
		868	addl %ebp,%ebx
		869	movb (%esi),%al
		870	adcl advancetable+4(,%ecx,4),%esi
		871	addl tstep,%edx
		872	LEntry14_16:
		873	sbbl %ecx,%ecx
		874	movb %al,3(%edi)
		875	addl %ebp,%ebx
		876	movb (%esi),%al
		877	adcl advancetable+4(,%ecx,4),%esi
		878	addl tstep,%edx
		879	LEntry13_16:
		880	sbbl %ecx,%ecx
		881	movb %al,4(%edi)
		882	addl %ebp,%ebx
		883	movb (%esi),%al
		884	adcl advancetable+4(,%ecx,4),%esi
		885	addl tstep,%edx
		886	LEntry12_16:
		887	sbbl %ecx,%ecx
		888	movb %al,5(%edi)
		889	addl %ebp,%ebx
		890	movb (%esi),%al
		891	adcl advancetable+4(,%ecx,4),%esi
		892	addl tstep,%edx
		893	LEntry11_16:
		894	sbbl %ecx,%ecx
		895	movb %al,6(%edi)
		896	addl %ebp,%ebx
		897	movb (%esi),%al
		898	adcl advancetable+4(,%ecx,4),%esi
		899	addl tstep,%edx
		900	LEntry10_16:
		901	sbbl %ecx,%ecx
		902	movb %al,7(%edi)
		903	addl %ebp,%ebx
		904	movb (%esi),%al
		905	adcl advancetable+4(,%ecx,4),%esi
		906	addl tstep,%edx
		907	LEntry9_16:
		908	sbbl %ecx,%ecx
		909	movb %al,8(%edi)
		910	addl %ebp,%ebx
		911	movb (%esi),%al
		912	adcl advancetable+4(,%ecx,4),%esi
		913	addl tstep,%edx
		914	LEntry8_16:
		915	sbbl %ecx,%ecx
		916	movb %al,9(%edi)
		917	addl %ebp,%ebx
		918	movb (%esi),%al
		919	adcl advancetable+4(,%ecx,4),%esi
		920	addl tstep,%edx
		921	LEntry7_16:
		922	sbbl %ecx,%ecx
		923	movb %al,10(%edi)
		924	addl %ebp,%ebx
		925	movb (%esi),%al
		926	adcl advancetable+4(,%ecx,4),%esi
		927	addl tstep,%edx
		928	LEntry6_16:
		929	sbbl %ecx,%ecx
		930	movb %al,11(%edi)
		931	addl %ebp,%ebx
		932	movb (%esi),%al
		933	adcl advancetable+4(,%ecx,4),%esi
		934	addl tstep,%edx
		935	LEntry5_16:
		936	sbbl %ecx,%ecx
		937	movb %al,12(%edi)
		938	addl %ebp,%ebx
		939	movb (%esi),%al
		940	adcl advancetable+4(,%ecx,4),%esi
		941	addl tstep,%edx
		942	LEntry4_16:
		943	sbbl %ecx,%ecx
		944	movb %al,13(%edi)
		945	addl %ebp,%ebx
		946	movb (%esi),%al
		947	adcl advancetable+4(,%ecx,4),%esi
		948	LEntry3_16:
		949	movb %al,14(%edi)
		950	movb (%esi),%al
		951	LEntry2_16:
		952
		953	LEndSpan:
		954
		955	//
		956	// clear s/z, t/z, 1/z from FP stack
		957	//
		958	fstp %st(0)
		959	fstp %st(0)
		960	fstp %st(0)
		961
		962	movl pspantemp,%ebx // restore spans pointer
		963	movl espan_t_pnext(%ebx),%ebx // point to next span
		964	testl %ebx,%ebx // any more spans?
		965	movb %al,15(%edi)
		966	jnz LSpanLoop // more spans
		967
		968	popl %ebx // restore register variables
		969	popl %esi
		970	popl %edi
		971	popl %ebp // restore the caller's stack frame
		972	ret
		973
		974	#endif // id386

Subversion Repositories Kolibri OS

(root)/contrib/other/sdlquake-1.0.9/d_draw16.S @ 6078 – Rev 5131