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