WebSVN – Kolibri OS – Blame – /contrib/other/sdlquake-1.0.9/d_polysa.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_polysa.s
		22	// x86 assembly-language polygon model drawing code
		23	//
		24
		25	#include "asm_i386.h"
		26	#include "quakeasm.h"
		27	#include "asm_draw.h"
		28	#include "d_ifacea.h"
		29
		30	#if id386
		31
		32	// !!! if this is changed, it must be changed in d_polyse.c too !!!
		33	#define DPS_MAXSPANS MAXHEIGHT+1
		34	// 1 extra for spanpackage that marks end
		35
		36	//#define SPAN_SIZE (((DPS_MAXSPANS + 1 + ((CACHE_SIZE - 1) / spanpackage_t_size)) + 1) * spanpackage_t_size)
		37	#define SPAN_SIZE (1024+1+1+1)*32
		38
		39
		40	.data
		41
		42	.align 4
		43	p10_minus_p20: .single 0
		44	p01_minus_p21: .single 0
		45	temp0: .single 0
		46	temp1: .single 0
		47	Ltemp: .single 0
		48
		49	aff8entryvec_table: .long LDraw8, LDraw7, LDraw6, LDraw5
		50	.long LDraw4, LDraw3, LDraw2, LDraw1
		51
		52	lzistepx: .long 0
		53
		54
		55	.text
		56
		57	#ifndef NeXT
		58	.extern C(D_PolysetSetEdgeTable)
		59	.extern C(D_RasterizeAliasPolySmooth)
		60	#endif
		61
		62	//----------------------------------------------------------------------
		63	// affine triangle gradient calculation code
		64	//----------------------------------------------------------------------
		65
		66	#define skinwidth 4+0
		67
		68	.globl C(D_PolysetCalcGradients)
		69	C(D_PolysetCalcGradients):
		70
		71	// p00_minus_p20 = r_p0[0] - r_p2[0];
		72	// p01_minus_p21 = r_p0[1] - r_p2[1];
		73	// p10_minus_p20 = r_p1[0] - r_p2[0];
		74	// p11_minus_p21 = r_p1[1] - r_p2[1];
		75	//
		76	// xstepdenominv = 1.0 / (p10_minus_p20 * p01_minus_p21 -
		77	// p00_minus_p20 * p11_minus_p21);
		78	//
		79	// ystepdenominv = -xstepdenominv;
		80
		81	fildl C(r_p0)+0 // r_p0[0]
		82	fildl C(r_p2)+0 // r_p2[0] \| r_p0[0]
		83	fildl C(r_p0)+4 // r_p0[1] \| r_p2[0] \| r_p0[0]
		84	fildl C(r_p2)+4 // r_p2[1] \| r_p0[1] \| r_p2[0] \| r_p0[0]
		85	fildl C(r_p1)+0 // r_p1[0] \| r_p2[1] \| r_p0[1] \| r_p2[0] \| r_p0[0]
		86	fildl C(r_p1)+4 // r_p1[1] \| r_p1[0] \| r_p2[1] \| r_p0[1] \|
		87	// r_p2[0] \| r_p0[0]
		88	fxch %st(3) // r_p0[1] \| r_p1[0] \| r_p2[1] \| r_p1[1] \|
		89	// r_p2[0] \| r_p0[0]
		90	fsub %st(2),%st(0) // p01_minus_p21 \| r_p1[0] \| r_p2[1] \| r_p1[1] \|
		91	// r_p2[0] \| r_p0[0]
		92	fxch %st(1) // r_p1[0] \| p01_minus_p21 \| r_p2[1] \| r_p1[1] \|
		93	// r_p2[0] \| r_p0[0]
		94	fsub %st(4),%st(0) // p10_minus_p20 \| p01_minus_p21 \| r_p2[1] \|
		95	// r_p1[1] \| r_p2[0] \| r_p0[0]
		96	fxch %st(5) // r_p0[0] \| p01_minus_p21 \| r_p2[1] \|
		97	// r_p1[1] \| r_p2[0] \| p10_minus_p20
		98	fsubp %st(0),%st(4) // p01_minus_p21 \| r_p2[1] \| r_p1[1] \|
		99	// p00_minus_p20 \| p10_minus_p20
		100	fxch %st(2) // r_p1[1] \| r_p2[1] \| p01_minus_p21 \|
		101	// p00_minus_p20 \| p10_minus_p20
		102	fsubp %st(0),%st(1) // p11_minus_p21 \| p01_minus_p21 \|
		103	// p00_minus_p20 \| p10_minus_p20
		104	fxch %st(1) // p01_minus_p21 \| p11_minus_p21 \|
		105	// p00_minus_p20 \| p10_minus_p20
		106	flds C(d_xdenom) // d_xdenom \| p01_minus_p21 \| p11_minus_p21 \|
		107	// p00_minus_p20 \| p10_minus_p20
		108	fxch %st(4) // p10_minus_p20 \| p01_minus_p21 \| p11_minus_p21 \|
		109	// p00_minus_p20 \| d_xdenom
		110	fstps p10_minus_p20 // p01_minus_p21 \| p11_minus_p21 \|
		111	// p00_minus_p20 \| d_xdenom
		112	fstps p01_minus_p21 // p11_minus_p21 \| p00_minus_p20 \| xstepdenominv
		113	fxch %st(2) // xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		114
		115	//// ceil () for light so positive steps are exaggerated, negative steps
		116	//// diminished, pushing us away from underflow toward overflow. Underflow is
		117	//// very visible, overflow is very unlikely, because of ambient lighting
		118	// t0 = r_p0[4] - r_p2[4];
		119	// t1 = r_p1[4] - r_p2[4];
		120
		121	fildl C(r_p2)+16 // r_p2[4] \| xstepdenominv \| p00_minus_p20 \|
		122	// p11_minus_p21
		123	fildl C(r_p0)+16 // r_p0[4] \| r_p2[4] \| xstepdenominv \|
		124	// p00_minus_p20 \| p11_minus_p21
		125	fildl C(r_p1)+16 // r_p1[4] \| r_p0[4] \| r_p2[4] \| xstepdenominv \|
		126	// p00_minus_p20 \| p11_minus_p21
		127	fxch %st(2) // r_p2[4] \| r_p0[4] \| r_p1[4] \| xstepdenominv \|
		128	// p00_minus_p20 \| p11_minus_p21
		129	fld %st(0) // r_p2[4] \| r_p2[4] \| r_p0[4] \| r_p1[4] \|
		130	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		131	fsubrp %st(0),%st(2) // r_p2[4] \| t0 \| r_p1[4] \| xstepdenominv \|
		132	// p00_minus_p20 \| p11_minus_p21
		133	fsubrp %st(0),%st(2) // t0 \| t1 \| xstepdenominv \| p00_minus_p20 \|
		134	// p11_minus_p21
		135
		136	// r_lstepx = (int)
		137	// ceil((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
		138	// r_lstepy = (int)
		139	// ceil((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv);
		140
		141	fld %st(0) // t0 \| t0 \| t1 \| xstepdenominv \| p00_minus_p20 \|
		142	// p11_minus_p21
		143	fmul %st(5),%st(0) // t0*p11_minus_p21 \| t0 \| t1 \| xstepdenominv \|
		144	// p00_minus_p20 \| p11_minus_p21
		145	fxch %st(2) // t1 \| t0 \| t0*p11_minus_p21 \| xstepdenominv \|
		146	// p00_minus_p20 \| p11_minus_p21
		147	fld %st(0) // t1 \| t1 \| t0 \| t0*p11_minus_p21 \|
		148	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		149	fmuls p01_minus_p21 // t1p01_minus_p21 \| t1 \| t0 \| t0p11_minus_p21 \|
		150	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		151	fxch %st(2) // t0 \| t1 \| t1p01_minus_p21 \| t0p11_minus_p21 \|
		152	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		153	fmuls p10_minus_p20 // t0p10_minus_p20 \| t1 \| t1p01_minus_p21 \|
		154	// t0*p11_minus_p21 \| xstepdenominv \|
		155	// p00_minus_p20 \| p11_minus_p21
		156	fxch %st(1) // t1 \| t0p10_minus_p20 \| t1p01_minus_p21 \|
		157	// t0*p11_minus_p21 \| xstepdenominv \|
		158	// p00_minus_p20 \| p11_minus_p21
		159	fmul %st(5),%st(0) // t1p00_minus_p20 \| t0p10_minus_p20 \|
		160	// t1p01_minus_p21 \| t0p11_minus_p21 \|
		161	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		162	fxch %st(2) // t1p01_minus_p21 \| t0p10_minus_p20 \|
		163	// t1p00_minus_p20 \| t0p11_minus_p21 \|
		164	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		165	fsubp %st(0),%st(3) // t0p10_minus_p20 \| t1p00_minus_p20 \|
		166	// t1p01_minus_p21 - t0p11_minus_p21 \|
		167	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		168	fsubrp %st(0),%st(1) // t1p00_minus_p20 - t0p10_minus_p20 \|
		169	// t1p01_minus_p21 - t0p11_minus_p21 \|
		170	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		171	fld %st(2) // xstepdenominv \|
		172	// t1p00_minus_p20 - t0p10_minus_p20 \|
		173	// t1p01_minus_p21 - t0p11_minus_p21 \|
		174	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		175	fmuls float_minus_1 // ystepdenominv \|
		176	// t1p00_minus_p20 - t0p10_minus_p20 \|
		177	// t1p01_minus_p21 - t0p11_minus_p21 \|
		178	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		179	fxch %st(2) // t1p01_minus_p21 - t0p11_minus_p21 \|
		180	// t1p00_minus_p20 - t0p10_minus_p20 \|
		181	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		182	// p11_minus_p21
		183	fmul %st(3),%st(0) // (t1p01_minus_p21 - t0p11_minus_p21)*
		184	// xstepdenominv \|
		185	// t1p00_minus_p20 - t0p10_minus_p20 \|
		186	// \| ystepdenominv \| xstepdenominv \|
		187	// p00_minus_p20 \| p11_minus_p21
		188	fxch %st(1) // t1p00_minus_p20 - t0p10_minus_p20 \|
		189	// (t1p01_minus_p21 - t0p11_minus_p21)*
		190	// xstepdenominv \| ystepdenominv \|
		191	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		192	fmul %st(2),%st(0) // (t1p00_minus_p20 - t0p10_minus_p20)*
		193	// ystepdenominv \|
		194	// (t1p01_minus_p21 - t0p11_minus_p21)*
		195	// xstepdenominv \| ystepdenominv \|
		196	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		197	fldcw ceil_cw
		198	fistpl C(r_lstepy) // r_lstepx \| ystepdenominv \| xstepdenominv \|
		199	// p00_minus_p20 \| p11_minus_p21
		200	fistpl C(r_lstepx) // ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		201	// p11_minus_p21
		202	fldcw single_cw
		203
		204	// t0 = r_p0[2] - r_p2[2];
		205	// t1 = r_p1[2] - r_p2[2];
		206
		207	fildl C(r_p2)+8 // r_p2[2] \| ystepdenominv \| xstepdenominv \|
		208	// p00_minus_p20 \| p11_minus_p21
		209	fildl C(r_p0)+8 // r_p0[2] \| r_p2[2] \| ystepdenominv \|
		210	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		211	fildl C(r_p1)+8 // r_p1[2] \| r_p0[2] \| r_p2[2] \| ystepdenominv \|
		212	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		213	fxch %st(2) // r_p2[2] \| r_p0[2] \| r_p1[2] \| ystepdenominv \|
		214	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		215	fld %st(0) // r_p2[2] \| r_p2[2] \| r_p0[2] \| r_p1[2] \|
		216	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		217	// p11_minus_p21
		218	fsubrp %st(0),%st(2) // r_p2[2] \| t0 \| r_p1[2] \| ystepdenominv \|
		219	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		220	fsubrp %st(0),%st(2) // t0 \| t1 \| ystepdenominv \| xstepdenominv \|
		221	// p00_minus_p20 \| p11_minus_p21
		222
		223	// r_sstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
		224	// xstepdenominv);
		225	// r_sstepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
		226	// ystepdenominv);
		227
		228	fld %st(0) // t0 \| t0 \| t1 \| ystepdenominv \| xstepdenominv
		229	fmul %st(6),%st(0) // t0*p11_minus_p21 \| t0 \| t1 \| ystepdenominv \|
		230	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		231	fxch %st(2) // t1 \| t0 \| t0*p11_minus_p21 \| ystepdenominv \|
		232	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		233	fld %st(0) // t1 \| t1 \| t0 \| t0*p11_minus_p21 \|
		234	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		235	// p11_minus_p21
		236	fmuls p01_minus_p21 // t1p01_minus_p21 \| t1 \| t0 \| t0p11_minus_p21 \|
		237	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		238	// p11_minus_p21
		239	fxch %st(2) // t0 \| t1 \| t1p01_minus_p21 \| t0p11_minus_p21 \|
		240	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		241	// p11_minus_p21
		242	fmuls p10_minus_p20 // t0p10_minus_p20 \| t1 \| t1p01_minus_p21 \|
		243	// t0*p11_minus_p21 \| ystepdenominv \|
		244	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		245	fxch %st(1) // t1 \| t0p10_minus_p20 \| t1p01_minus_p21 \|
		246	// t0*p11_minus_p21 \| ystepdenominv \|
		247	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		248	fmul %st(6),%st(0) // t1p00_minus_p20 \| t0p10_minus_p20 \|
		249	// t1p01_minus_p21 \| t0p11_minus_p21 \|
		250	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		251	// p11_minus_p21
		252	fxch %st(2) // t1p01_minus_p21 \| t0p10_minus_p20 \|
		253	// t1p00_minus_p20 \| t0p11_minus_p21 \|
		254	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		255	// p11_minus_p21
		256	fsubp %st(0),%st(3) // t0p10_minus_p20 \| t1p00_minus_p20 \|
		257	// t1p01_minus_p21 - t0p11_minus_p21 \|
		258	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		259	// p11_minus_p21
		260	fsubrp %st(0),%st(1) // t1p00_minus_p20 - t0p10_minus_p20 \|
		261	// t1p01_minus_p21 - t0p11_minus_p21 \|
		262	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		263	// p11_minus_p21
		264	fmul %st(2),%st(0) // (t1p00_minus_p20 - t0p10_minus_p20)*
		265	// ystepdenominv \|
		266	// t1p01_minus_p21 - t0p11_minus_p21 \|
		267	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		268	// p11_minus_p21
		269	fxch %st(1) // t1p01_minus_p21 - t0p11_minus_p21 \|
		270	// (t1p00_minus_p20 - t0p10_minus_p20)*
		271	// ystepdenominv \| ystepdenominv \|
		272	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		273	fmul %st(3),%st(0) // (t1p01_minus_p21 - t0p11_minus_p21)*
		274	// xstepdenominv \|
		275	// (t1p00_minus_p20 - t0p10_minus_p20)*
		276	// ystepdenominv \| ystepdenominv \|
		277	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		278	fxch %st(1) // (t1p00_minus_p20 - t0p10_minus_p20)*
		279	// ystepdenominv \|
		280	// (t1p01_minus_p21 - t0p11_minus_p21)*
		281	// xstepdenominv \| ystepdenominv \|
		282	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		283	fistpl C(r_sstepy) // r_sstepx \| ystepdenominv \| xstepdenominv \|
		284	// p00_minus_p20 \| p11_minus_p21
		285	fistpl C(r_sstepx) // ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		286	// p11_minus_p21
		287
		288	// t0 = r_p0[3] - r_p2[3];
		289	// t1 = r_p1[3] - r_p2[3];
		290
		291	fildl C(r_p2)+12 // r_p2[3] \| ystepdenominv \| xstepdenominv \|
		292	// p00_minus_p20 \| p11_minus_p21
		293	fildl C(r_p0)+12 // r_p0[3] \| r_p2[3] \| ystepdenominv \|
		294	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		295	fildl C(r_p1)+12 // r_p1[3] \| r_p0[3] \| r_p2[3] \| ystepdenominv \|
		296	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		297	fxch %st(2) // r_p2[3] \| r_p0[3] \| r_p1[3] \| ystepdenominv \|
		298	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		299	fld %st(0) // r_p2[3] \| r_p2[3] \| r_p0[3] \| r_p1[3] \|
		300	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		301	// p11_minus_p21
		302	fsubrp %st(0),%st(2) // r_p2[3] \| t0 \| r_p1[3] \| ystepdenominv \|
		303	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		304	fsubrp %st(0),%st(2) // t0 \| t1 \| ystepdenominv \| xstepdenominv \|
		305	// p00_minus_p20 \| p11_minus_p21
		306
		307	// r_tstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
		308	// xstepdenominv);
		309	// r_tstepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
		310	// ystepdenominv);
		311
		312	fld %st(0) // t0 \| t0 \| t1 \| ystepdenominv \| xstepdenominv \|
		313	// p00_minus_p20 \| p11_minus_p21
		314	fmul %st(6),%st(0) // t0*p11_minus_p21 \| t0 \| t1 \| ystepdenominv \|
		315	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		316	fxch %st(2) // t1 \| t0 \| t0*p11_minus_p21 \| ystepdenominv \|
		317	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		318	fld %st(0) // t1 \| t1 \| t0 \| t0*p11_minus_p21 \|
		319	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		320	// p11_minus_p21
		321	fmuls p01_minus_p21 // t1p01_minus_p21 \| t1 \| t0 \| t0p11_minus_p21 \|
		322	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		323	// p11_minus_p21
		324	fxch %st(2) // t0 \| t1 \| t1p01_minus_p21 \| t0p11_minus_p21 \|
		325	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		326	// p11_minus_p21
		327	fmuls p10_minus_p20 // t0p10_minus_p20 \| t1 \| t1p01_minus_p21 \|
		328	// t0*p11_minus_p21 \| ystepdenominv \|
		329	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		330	fxch %st(1) // t1 \| t0p10_minus_p20 \| t1p01_minus_p21 \|
		331	// t0*p11_minus_p21 \| ystepdenominv \|
		332	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		333	fmul %st(6),%st(0) // t1p00_minus_p20 \| t0p10_minus_p20 \|
		334	// t1p01_minus_p21 \| t0p11_minus_p21 \|
		335	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		336	// p11_minus_p21
		337	fxch %st(2) // t1p01_minus_p21 \| t0p10_minus_p20 \|
		338	// t1p00_minus_p20 \| t0p11_minus_p21 \|
		339	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		340	// p11_minus_p21
		341	fsubp %st(0),%st(3) // t0p10_minus_p20 \| t1p00_minus_p20 \|
		342	// t1p01_minus_p21 - t0p11_minus_p21 \|
		343	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		344	// p11_minus_p21
		345	fsubrp %st(0),%st(1) // t1p00_minus_p20 - t0p10_minus_p20 \|
		346	// t1p01_minus_p21 - t0p11_minus_p21 \|
		347	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		348	// p11_minus_p21
		349	fmul %st(2),%st(0) // (t1p00_minus_p20 - t0p10_minus_p20)*
		350	// ystepdenominv \|
		351	// t1p01_minus_p21 - t0p11_minus_p21 \|
		352	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		353	// p11_minus_p21
		354	fxch %st(1) // t1p01_minus_p21 - t0p11_minus_p21 \|
		355	// (t1p00_minus_p20 - t0p10_minus_p20)*
		356	// ystepdenominv \| ystepdenominv \|
		357	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		358	fmul %st(3),%st(0) // (t1p01_minus_p21 - t0p11_minus_p21)*
		359	// xstepdenominv \|
		360	// (t1p00_minus_p20 - t0p10_minus_p20)*
		361	// ystepdenominv \| ystepdenominv \|
		362	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		363	fxch %st(1) // (t1p00_minus_p20 - t0p10_minus_p20)*
		364	// ystepdenominv \|
		365	// (t1p01_minus_p21 - t0p11_minus_p21)*
		366	// xstepdenominv \| ystepdenominv \|
		367	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		368	fistpl C(r_tstepy) // r_tstepx \| ystepdenominv \| xstepdenominv \|
		369	// p00_minus_p20 \| p11_minus_p21
		370	fistpl C(r_tstepx) // ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		371	// p11_minus_p21
		372
		373	// t0 = r_p0[5] - r_p2[5];
		374	// t1 = r_p1[5] - r_p2[5];
		375
		376	fildl C(r_p2)+20 // r_p2[5] \| ystepdenominv \| xstepdenominv \|
		377	// p00_minus_p20 \| p11_minus_p21
		378	fildl C(r_p0)+20 // r_p0[5] \| r_p2[5] \| ystepdenominv \|
		379	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		380	fildl C(r_p1)+20 // r_p1[5] \| r_p0[5] \| r_p2[5] \| ystepdenominv \|
		381	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		382	fxch %st(2) // r_p2[5] \| r_p0[5] \| r_p1[5] \| ystepdenominv \|
		383	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		384	fld %st(0) // r_p2[5] \| r_p2[5] \| r_p0[5] \| r_p1[5] \|
		385	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		386	// p11_minus_p21
		387	fsubrp %st(0),%st(2) // r_p2[5] \| t0 \| r_p1[5] \| ystepdenominv \|
		388	// xstepdenominv \| p00_minus_p20 \| p11_minus_p21
		389	fsubrp %st(0),%st(2) // t0 \| t1 \| ystepdenominv \| xstepdenominv \|
		390	// p00_minus_p20 \| p11_minus_p21
		391
		392	// r_zistepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
		393	// xstepdenominv);
		394	// r_zistepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
		395	// ystepdenominv);
		396
		397	fld %st(0) // t0 \| t0 \| t1 \| ystepdenominv \| xstepdenominv \|
		398	// p00_minus_p20 \| p11_minus_p21
		399	fmulp %st(0),%st(6) // t0 \| t1 \| ystepdenominv \| xstepdenominv \|
		400	// p00_minus_p20 \| t0*p11_minus_p21
		401	fxch %st(1) // t1 \| t0 \| ystepdenominv \| xstepdenominv \|
		402	// p00_minus_p20 \| t0*p11_minus_p21
		403	fld %st(0) // t1 \| t1 \| t0 \| ystepdenominv \| xstepdenominv \|
		404	// p00_minus_p20 \| t0*p11_minus_p21
		405	fmuls p01_minus_p21 // t1*p01_minus_p21 \| t1 \| t0 \| ystepdenominv \|
		406	// xstepdenominv \| p00_minus_p20 \|
		407	// t0*p11_minus_p21
		408	fxch %st(2) // t0 \| t1 \| t1*p01_minus_p21 \| ystepdenominv \|
		409	// xstepdenominv \| p00_minus_p20 \|
		410	// t0*p11_minus_p21
		411	fmuls p10_minus_p20 // t0p10_minus_p20 \| t1 \| t1p01_minus_p21 \|
		412	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		413	// t0*p11_minus_p21
		414	fxch %st(1) // t1 \| t0p10_minus_p20 \| t1p01_minus_p21 \|
		415	// ystepdenominv \| xstepdenominv \| p00_minus_p20 \|
		416	// t0*p11_minus_p21
		417	fmulp %st(0),%st(5) // t0p10_minus_p20 \| t1p01_minus_p21 \|
		418	// ystepdenominv \| xstepdenominv \|
		419	// t1p00_minus_p20 \| t0p11_minus_p21
		420	fxch %st(5) // t0p11_minus_p21 \| t1p01_minus_p21 \|
		421	// ystepdenominv \| xstepdenominv \|
		422	// t1p00_minus_p20 \| t0p10_minus_p20
		423	fsubrp %st(0),%st(1) // t1p01_minus_p21 - t0p11_minus_p21 \|
		424	// ystepdenominv \| xstepdenominv \|
		425	// t1p00_minus_p20 \| t0p10_minus_p20
		426	fxch %st(3) // t1*p00_minus_p20 \| ystepdenominv \|
		427	// xstepdenominv \|
		428	// t1p01_minus_p21 - t0p11_minus_p21 \|
		429	// t0*p10_minus_p20
		430	fsubp %st(0),%st(4) // ystepdenominv \| xstepdenominv \|
		431	// t1p01_minus_p21 - t0p11_minus_p21 \|
		432	// t1p00_minus_p20 - t0p10_minus_p20
		433	fxch %st(1) // xstepdenominv \| ystepdenominv \|
		434	// t1p01_minus_p21 - t0p11_minus_p21 \|
		435	// t1p00_minus_p20 - t0p10_minus_p20
		436	fmulp %st(0),%st(2) // ystepdenominv \|
		437	// (t1p01_minus_p21 - t0p11_minus_p21) *
		438	// xstepdenominv \|
		439	// t1p00_minus_p20 - t0p10_minus_p20
		440	fmulp %st(0),%st(2) // (t1p01_minus_p21 - t0p11_minus_p21) *
		441	// xstepdenominv \|
		442	// (t1p00_minus_p20 - t0p10_minus_p20) *
		443	// ystepdenominv
		444	fistpl C(r_zistepx) // (t1p00_minus_p20 - t0p10_minus_p20) *
		445	// ystepdenominv
		446	fistpl C(r_zistepy)
		447
		448	// a_sstepxfrac = r_sstepx << 16;
		449	// a_tstepxfrac = r_tstepx << 16;
		450	//
		451	// a_ststepxwhole = r_affinetridesc.skinwidth * (r_tstepx >> 16) +
		452	// (r_sstepx >> 16);
		453
		454	movl C(r_sstepx),%eax
		455	movl C(r_tstepx),%edx
		456	shll $16,%eax
		457	shll $16,%edx
		458	movl %eax,C(a_sstepxfrac)
		459	movl %edx,C(a_tstepxfrac)
		460
		461	movl C(r_sstepx),%ecx
		462	movl C(r_tstepx),%eax
		463	sarl $16,%ecx
		464	sarl $16,%eax
		465	imull skinwidth(%esp)
		466	addl %ecx,%eax
		467	movl %eax,C(a_ststepxwhole)
		468
		469	ret
		470
		471
		472	//----------------------------------------------------------------------
		473	// recursive subdivision affine triangle drawing code
		474	//
		475	// not C-callable because of stdcall return
		476	//----------------------------------------------------------------------
		477
		478	#define lp1 4+16
		479	#define lp2 8+16
		480	#define lp3 12+16
		481
		482	.globl C(D_PolysetRecursiveTriangle)
		483	C(D_PolysetRecursiveTriangle):
		484	pushl %ebp // preserve caller stack frame pointer
		485	pushl %esi // preserve register variables
		486	pushl %edi
		487	pushl %ebx
		488
		489	// int *temp;
		490	// int d;
		491	// int new[6];
		492	// int i;
		493	// int z;
		494	// short *zbuf;
		495	movl lp2(%esp),%esi
		496	movl lp1(%esp),%ebx
		497	movl lp3(%esp),%edi
		498
		499	// d = lp2[0] - lp1[0];
		500	// if (d < -1 \|\| d > 1)
		501	// goto split;
		502	movl 0(%esi),%eax
		503
		504	movl 0(%ebx),%edx
		505	movl 4(%esi),%ebp
		506
		507	subl %edx,%eax
		508	movl 4(%ebx),%ecx
		509
		510	subl %ecx,%ebp
		511	incl %eax
		512
		513	cmpl $2,%eax
		514	ja LSplit
		515
		516	// d = lp2[1] - lp1[1];
		517	// if (d < -1 \|\| d > 1)
		518	// goto split;
		519	movl 0(%edi),%eax
		520	incl %ebp
		521
		522	cmpl $2,%ebp
		523	ja LSplit
		524
		525	// d = lp3[0] - lp2[0];
		526	// if (d < -1 \|\| d > 1)
		527	// goto split2;
		528	movl 0(%esi),%edx
		529	movl 4(%edi),%ebp
		530
		531	subl %edx,%eax
		532	movl 4(%esi),%ecx
		533
		534	subl %ecx,%ebp
		535	incl %eax
		536
		537	cmpl $2,%eax
		538	ja LSplit2
		539
		540	// d = lp3[1] - lp2[1];
		541	// if (d < -1 \|\| d > 1)
		542	// goto split2;
		543	movl 0(%ebx),%eax
		544	incl %ebp
		545
		546	cmpl $2,%ebp
		547	ja LSplit2
		548
		549	// d = lp1[0] - lp3[0];
		550	// if (d < -1 \|\| d > 1)
		551	// goto split3;
		552	movl 0(%edi),%edx
		553	movl 4(%ebx),%ebp
		554
		555	subl %edx,%eax
		556	movl 4(%edi),%ecx
		557
		558	subl %ecx,%ebp
		559	incl %eax
		560
		561	incl %ebp
		562	movl %ebx,%edx
		563
		564	cmpl $2,%eax
		565	ja LSplit3
		566
		567	// d = lp1[1] - lp3[1];
		568	// if (d < -1 \|\| d > 1)
		569	// {
		570	//split3:
		571	// temp = lp1;
		572	// lp3 = lp2;
		573	// lp1 = lp3;
		574	// lp2 = temp;
		575	// goto split;
		576	// }
		577	//
		578	// return; // entire tri is filled
		579	//
		580	cmpl $2,%ebp
		581	jna LDone
		582
		583	LSplit3:
		584	movl %edi,%ebx
		585	movl %esi,%edi
		586	movl %edx,%esi
		587	jmp LSplit
		588
		589	//split2:
		590	LSplit2:
		591
		592	// temp = lp1;
		593	// lp1 = lp2;
		594	// lp2 = lp3;
		595	// lp3 = temp;
		596	movl %ebx,%eax
		597	movl %esi,%ebx
		598	movl %edi,%esi
		599	movl %eax,%edi
		600
		601	//split:
		602	LSplit:
		603
		604	subl $24,%esp // allocate space for a new vertex
		605
		606	//// split this edge
		607	// new[0] = (lp1[0] + lp2[0]) >> 1;
		608	// new[1] = (lp1[1] + lp2[1]) >> 1;
		609	// new[2] = (lp1[2] + lp2[2]) >> 1;
		610	// new[3] = (lp1[3] + lp2[3]) >> 1;
		611	// new[5] = (lp1[5] + lp2[5]) >> 1;
		612	movl 8(%ebx),%eax
		613
		614	movl 8(%esi),%edx
		615	movl 12(%ebx),%ecx
		616
		617	addl %edx,%eax
		618	movl 12(%esi),%edx
		619
		620	sarl $1,%eax
		621	addl %edx,%ecx
		622
		623	movl %eax,8(%esp)
		624	movl 20(%ebx),%eax
		625
		626	sarl $1,%ecx
		627	movl 20(%esi),%edx
		628
		629	movl %ecx,12(%esp)
		630	addl %edx,%eax
		631
		632	movl 0(%ebx),%ecx
		633	movl 0(%esi),%edx
		634
		635	sarl $1,%eax
		636	addl %ecx,%edx
		637
		638	movl %eax,20(%esp)
		639	movl 4(%ebx),%eax
		640
		641	sarl $1,%edx
		642	movl 4(%esi),%ebp
		643
		644	movl %edx,0(%esp)
		645	addl %eax,%ebp
		646
		647	sarl $1,%ebp
		648	movl %ebp,4(%esp)
		649
		650	//// draw the point if splitting a leading edge
		651	// if (lp2[1] > lp1[1])
		652	// goto nodraw;
		653	cmpl %eax,4(%esi)
		654	jg LNoDraw
		655
		656	// if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0]))
		657	// goto nodraw;
		658	movl 0(%esi),%edx
		659	jnz LDraw
		660
		661	cmpl %ecx,%edx
		662	jl LNoDraw
		663
		664	LDraw:
		665
		666	// z = new[5] >> 16;
		667	movl 20(%esp),%edx
		668	movl 4(%esp),%ecx
		669
		670	sarl $16,%edx
		671	movl 0(%esp),%ebp
		672
		673	// zbuf = zspantable[new[1]] + new[0];
		674	movl C(zspantable)(,%ecx,4),%eax
		675
		676	// if (z >= *zbuf)
		677	// {
		678	cmpw (%eax,%ebp,2),%dx
		679	jnge LNoDraw
		680
		681	// int pix;
		682	//
		683	// *zbuf = z;
		684	movw %dx,(%eax,%ebp,2)
		685
		686	// pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]];
		687	movl 12(%esp),%eax
		688
		689	sarl $16,%eax
		690	movl 8(%esp),%edx
		691
		692	sarl $16,%edx
		693	subl %ecx,%ecx
		694
		695	movl C(skintable)(,%eax,4),%eax
		696	movl 4(%esp),%ebp
		697
		698	movb (%eax,%edx,),%cl
		699	movl C(d_pcolormap),%edx
		700
		701	movb (%edx,%ecx,),%dl
		702	movl 0(%esp),%ecx
		703
		704	// d_viewbuffer[d_scantable[new[1]] + new[0]] = pix;
		705	movl C(d_scantable)(,%ebp,4),%eax
		706	addl %eax,%ecx
		707	movl C(d_viewbuffer),%eax
		708	movb %dl,(%eax,%ecx,1)
		709
		710	// }
		711	//
		712	//nodraw:
		713	LNoDraw:
		714
		715	//// recursively continue
		716	// D_PolysetRecursiveTriangle (lp3, lp1, new);
		717	pushl %esp
		718	pushl %ebx
		719	pushl %edi
		720	call C(D_PolysetRecursiveTriangle)
		721
		722	// D_PolysetRecursiveTriangle (lp3, new, lp2);
		723	movl %esp,%ebx
		724	pushl %esi
		725	pushl %ebx
		726	pushl %edi
		727	call C(D_PolysetRecursiveTriangle)
		728	addl $24,%esp
		729
		730	LDone:
		731	popl %ebx // restore register variables
		732	popl %edi
		733	popl %esi
		734	popl %ebp // restore caller stack frame pointer
		735	ret $12
		736
		737
		738	//----------------------------------------------------------------------
		739	// 8-bpp horizontal span drawing code for affine polygons, with smooth
		740	// shading and no transparency
		741	//----------------------------------------------------------------------
		742
		743	#define pspans 4+8
		744
		745	.globl C(D_PolysetAff8Start)
		746	C(D_PolysetAff8Start):
		747
		748	.globl C(D_PolysetDrawSpans8)
		749	C(D_PolysetDrawSpans8):
		750	pushl %esi // preserve register variables
		751	pushl %ebx
		752
		753	movl pspans(%esp),%esi // point to the first span descriptor
		754	movl C(r_zistepx),%ecx
		755
		756	pushl %ebp // preserve caller's stack frame
		757	pushl %edi
		758
		759	rorl $16,%ecx // put high 16 bits of 1/z step in low word
		760	movl spanpackage_t_count(%esi),%edx
		761
		762	movl %ecx,lzistepx
		763
		764	LSpanLoop:
		765
		766	// lcount = d_aspancount - pspanpackage->count;
		767	//
		768	// errorterm += erroradjustup;
		769	// if (errorterm >= 0)
		770	// {
		771	// d_aspancount += d_countextrastep;
		772	// errorterm -= erroradjustdown;
		773	// }
		774	// else
		775	// {
		776	// d_aspancount += ubasestep;
		777	// }
		778	movl C(d_aspancount),%eax
		779	subl %edx,%eax
		780
		781	movl C(erroradjustup),%edx
		782	movl C(errorterm),%ebx
		783	addl %edx,%ebx
		784	js LNoTurnover
		785
		786	movl C(erroradjustdown),%edx
		787	movl C(d_countextrastep),%edi
		788	subl %edx,%ebx
		789	movl C(d_aspancount),%ebp
		790	movl %ebx,C(errorterm)
		791	addl %edi,%ebp
		792	movl %ebp,C(d_aspancount)
		793	jmp LRightEdgeStepped
		794
		795	LNoTurnover:
		796	movl C(d_aspancount),%edi
		797	movl C(ubasestep),%edx
		798	movl %ebx,C(errorterm)
		799	addl %edx,%edi
		800	movl %edi,C(d_aspancount)
		801
		802	LRightEdgeStepped:
		803	cmpl $1,%eax
		804
		805	jl LNextSpan
		806	jz LExactlyOneLong
		807
		808	//
		809	// set up advancetable
		810	//
		811	movl C(a_ststepxwhole),%ecx
		812	movl C(r_affinetridesc)+atd_skinwidth,%edx
		813
		814	movl %ecx,advancetable+4 // advance base in t
		815	addl %edx,%ecx
		816
		817	movl %ecx,advancetable // advance extra in t
		818	movl C(a_tstepxfrac),%ecx
		819
		820	movw C(r_lstepx),%cx
		821	movl %eax,%edx // count
		822
		823	movl %ecx,tstep
		824	addl $7,%edx
		825
		826	shrl $3,%edx // count of full and partial loops
		827	movl spanpackage_t_sfrac(%esi),%ebx
		828
		829	movw %dx,%bx
		830	movl spanpackage_t_pz(%esi),%ecx
		831
		832	negl %eax
		833
		834	movl spanpackage_t_pdest(%esi),%edi
		835	andl $7,%eax // 0->0, 1->7, 2->6, ... , 7->1
		836
		837	subl %eax,%edi // compensate for hardwired offsets
		838	subl %eax,%ecx
		839
		840	subl %eax,%ecx
		841	movl spanpackage_t_tfrac(%esi),%edx
		842
		843	movw spanpackage_t_light(%esi),%dx
		844	movl spanpackage_t_zi(%esi),%ebp
		845
		846	rorl $16,%ebp // put high 16 bits of 1/z in low word
		847	pushl %esi
		848
		849	movl spanpackage_t_ptex(%esi),%esi
		850	jmp aff8entryvec_table(,%eax,4)
		851
		852	// %bx = count of full and partial loops
		853	// %ebx high word = sfrac
		854	// %ecx = pz
		855	// %dx = light
		856	// %edx high word = tfrac
		857	// %esi = ptex
		858	// %edi = pdest
		859	// %ebp = 1/z
		860	// tstep low word = C(r_lstepx)
		861	// tstep high word = C(a_tstepxfrac)
		862	// C(a_sstepxfrac) low word = 0
		863	// C(a_sstepxfrac) high word = C(a_sstepxfrac)
		864
		865	LDrawLoop:
		866
		867	// FIXME: do we need to clamp light? We may need at least a buffer bit to
		868	// keep it from poking into tfrac and causing problems
		869
		870	LDraw8:
		871	cmpw (%ecx),%bp
		872	jl Lp1
		873	xorl %eax,%eax
		874	movb %dh,%ah
		875	movb (%esi),%al
		876	movw %bp,(%ecx)
		877	movb 0x12345678(%eax),%al
		878	LPatch8:
		879	movb %al,(%edi)
		880	Lp1:
		881	addl tstep,%edx
		882	sbbl %eax,%eax
		883	addl lzistepx,%ebp
		884	adcl $0,%ebp
		885	addl C(a_sstepxfrac),%ebx
		886	adcl advancetable+4(,%eax,4),%esi
		887
		888	LDraw7:
		889	cmpw 2(%ecx),%bp
		890	jl Lp2
		891	xorl %eax,%eax
		892	movb %dh,%ah
		893	movb (%esi),%al
		894	movw %bp,2(%ecx)
		895	movb 0x12345678(%eax),%al
		896	LPatch7:
		897	movb %al,1(%edi)
		898	Lp2:
		899	addl tstep,%edx
		900	sbbl %eax,%eax
		901	addl lzistepx,%ebp
		902	adcl $0,%ebp
		903	addl C(a_sstepxfrac),%ebx
		904	adcl advancetable+4(,%eax,4),%esi
		905
		906	LDraw6:
		907	cmpw 4(%ecx),%bp
		908	jl Lp3
		909	xorl %eax,%eax
		910	movb %dh,%ah
		911	movb (%esi),%al
		912	movw %bp,4(%ecx)
		913	movb 0x12345678(%eax),%al
		914	LPatch6:
		915	movb %al,2(%edi)
		916	Lp3:
		917	addl tstep,%edx
		918	sbbl %eax,%eax
		919	addl lzistepx,%ebp
		920	adcl $0,%ebp
		921	addl C(a_sstepxfrac),%ebx
		922	adcl advancetable+4(,%eax,4),%esi
		923
		924	LDraw5:
		925	cmpw 6(%ecx),%bp
		926	jl Lp4
		927	xorl %eax,%eax
		928	movb %dh,%ah
		929	movb (%esi),%al
		930	movw %bp,6(%ecx)
		931	movb 0x12345678(%eax),%al
		932	LPatch5:
		933	movb %al,3(%edi)
		934	Lp4:
		935	addl tstep,%edx
		936	sbbl %eax,%eax
		937	addl lzistepx,%ebp
		938	adcl $0,%ebp
		939	addl C(a_sstepxfrac),%ebx
		940	adcl advancetable+4(,%eax,4),%esi
		941
		942	LDraw4:
		943	cmpw 8(%ecx),%bp
		944	jl Lp5
		945	xorl %eax,%eax
		946	movb %dh,%ah
		947	movb (%esi),%al
		948	movw %bp,8(%ecx)
		949	movb 0x12345678(%eax),%al
		950	LPatch4:
		951	movb %al,4(%edi)
		952	Lp5:
		953	addl tstep,%edx
		954	sbbl %eax,%eax
		955	addl lzistepx,%ebp
		956	adcl $0,%ebp
		957	addl C(a_sstepxfrac),%ebx
		958	adcl advancetable+4(,%eax,4),%esi
		959
		960	LDraw3:
		961	cmpw 10(%ecx),%bp
		962	jl Lp6
		963	xorl %eax,%eax
		964	movb %dh,%ah
		965	movb (%esi),%al
		966	movw %bp,10(%ecx)
		967	movb 0x12345678(%eax),%al
		968	LPatch3:
		969	movb %al,5(%edi)
		970	Lp6:
		971	addl tstep,%edx
		972	sbbl %eax,%eax
		973	addl lzistepx,%ebp
		974	adcl $0,%ebp
		975	addl C(a_sstepxfrac),%ebx
		976	adcl advancetable+4(,%eax,4),%esi
		977
		978	LDraw2:
		979	cmpw 12(%ecx),%bp
		980	jl Lp7
		981	xorl %eax,%eax
		982	movb %dh,%ah
		983	movb (%esi),%al
		984	movw %bp,12(%ecx)
		985	movb 0x12345678(%eax),%al
		986	LPatch2:
		987	movb %al,6(%edi)
		988	Lp7:
		989	addl tstep,%edx
		990	sbbl %eax,%eax
		991	addl lzistepx,%ebp
		992	adcl $0,%ebp
		993	addl C(a_sstepxfrac),%ebx
		994	adcl advancetable+4(,%eax,4),%esi
		995
		996	LDraw1:
		997	cmpw 14(%ecx),%bp
		998	jl Lp8
		999	xorl %eax,%eax
		1000	movb %dh,%ah
		1001	movb (%esi),%al
		1002	movw %bp,14(%ecx)
		1003	movb 0x12345678(%eax),%al
		1004	LPatch1:
		1005	movb %al,7(%edi)
		1006	Lp8:
		1007	addl tstep,%edx
		1008	sbbl %eax,%eax
		1009	addl lzistepx,%ebp
		1010	adcl $0,%ebp
		1011	addl C(a_sstepxfrac),%ebx
		1012	adcl advancetable+4(,%eax,4),%esi
		1013
		1014	addl $8,%edi
		1015	addl $16,%ecx
		1016
		1017	decw %bx
		1018	jnz LDrawLoop
		1019
		1020	popl %esi // restore spans pointer
		1021	LNextSpan:
		1022	addl $(spanpackage_t_size),%esi // point to next span
		1023	LNextSpanESISet:
		1024	movl spanpackage_t_count(%esi),%edx
		1025	cmpl $-999999,%edx // any more spans?
		1026	jnz LSpanLoop // yes
		1027
		1028	popl %edi
		1029	popl %ebp // restore the caller's stack frame
		1030	popl %ebx // restore register variables
		1031	popl %esi
		1032	ret
		1033
		1034
		1035	// draw a one-long span
		1036
		1037	LExactlyOneLong:
		1038
		1039	movl spanpackage_t_pz(%esi),%ecx
		1040	movl spanpackage_t_zi(%esi),%ebp
		1041
		1042	rorl $16,%ebp // put high 16 bits of 1/z in low word
		1043	movl spanpackage_t_ptex(%esi),%ebx
		1044
		1045	cmpw (%ecx),%bp
		1046	jl LNextSpan
		1047	xorl %eax,%eax
		1048	movl spanpackage_t_pdest(%esi),%edi
		1049	movb spanpackage_t_light+1(%esi),%ah
		1050	addl $(spanpackage_t_size),%esi // point to next span
		1051	movb (%ebx),%al
		1052	movw %bp,(%ecx)
		1053	movb 0x12345678(%eax),%al
		1054	LPatch9:
		1055	movb %al,(%edi)
		1056
		1057	jmp LNextSpanESISet
		1058
		1059	.globl C(D_PolysetAff8End)
		1060	C(D_PolysetAff8End):
		1061
		1062
		1063	#define pcolormap 4
		1064
		1065	.globl C(D_Aff8Patch)
		1066	C(D_Aff8Patch):
		1067	movl pcolormap(%esp),%eax
		1068	movl %eax,LPatch1-4
		1069	movl %eax,LPatch2-4
		1070	movl %eax,LPatch3-4
		1071	movl %eax,LPatch4-4
		1072	movl %eax,LPatch5-4
		1073	movl %eax,LPatch6-4
		1074	movl %eax,LPatch7-4
		1075	movl %eax,LPatch8-4
		1076	movl %eax,LPatch9-4
		1077
		1078	ret
		1079
		1080
		1081	//----------------------------------------------------------------------
		1082	// Alias model polygon dispatching code, combined with subdivided affine
		1083	// triangle drawing code
		1084	//----------------------------------------------------------------------
		1085
		1086	.globl C(D_PolysetDraw)
		1087	C(D_PolysetDraw):
		1088
		1089	// spanpackage_t spans[DPS_MAXSPANS + 1 +
		1090	// ((CACHE_SIZE - 1) / sizeof(spanpackage_t)) + 1];
		1091	// // one extra because of cache line pretouching
		1092	//
		1093	// a_spans = (spanpackage_t *)
		1094	// (((long)&spans[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
		1095	subl $(SPAN_SIZE),%esp
		1096	movl %esp,%eax
		1097	addl $(CACHE_SIZE - 1),%eax
		1098	andl $(~(CACHE_SIZE - 1)),%eax
		1099	movl %eax,C(a_spans)
		1100
		1101	// if (r_affinetridesc.drawtype)
		1102	// D_DrawSubdiv ();
		1103	// else
		1104	// D_DrawNonSubdiv ();
		1105	movl C(r_affinetridesc)+atd_drawtype,%eax
		1106	testl %eax,%eax
		1107	jz C(D_DrawNonSubdiv)
		1108
		1109	pushl %ebp // preserve caller stack frame pointer
		1110
		1111	// lnumtriangles = r_affinetridesc.numtriangles;
		1112	movl C(r_affinetridesc)+atd_numtriangles,%ebp
		1113
		1114	pushl %esi // preserve register variables
		1115	shll $4,%ebp
		1116
		1117	pushl %ebx
		1118	// ptri = r_affinetridesc.ptriangles;
		1119	movl C(r_affinetridesc)+atd_ptriangles,%ebx
		1120
		1121	pushl %edi
		1122
		1123	// mtriangle_t *ptri;
		1124	// finalvert_t pfv, index0, index1, index2;
		1125	// int i;
		1126	// int lnumtriangles;
		1127	// int s0, s1, s2;
		1128
		1129	// pfv = r_affinetridesc.pfinalverts;
		1130	movl C(r_affinetridesc)+atd_pfinalverts,%edi
		1131
		1132	// for (i=0 ; i
		1133	// {
		1134
		1135	Llooptop:
		1136
		1137	// index0 = pfv + ptri[i].vertindex[0];
		1138	// index1 = pfv + ptri[i].vertindex[1];
		1139	// index2 = pfv + ptri[i].vertindex[2];
		1140	movl mtri_vertindex-16+0(%ebx,%ebp,),%ecx
		1141	movl mtri_vertindex-16+4(%ebx,%ebp,),%esi
		1142
		1143	shll $(fv_shift),%ecx
		1144	movl mtri_vertindex-16+8(%ebx,%ebp,),%edx
		1145
		1146	shll $(fv_shift),%esi
		1147	addl %edi,%ecx
		1148
		1149	shll $(fv_shift),%edx
		1150	addl %edi,%esi
		1151
		1152	addl %edi,%edx
		1153
		1154	// if (((index0->v[1]-index1->v[1]) *
		1155	// (index0->v[0]-index2->v[0]) -
		1156	// (index0->v[0]-index1->v[0])*(index0->v[1]-index2->v[1])) >= 0)
		1157	// {
		1158	// continue;
		1159	// }
		1160	//
		1161	// d_pcolormap = &((byte *)acolormap)[index0->v[4] & 0xFF00];
		1162	fildl fv_v+4(%ecx) // i0v1
		1163	fildl fv_v+4(%esi) // i1v1 \| i0v1
		1164	fildl fv_v+0(%ecx) // i0v0 \| i1v1 \| i0v1
		1165	fildl fv_v+0(%edx) // i2v0 \| i0v0 \| i1v1 \| i0v1
		1166	fxch %st(2) // i1v1 \| i0v0 \| i2v0 \| i0v1
		1167	fsubr %st(3),%st(0) // i0v1-i1v1 \| i0v0 \| i2v0 \| i0v1
		1168	fildl fv_v+0(%esi) // i1v0 \| i0v1-i1v1 \| i0v0 \| i2v0 \| i0v1
		1169	fxch %st(2) // i0v0 \| i0v1-i1v1 \| i1v0 \| i2v0 \| i0v1
		1170	fsub %st(0),%st(3) // i0v0 \| i0v1-i1v1 \| i1v0 \| i0v0-i2v0 \| i0v1
		1171	fildl fv_v+4(%edx) // i2v1 \| i0v0 \| i0v1-i1v1 \| i1v0 \| i0v0-i2v0\| i0v1
		1172	fxch %st(1) // i0v0 \| i2v1 \| i0v1-i1v1 \| i1v0 \| i0v0-i2v0\| i0v1
		1173	fsubp %st(0),%st(3) // i2v1 \| i0v1-i1v1 \| i0v0-i1v0 \| i0v0-i2v0 \| i0v1
		1174	fxch %st(1) // i0v1-i1v1 \| i2v1 \| i0v0-i1v0 \| i0v0-i2v0 \| i0v1
		1175	fmulp %st(0),%st(3) // i2v1 \| i0v0-i1v0 \| i0v1-i1v1*i0v0-i2v0 \| i0v1
		1176	fsubrp %st(0),%st(3) // i0v0-i1v0 \| i0v1-i1v1*i0v0-i2v0 \| i0v1-i2v1
		1177	movl fv_v+16(%ecx),%eax
		1178	andl $0xFF00,%eax
		1179	fmulp %st(0),%st(2) // i0v1-i1v1i0v0-i2v0 \| i0v0-i1v0i0v1-i2v1
		1180	addl C(acolormap),%eax
		1181	fsubp %st(0),%st(1) // (i0v1-i1v1)(i0v0-i2v0)-(i0v0-i1v0)(i0v1-i2v1)
		1182	movl %eax,C(d_pcolormap)
		1183	fstps Ltemp
		1184	movl Ltemp,%eax
		1185	subl $0x80000001,%eax
		1186	jc Lskip
		1187
		1188	// if (ptri[i].facesfront)
		1189	// {
		1190	// D_PolysetRecursiveTriangle(index0->v, index1->v, index2->v);
		1191	movl mtri_facesfront-16(%ebx,%ebp,),%eax
		1192	testl %eax,%eax
		1193	jz Lfacesback
		1194
		1195	pushl %edx
		1196	pushl %esi
		1197	pushl %ecx
		1198	call C(D_PolysetRecursiveTriangle)
		1199
		1200	subl $16,%ebp
		1201	jnz Llooptop
		1202	jmp Ldone2
		1203
		1204	// }
		1205	// else
		1206	// {
		1207	Lfacesback:
		1208
		1209	// s0 = index0->v[2];
		1210	// s1 = index1->v[2];
		1211	// s2 = index2->v[2];
		1212	movl fv_v+8(%ecx),%eax
		1213	pushl %eax
		1214	movl fv_v+8(%esi),%eax
		1215	pushl %eax
		1216	movl fv_v+8(%edx),%eax
		1217	pushl %eax
		1218	pushl %ecx
		1219	pushl %edx
		1220
		1221	// if (index0->flags & ALIAS_ONSEAM)
		1222	// index0->v[2] += r_affinetridesc.seamfixupX16;
		1223	movl C(r_affinetridesc)+atd_seamfixupX16,%eax
		1224	testl $(ALIAS_ONSEAM),fv_flags(%ecx)
		1225	jz Lp11
		1226	addl %eax,fv_v+8(%ecx)
		1227	Lp11:
		1228
		1229	// if (index1->flags & ALIAS_ONSEAM)
		1230	// index1->v[2] += r_affinetridesc.seamfixupX16;
		1231	testl $(ALIAS_ONSEAM),fv_flags(%esi)
		1232	jz Lp12
		1233	addl %eax,fv_v+8(%esi)
		1234	Lp12:
		1235
		1236	// if (index2->flags & ALIAS_ONSEAM)
		1237	// index2->v[2] += r_affinetridesc.seamfixupX16;
		1238	testl $(ALIAS_ONSEAM),fv_flags(%edx)
		1239	jz Lp13
		1240	addl %eax,fv_v+8(%edx)
		1241	Lp13:
		1242
		1243	// D_PolysetRecursiveTriangle(index0->v, index1->v, index2->v);
		1244	pushl %edx
		1245	pushl %esi
		1246	pushl %ecx
		1247	call C(D_PolysetRecursiveTriangle)
		1248
		1249	// index0->v[2] = s0;
		1250	// index1->v[2] = s1;
		1251	// index2->v[2] = s2;
		1252	popl %edx
		1253	popl %ecx
		1254	popl %eax
		1255	movl %eax,fv_v+8(%edx)
		1256	popl %eax
		1257	movl %eax,fv_v+8(%esi)
		1258	popl %eax
		1259	movl %eax,fv_v+8(%ecx)
		1260
		1261	// }
		1262	// }
		1263	Lskip:
		1264	subl $16,%ebp
		1265	jnz Llooptop
		1266
		1267	Ldone2:
		1268	popl %edi // restore the caller's stack frame
		1269	popl %ebx
		1270	popl %esi // restore register variables
		1271	popl %ebp
		1272
		1273	addl $(SPAN_SIZE),%esp
		1274
		1275	ret
		1276
		1277
		1278	//----------------------------------------------------------------------
		1279	// Alias model triangle left-edge scanning code
		1280	//----------------------------------------------------------------------
		1281
		1282	#define height 4+16
		1283
		1284	.globl C(D_PolysetScanLeftEdge)
		1285	C(D_PolysetScanLeftEdge):
		1286	pushl %ebp // preserve caller stack frame pointer
		1287	pushl %esi // preserve register variables
		1288	pushl %edi
		1289	pushl %ebx
		1290
		1291	movl height(%esp),%eax
		1292	movl C(d_sfrac),%ecx
		1293	andl $0xFFFF,%eax
		1294	movl C(d_ptex),%ebx
		1295	orl %eax,%ecx
		1296	movl C(d_pedgespanpackage),%esi
		1297	movl C(d_tfrac),%edx
		1298	movl C(d_light),%edi
		1299	movl C(d_zi),%ebp
		1300
		1301	// %eax: scratch
		1302	// %ebx: d_ptex
		1303	// %ecx: d_sfrac in high word, count in low word
		1304	// %edx: d_tfrac
		1305	// %esi: d_pedgespanpackage, errorterm, scratch alternately
		1306	// %edi: d_light
		1307	// %ebp: d_zi
		1308
		1309	// do
		1310	// {
		1311
		1312	LScanLoop:
		1313
		1314	// d_pedgespanpackage->ptex = ptex;
		1315	// d_pedgespanpackage->pdest = d_pdest;
		1316	// d_pedgespanpackage->pz = d_pz;
		1317	// d_pedgespanpackage->count = d_aspancount;
		1318	// d_pedgespanpackage->light = d_light;
		1319	// d_pedgespanpackage->zi = d_zi;
		1320	// d_pedgespanpackage->sfrac = d_sfrac << 16;
		1321	// d_pedgespanpackage->tfrac = d_tfrac << 16;
		1322	movl %ebx,spanpackage_t_ptex(%esi)
		1323	movl C(d_pdest),%eax
		1324	movl %eax,spanpackage_t_pdest(%esi)
		1325	movl C(d_pz),%eax
		1326	movl %eax,spanpackage_t_pz(%esi)
		1327	movl C(d_aspancount),%eax
		1328	movl %eax,spanpackage_t_count(%esi)
		1329	movl %edi,spanpackage_t_light(%esi)
		1330	movl %ebp,spanpackage_t_zi(%esi)
		1331	movl %ecx,spanpackage_t_sfrac(%esi)
		1332	movl %edx,spanpackage_t_tfrac(%esi)
		1333
		1334	// pretouch the next cache line
		1335	movb spanpackage_t_size(%esi),%al
		1336
		1337	// d_pedgespanpackage++;
		1338	addl $(spanpackage_t_size),%esi
		1339	movl C(erroradjustup),%eax
		1340	movl %esi,C(d_pedgespanpackage)
		1341
		1342	// errorterm += erroradjustup;
		1343	movl C(errorterm),%esi
		1344	addl %eax,%esi
		1345	movl C(d_pdest),%eax
		1346
		1347	// if (errorterm >= 0)
		1348	// {
		1349	js LNoLeftEdgeTurnover
		1350
		1351	// errorterm -= erroradjustdown;
		1352	// d_pdest += d_pdestextrastep;
		1353	subl C(erroradjustdown),%esi
		1354	addl C(d_pdestextrastep),%eax
		1355	movl %esi,C(errorterm)
		1356	movl %eax,C(d_pdest)
		1357
		1358	// d_pz += d_pzextrastep;
		1359	// d_aspancount += d_countextrastep;
		1360	// d_ptex += d_ptexextrastep;
		1361	// d_sfrac += d_sfracextrastep;
		1362	// d_ptex += d_sfrac >> 16;
		1363	// d_sfrac &= 0xFFFF;
		1364	// d_tfrac += d_tfracextrastep;
		1365	movl C(d_pz),%eax
		1366	movl C(d_aspancount),%esi
		1367	addl C(d_pzextrastep),%eax
		1368	addl C(d_sfracextrastep),%ecx
		1369	adcl C(d_ptexextrastep),%ebx
		1370	addl C(d_countextrastep),%esi
		1371	movl %eax,C(d_pz)
		1372	movl C(d_tfracextrastep),%eax
		1373	movl %esi,C(d_aspancount)
		1374	addl %eax,%edx
		1375
		1376	// if (d_tfrac & 0x10000)
		1377	// {
		1378	jnc LSkip1
		1379
		1380	// d_ptex += r_affinetridesc.skinwidth;
		1381	// d_tfrac &= 0xFFFF;
		1382	addl C(r_affinetridesc)+atd_skinwidth,%ebx
		1383
		1384	// }
		1385
		1386	LSkip1:
		1387
		1388	// d_light += d_lightextrastep;
		1389	// d_zi += d_ziextrastep;
		1390	addl C(d_lightextrastep),%edi
		1391	addl C(d_ziextrastep),%ebp
		1392
		1393	// }
		1394	movl C(d_pedgespanpackage),%esi
		1395	decl %ecx
		1396	testl $0xFFFF,%ecx
		1397	jnz LScanLoop
		1398
		1399	popl %ebx
		1400	popl %edi
		1401	popl %esi
		1402	popl %ebp
		1403	ret
		1404
		1405	// else
		1406	// {
		1407
		1408	LNoLeftEdgeTurnover:
		1409	movl %esi,C(errorterm)
		1410
		1411	// d_pdest += d_pdestbasestep;
		1412	addl C(d_pdestbasestep),%eax
		1413	movl %eax,C(d_pdest)
		1414
		1415	// d_pz += d_pzbasestep;
		1416	// d_aspancount += ubasestep;
		1417	// d_ptex += d_ptexbasestep;
		1418	// d_sfrac += d_sfracbasestep;
		1419	// d_ptex += d_sfrac >> 16;
		1420	// d_sfrac &= 0xFFFF;
		1421	movl C(d_pz),%eax
		1422	movl C(d_aspancount),%esi
		1423	addl C(d_pzbasestep),%eax
		1424	addl C(d_sfracbasestep),%ecx
		1425	adcl C(d_ptexbasestep),%ebx
		1426	addl C(ubasestep),%esi
		1427	movl %eax,C(d_pz)
		1428	movl %esi,C(d_aspancount)
		1429
		1430	// d_tfrac += d_tfracbasestep;
		1431	movl C(d_tfracbasestep),%esi
		1432	addl %esi,%edx
		1433
		1434	// if (d_tfrac & 0x10000)
		1435	// {
		1436	jnc LSkip2
		1437
		1438	// d_ptex += r_affinetridesc.skinwidth;
		1439	// d_tfrac &= 0xFFFF;
		1440	addl C(r_affinetridesc)+atd_skinwidth,%ebx
		1441
		1442	// }
		1443
		1444	LSkip2:
		1445
		1446	// d_light += d_lightbasestep;
		1447	// d_zi += d_zibasestep;
		1448	addl C(d_lightbasestep),%edi
		1449	addl C(d_zibasestep),%ebp
		1450
		1451	// }
		1452	// } while (--height);
		1453	movl C(d_pedgespanpackage),%esi
		1454	decl %ecx
		1455	testl $0xFFFF,%ecx
		1456	jnz LScanLoop
		1457
		1458	popl %ebx
		1459	popl %edi
		1460	popl %esi
		1461	popl %ebp
		1462	ret
		1463
		1464
		1465	//----------------------------------------------------------------------
		1466	// Alias model vertex drawing code
		1467	//----------------------------------------------------------------------
		1468
		1469	#define fv 4+8
		1470	#define numverts 8+8
		1471
		1472	.globl C(D_PolysetDrawFinalVerts)
		1473	C(D_PolysetDrawFinalVerts):
		1474	pushl %ebp // preserve caller stack frame pointer
		1475	pushl %ebx
		1476
		1477	// int i, z;
		1478	// short *zbuf;
		1479
		1480	movl numverts(%esp),%ecx
		1481	movl fv(%esp),%ebx
		1482
		1483	pushl %esi // preserve register variables
		1484	pushl %edi
		1485
		1486	LFVLoop:
		1487
		1488	// for (i=0 ; i
		1489	// {
		1490	// // valid triangle coordinates for filling can include the bottom and
		1491	// // right clip edges, due to the fill rule; these shouldn't be drawn
		1492	// if ((fv->v[0] < r_refdef.vrectright) &&
		1493	// (fv->v[1] < r_refdef.vrectbottom))
		1494	// {
		1495	movl fv_v+0(%ebx),%eax
		1496	movl C(r_refdef)+rd_vrectright,%edx
		1497	cmpl %edx,%eax
		1498	jge LNextVert
		1499	movl fv_v+4(%ebx),%esi
		1500	movl C(r_refdef)+rd_vrectbottom,%edx
		1501	cmpl %edx,%esi
		1502	jge LNextVert
		1503
		1504	// zbuf = zspantable[fv->v[1]] + fv->v[0];
		1505	movl C(zspantable)(,%esi,4),%edi
		1506
		1507	// z = fv->v[5]>>16;
		1508	movl fv_v+20(%ebx),%edx
		1509	shrl $16,%edx
		1510
		1511	// if (z >= *zbuf)
		1512	// {
		1513	// int pix;
		1514	cmpw (%edi,%eax,2),%dx
		1515	jl LNextVert
		1516
		1517	// *zbuf = z;
		1518	movw %dx,(%edi,%eax,2)
		1519
		1520	// pix = skintable[fv->v[3]>>16][fv->v[2]>>16];
		1521	movl fv_v+12(%ebx),%edi
		1522	shrl $16,%edi
		1523	movl C(skintable)(,%edi,4),%edi
		1524	movl fv_v+8(%ebx),%edx
		1525	shrl $16,%edx
		1526	movb (%edi,%edx),%dl
		1527
		1528	// pix = ((byte *)acolormap)[pix + (fv->v[4] & 0xFF00)];
		1529	movl fv_v+16(%ebx),%edi
		1530	andl $0xFF00,%edi
		1531	andl $0x00FF,%edx
		1532	addl %edx,%edi
		1533	movl C(acolormap),%edx
		1534	movb (%edx,%edi,1),%dl
		1535
		1536	// d_viewbuffer[d_scantable[fv->v[1]] + fv->v[0]] = pix;
		1537	movl C(d_scantable)(,%esi,4),%edi
		1538	movl C(d_viewbuffer),%esi
		1539	addl %eax,%edi
		1540	movb %dl,(%esi,%edi)
		1541
		1542	// }
		1543	// }
		1544	// }
		1545	LNextVert:
		1546	addl $(fv_size),%ebx
		1547	decl %ecx
		1548	jnz LFVLoop
		1549
		1550	popl %edi
		1551	popl %esi
		1552	popl %ebx
		1553	popl %ebp
		1554	ret
		1555
		1556
		1557	//----------------------------------------------------------------------
		1558	// Alias model non-subdivided polygon dispatching code
		1559	//
		1560	// not C-callable because of stack buffer cleanup
		1561	//----------------------------------------------------------------------
		1562
		1563	.globl C(D_DrawNonSubdiv)
		1564	C(D_DrawNonSubdiv):
		1565	pushl %ebp // preserve caller stack frame pointer
		1566	movl C(r_affinetridesc)+atd_numtriangles,%ebp
		1567	pushl %ebx
		1568	shll $(mtri_shift),%ebp
		1569	pushl %esi // preserve register variables
		1570	movl C(r_affinetridesc)+atd_ptriangles,%esi
		1571	pushl %edi
		1572
		1573	// mtriangle_t *ptri;
		1574	// finalvert_t pfv, index0, index1, index2;
		1575	// int i;
		1576	// int lnumtriangles;
		1577
		1578	// pfv = r_affinetridesc.pfinalverts;
		1579	// ptri = r_affinetridesc.ptriangles;
		1580	// lnumtriangles = r_affinetridesc.numtriangles;
		1581
		1582	LNDLoop:
		1583
		1584	// for (i=0 ; i
		1585	// {
		1586	// index0 = pfv + ptri->vertindex[0];
		1587	// index1 = pfv + ptri->vertindex[1];
		1588	// index2 = pfv + ptri->vertindex[2];
		1589	movl C(r_affinetridesc)+atd_pfinalverts,%edi
		1590	movl mtri_vertindex+0-mtri_size(%esi,%ebp,1),%ecx
		1591	shll $(fv_shift),%ecx
		1592	movl mtri_vertindex+4-mtri_size(%esi,%ebp,1),%edx
		1593	shll $(fv_shift),%edx
		1594	movl mtri_vertindex+8-mtri_size(%esi,%ebp,1),%ebx
		1595	shll $(fv_shift),%ebx
		1596	addl %edi,%ecx
		1597	addl %edi,%edx
		1598	addl %edi,%ebx
		1599
		1600	// d_xdenom = (index0->v[1]-index1->v[1]) *
		1601	// (index0->v[0]-index2->v[0]) -
		1602	// (index0->v[0]-index1->v[0])*(index0->v[1]-index2->v[1]);
		1603	movl fv_v+4(%ecx),%eax
		1604	movl fv_v+0(%ecx),%esi
		1605	subl fv_v+4(%edx),%eax
		1606	subl fv_v+0(%ebx),%esi
		1607	imull %esi,%eax
		1608	movl fv_v+0(%ecx),%esi
		1609	movl fv_v+4(%ecx),%edi
		1610	subl fv_v+0(%edx),%esi
		1611	subl fv_v+4(%ebx),%edi
		1612	imull %esi,%edi
		1613	subl %edi,%eax
		1614
		1615	// if (d_xdenom >= 0)
		1616	// {
		1617	// continue;
		1618	jns LNextTri
		1619
		1620	// }
		1621
		1622	movl %eax,C(d_xdenom)
		1623	fildl C(d_xdenom)
		1624
		1625	// r_p0[0] = index0->v[0]; // u
		1626	// r_p0[1] = index0->v[1]; // v
		1627	// r_p0[2] = index0->v[2]; // s
		1628	// r_p0[3] = index0->v[3]; // t
		1629	// r_p0[4] = index0->v[4]; // light
		1630	// r_p0[5] = index0->v[5]; // iz
		1631	movl fv_v+0(%ecx),%eax
		1632	movl fv_v+4(%ecx),%esi
		1633	movl %eax,C(r_p0)+0
		1634	movl %esi,C(r_p0)+4
		1635	movl fv_v+8(%ecx),%eax
		1636	movl fv_v+12(%ecx),%esi
		1637	movl %eax,C(r_p0)+8
		1638	movl %esi,C(r_p0)+12
		1639	movl fv_v+16(%ecx),%eax
		1640	movl fv_v+20(%ecx),%esi
		1641	movl %eax,C(r_p0)+16
		1642	movl %esi,C(r_p0)+20
		1643
		1644	fdivrs float_1
		1645
		1646	// r_p1[0] = index1->v[0];
		1647	// r_p1[1] = index1->v[1];
		1648	// r_p1[2] = index1->v[2];
		1649	// r_p1[3] = index1->v[3];
		1650	// r_p1[4] = index1->v[4];
		1651	// r_p1[5] = index1->v[5];
		1652	movl fv_v+0(%edx),%eax
		1653	movl fv_v+4(%edx),%esi
		1654	movl %eax,C(r_p1)+0
		1655	movl %esi,C(r_p1)+4
		1656	movl fv_v+8(%edx),%eax
		1657	movl fv_v+12(%edx),%esi
		1658	movl %eax,C(r_p1)+8
		1659	movl %esi,C(r_p1)+12
		1660	movl fv_v+16(%edx),%eax
		1661	movl fv_v+20(%edx),%esi
		1662	movl %eax,C(r_p1)+16
		1663	movl %esi,C(r_p1)+20
		1664
		1665	// r_p2[0] = index2->v[0];
		1666	// r_p2[1] = index2->v[1];
		1667	// r_p2[2] = index2->v[2];
		1668	// r_p2[3] = index2->v[3];
		1669	// r_p2[4] = index2->v[4];
		1670	// r_p2[5] = index2->v[5];
		1671	movl fv_v+0(%ebx),%eax
		1672	movl fv_v+4(%ebx),%esi
		1673	movl %eax,C(r_p2)+0
		1674	movl %esi,C(r_p2)+4
		1675	movl fv_v+8(%ebx),%eax
		1676	movl fv_v+12(%ebx),%esi
		1677	movl %eax,C(r_p2)+8
		1678	movl %esi,C(r_p2)+12
		1679	movl fv_v+16(%ebx),%eax
		1680	movl fv_v+20(%ebx),%esi
		1681	movl %eax,C(r_p2)+16
		1682	movl C(r_affinetridesc)+atd_ptriangles,%edi
		1683	movl %esi,C(r_p2)+20
		1684	movl mtri_facesfront-mtri_size(%edi,%ebp,1),%eax
		1685
		1686	// if (!ptri->facesfront)
		1687	// {
		1688	testl %eax,%eax
		1689	jnz LFacesFront
		1690
		1691	// if (index0->flags & ALIAS_ONSEAM)
		1692	// r_p0[2] += r_affinetridesc.seamfixupX16;
		1693	movl fv_flags(%ecx),%eax
		1694	movl fv_flags(%edx),%esi
		1695	movl fv_flags(%ebx),%edi
		1696	testl $(ALIAS_ONSEAM),%eax
		1697	movl C(r_affinetridesc)+atd_seamfixupX16,%eax
		1698	jz LOnseamDone0
		1699	addl %eax,C(r_p0)+8
		1700	LOnseamDone0:
		1701
		1702	// if (index1->flags & ALIAS_ONSEAM)
		1703	// r_p1[2] += r_affinetridesc.seamfixupX16;
		1704	testl $(ALIAS_ONSEAM),%esi
		1705	jz LOnseamDone1
		1706	addl %eax,C(r_p1)+8
		1707	LOnseamDone1:
		1708
		1709	// if (index2->flags & ALIAS_ONSEAM)
		1710	// r_p2[2] += r_affinetridesc.seamfixupX16;
		1711	testl $(ALIAS_ONSEAM),%edi
		1712	jz LOnseamDone2
		1713	addl %eax,C(r_p2)+8
		1714	LOnseamDone2:
		1715
		1716	// }
		1717
		1718	LFacesFront:
		1719
		1720	fstps C(d_xdenom)
		1721
		1722	// D_PolysetSetEdgeTable ();
		1723	// D_RasterizeAliasPolySmooth ();
		1724	call C(D_PolysetSetEdgeTable)
		1725	call C(D_RasterizeAliasPolySmooth)
		1726
		1727	LNextTri:
		1728	movl C(r_affinetridesc)+atd_ptriangles,%esi
		1729	subl $16,%ebp
		1730	jnz LNDLoop
		1731	// }
		1732
		1733	popl %edi
		1734	popl %esi
		1735	popl %ebx
		1736	popl %ebp
		1737
		1738	addl $(SPAN_SIZE),%esp
		1739
		1740	ret
		1741
		1742
		1743	#endif // id386
		1744

Subversion Repositories Kolibri OS

(root)/contrib/other/sdlquake-1.0.9/d_polysa.S @ 5223 – Rev 5131