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