1 .386P
2 .model FLAT
3;
4; d_polysa.s
5; x86 assembly-language polygon model drawing code
6;
7
8include qasm.inc
9include d_if.inc
10
11if	id386
12
13; !!! if this is changed, it must be changed in d_polyse.c too !!!
14;DPS_MAXSPANS			equ		(MAXHEIGHT+1)
15; 1 extra for spanpackage that marks end
16
17;SPAN_SIZE	equ		(((DPS_MAXSPANS + 1 + ((CACHE_SIZE - 1) / spanpackage_t_size)) + 1) * spanpackage_t_size)
18
19MASK_1K	equ		03FFh
20
21_DATA SEGMENT
22
23 align 4
24;p10_minus_p20 dd 0
25;p01_minus_p21 dd 0
26;temp0 dd 0
27;temp1 dd 0
28;Ltemp dd 0
29
30aff8entryvec_table dd LDraw8, LDraw7, LDraw6, LDraw5
31 dd LDraw4, LDraw3, LDraw2, LDraw1, LDraw8IR, LDraw7IR, LDraw6IR, LDraw5IR, LDraw4IR, LDraw3IR, LDraw2IR, LDraw1IR
32
33lzistepx dd 0
34
35 externdef _rand1k:dword
36 externdef _rand1k_index:dword
37
38;PGM
39 externdef _irtable:dword
40 externdef _iractive:byte
41;PGM
42
43_DATA ENDS
44_TEXT SEGMENT
45
46
47;----------------------------------------------------------------------
48; 8-bpp horizontal span drawing code for affine polygons, with smooth
49; shading and no transparency
50;----------------------------------------------------------------------
51
52;===================================
53;===================================
54
55pspans	equ		4+8
56
57 public _D_PolysetAff8Start
58_D_PolysetAff8Start:
59
60 public _R_PolysetDrawSpans8_Opaque
61_R_PolysetDrawSpans8_Opaque:
62
63 push esi	; preserve register variables
64 push ebx
65
66 mov esi,ds:dword ptr[pspans+esp]	; point to the first span descriptor
67 mov ecx,ds:dword ptr[_r_zistepx]
68
69 push ebp	; preserve caller's stack frame
70 push edi
71
72 ror ecx,16	; put high 16 bits of 1/z step in low word
73 mov edx,ds:dword ptr[spanpackage_t_count+esi]
74
75 mov ds:dword ptr[lzistepx],ecx
76
77LSpanLoop:
78
79;		lcount = d_aspancount - pspanpackage->count;
80;
81;		errorterm += erroradjustup;
82;		if (errorterm >= 0)
83;		{
84;			d_aspancount += d_countextrastep;
85;			errorterm -= erroradjustdown;
86;		}
87;		else
88;		{
89;			d_aspancount += ubasestep;
90;		}
91
92 mov eax,ds:dword ptr[_d_aspancount]
93 sub eax,edx
94
95 mov edx,ds:dword ptr[_erroradjustup]
96 mov ebx,ds:dword ptr[_errorterm]
97 add ebx,edx
98 js LNoTurnover
99
100 mov edx,ds:dword ptr[_erroradjustdown]
101 mov edi,ds:dword ptr[_d_countextrastep]
102 sub ebx,edx
103 mov ebp,ds:dword ptr[_d_aspancount]
104 mov ds:dword ptr[_errorterm],ebx
105 add ebp,edi
106 mov ds:dword ptr[_d_aspancount],ebp
107 jmp LRightEdgeStepped
108
109LNoTurnover:
110 mov edi,ds:dword ptr[_d_aspancount]
111 mov edx,ds:dword ptr[_ubasestep]
112 mov ds:dword ptr[_errorterm],ebx
113 add edi,edx
114 mov ds:dword ptr[_d_aspancount],edi
115
116LRightEdgeStepped:
117 cmp eax,1
118
119 jl LNextSpan
120 jz LExactlyOneLong
121
122;
123; set up advancetable
124;
125 mov ecx,ds:dword ptr[_a_ststepxwhole]
126 mov edx,ds:dword ptr[_r_affinetridesc+atd_skinwidth]
127
128 mov ds:dword ptr[advancetable+4],ecx	; advance base in t
129 add ecx,edx
130
131 mov ds:dword ptr[advancetable],ecx	; advance extra in t
132 mov ecx,ds:dword ptr[_a_tstepxfrac]
133
134 mov cx,ds:word ptr[_r_lstepx]
135 mov edx,eax	; count
136
137 mov ds:dword ptr[tstep],ecx
138 add edx,7
139
140 shr edx,3	; count of full and partial loops
141 mov ebx,ds:dword ptr[spanpackage_t_sfrac+esi]
142
143 mov bx,dx
144 mov ecx,ds:dword ptr[spanpackage_t_pz+esi]
145
146 neg eax
147
148 mov edi,ds:dword ptr[spanpackage_t_pdest+esi]
149 and eax,7	; 0->0, 1->7, 2->6, ... , 7->1
150
151 sub edi,eax	; compensate for hardwired offsets
152 sub ecx,eax
153
154 sub ecx,eax
155 mov edx,ds:dword ptr[spanpackage_t_tfrac+esi]
156
157 mov dx,ds:word ptr[spanpackage_t_light+esi]
158 mov ebp,ds:dword ptr[spanpackage_t_zi+esi]
159
160 ror ebp,16	; put high 16 bits of 1/z in low word
161 push esi
162
163 push eax
164 mov al, [_iractive]
165 cmp al, 0
166 pop eax
167 jne IRInsert
168
169 mov esi,ds:dword ptr[spanpackage_t_ptex+esi]
170 jmp dword ptr[aff8entryvec_table+eax*4]
171
172IRInsert:
173 mov esi,ds:dword ptr[spanpackage_t_ptex+esi]
174 add eax, 8
175 jmp dword ptr[aff8entryvec_table+eax*4]
176
177; %bx = count of full and partial loops
178; %ebx high word = sfrac
179; %ecx = pz
180; %dx = light
181; %edx high word = tfrac
182; %esi = ptex
183; %edi = pdest
184; %ebp = 1/z
185; tstep low word = C(r_lstepx)
186; tstep high word = C(a_tstepxfrac)
187; C(a_sstepxfrac) low word = 0
188; C(a_sstepxfrac) high word = C(a_sstepxfrac)
189
190;===
191;Standard Draw Loop
192;===
193LDrawLoop:
194
195 mov al,[_iractive]
196 cmp al,0
197 jne LDrawLoopIR
198
199; FIXME: do we need to clamp light? We may need at least a buffer bit to
200; keep it from poking into tfrac and causing problems
201
202LDraw8:
203 cmp bp,ds:word ptr[ecx]
204 jl Lp1
205 xor eax,eax
206 mov ah,dh
207 mov al,ds:byte ptr[esi]
208 mov ds:word ptr[ecx],bp
209 mov al,ds:byte ptr[12345678h+eax]
210LPatch8:
211 mov ds:byte ptr[edi],al
212Lp1:
213 add edx,ds:dword ptr[tstep]
214 sbb eax,eax
215 add ebp,ds:dword ptr[lzistepx]
216 adc ebp,0
217 add ebx,ds:dword ptr[_a_sstepxfrac]
218 adc esi,ds:dword ptr[advancetable+4+eax*4]
219
220LDraw7:
221 cmp bp,ds:word ptr[2+ecx]
222 jl Lp2
223 xor eax,eax
224 mov ah,dh
225 mov al,ds:byte ptr[esi]
226 mov ds:word ptr[2+ecx],bp
227 mov al,ds:byte ptr[12345678h+eax]
228LPatch7:
229 mov ds:byte ptr[1+edi],al
230Lp2:
231 add edx,ds:dword ptr[tstep]
232 sbb eax,eax
233 add ebp,ds:dword ptr[lzistepx]
234 adc ebp,0
235 add ebx,ds:dword ptr[_a_sstepxfrac]
236 adc esi,ds:dword ptr[advancetable+4+eax*4]
237
238LDraw6:
239 cmp bp,ds:word ptr[4+ecx]
240 jl Lp3
241 xor eax,eax
242 mov ah,dh
243 mov al,ds:byte ptr[esi]
244 mov ds:word ptr[4+ecx],bp
245 mov al,ds:byte ptr[12345678h+eax]
246LPatch6:
247 mov ds:byte ptr[2+edi],al
248Lp3:
249 add edx,ds:dword ptr[tstep]
250 sbb eax,eax
251 add ebp,ds:dword ptr[lzistepx]
252 adc ebp,0
253 add ebx,ds:dword ptr[_a_sstepxfrac]
254 adc esi,ds:dword ptr[advancetable+4+eax*4]
255
256LDraw5:
257 cmp bp,ds:word ptr[6+ecx]
258 jl Lp4
259 xor eax,eax
260 mov ah,dh
261 mov al,ds:byte ptr[esi]
262 mov ds:word ptr[6+ecx],bp
263 mov al,ds:byte ptr[12345678h+eax]
264LPatch5:
265 mov ds:byte ptr[3+edi],al
266Lp4:
267 add edx,ds:dword ptr[tstep]
268 sbb eax,eax
269 add ebp,ds:dword ptr[lzistepx]
270 adc ebp,0
271 add ebx,ds:dword ptr[_a_sstepxfrac]
272 adc esi,ds:dword ptr[advancetable+4+eax*4]
273
274LDraw4:
275 cmp bp,ds:word ptr[8+ecx]
276 jl Lp5
277 xor eax,eax
278 mov ah,dh
279 mov al,ds:byte ptr[esi]
280 mov ds:word ptr[8+ecx],bp
281 mov al,ds:byte ptr[12345678h+eax]
282LPatch4:
283 mov ds:byte ptr[4+edi],al
284Lp5:
285 add edx,ds:dword ptr[tstep]
286 sbb eax,eax
287 add ebp,ds:dword ptr[lzistepx]
288 adc ebp,0
289 add ebx,ds:dword ptr[_a_sstepxfrac]
290 adc esi,ds:dword ptr[advancetable+4+eax*4]
291
292LDraw3:
293 cmp bp,ds:word ptr[10+ecx]
294 jl Lp6
295 xor eax,eax
296 mov ah,dh
297 mov al,ds:byte ptr[esi]
298 mov ds:word ptr[10+ecx],bp
299 mov al,ds:byte ptr[12345678h+eax]
300LPatch3:
301 mov ds:byte ptr[5+edi],al
302Lp6:
303 add edx,ds:dword ptr[tstep]
304 sbb eax,eax
305 add ebp,ds:dword ptr[lzistepx]
306 adc ebp,0
307 add ebx,ds:dword ptr[_a_sstepxfrac]
308 adc esi,ds:dword ptr[advancetable+4+eax*4]
309
310LDraw2:
311 cmp bp,ds:word ptr[12+ecx]
312 jl Lp7
313 xor eax,eax
314 mov ah,dh
315 mov al,ds:byte ptr[esi]
316 mov ds:word ptr[12+ecx],bp
317 mov al,ds:byte ptr[12345678h+eax]
318LPatch2:
319 mov ds:byte ptr[6+edi],al
320Lp7:
321 add edx,ds:dword ptr[tstep]
322 sbb eax,eax
323 add ebp,ds:dword ptr[lzistepx]
324 adc ebp,0
325 add ebx,ds:dword ptr[_a_sstepxfrac]
326 adc esi,ds:dword ptr[advancetable+4+eax*4]
327
328LDraw1:
329 cmp bp,ds:word ptr[14+ecx]
330 jl Lp8
331 xor eax,eax
332 mov ah,dh
333 mov al,ds:byte ptr[esi]
334 mov ds:word ptr[14+ecx],bp
335 mov al,ds:byte ptr[12345678h+eax]
336LPatch1:
337 mov ds:byte ptr[7+edi],al
338Lp8:
339 add edx,ds:dword ptr[tstep]
340 sbb eax,eax
341 add ebp,ds:dword ptr[lzistepx]
342 adc ebp,0
343 add ebx,ds:dword ptr[_a_sstepxfrac]
344 adc esi,ds:dword ptr[advancetable+4+eax*4]
345
346 add edi,8
347 add ecx,16
348
349 dec bx
350 jnz LDrawLoop
351
352 pop esi	; restore spans pointer
353LNextSpan:
354 add esi,offset spanpackage_t_size	; point to next span
355LNextSpanESISet:
356 mov edx,ds:dword ptr[spanpackage_t_count+esi]
357 cmp edx,offset -999999	; any more spans?
358 jnz LSpanLoop	; yes
359
360 pop edi
361 pop ebp	; restore the caller's stack frame
362 pop ebx	; restore register variables
363 pop esi
364 ret
365
366;=======
367; IR active draw loop
368;=======
369LDrawLoopIR:
370
371; FIXME: do we need to clamp light? We may need at least a buffer bit to
372; keep it from poking into tfrac and causing problems
373
374LDraw8IR:
375 cmp bp,ds:word ptr[ecx]
376 jl Lp1IR
377 xor eax,eax
378 mov al,ds:byte ptr[esi]
379 mov al,ds:byte ptr[_irtable+eax]
380 mov ds:word ptr[ecx],bp
381 mov al,ds:byte ptr[12345678h+eax]
382LPatch8IR:
383 mov ds:byte ptr[edi],al
384Lp1IR:
385 add edx,ds:dword ptr[tstep]
386 sbb eax,eax
387 add ebp,ds:dword ptr[lzistepx]
388 adc ebp,0
389 add ebx,ds:dword ptr[_a_sstepxfrac]
390 adc esi,ds:dword ptr[advancetable+4+eax*4]
391
392LDraw7IR:
393 cmp bp,ds:word ptr[2+ecx]
394 jl Lp2IR
395 xor eax,eax
396 mov al,ds:byte ptr[esi]
397 mov al,ds:byte ptr[_irtable+eax]
398 mov ds:word ptr[2+ecx],bp
399 mov al,ds:byte ptr[12345678h+eax]
400LPatch7IR:
401 mov ds:byte ptr[1+edi],al
402Lp2IR:
403 add edx,ds:dword ptr[tstep]
404 sbb eax,eax
405 add ebp,ds:dword ptr[lzistepx]
406 adc ebp,0
407 add ebx,ds:dword ptr[_a_sstepxfrac]
408 adc esi,ds:dword ptr[advancetable+4+eax*4]
409
410LDraw6IR:
411 cmp bp,ds:word ptr[4+ecx]
412 jl Lp3IR
413 xor eax,eax
414 mov al,ds:byte ptr[esi]
415 mov al,ds:byte ptr[_irtable+eax]
416 mov ds:word ptr[4+ecx],bp
417 mov al,ds:byte ptr[12345678h+eax]
418LPatch6IR:
419 mov ds:byte ptr[2+edi],al
420Lp3IR:
421 add edx,ds:dword ptr[tstep]
422 sbb eax,eax
423 add ebp,ds:dword ptr[lzistepx]
424 adc ebp,0
425 add ebx,ds:dword ptr[_a_sstepxfrac]
426 adc esi,ds:dword ptr[advancetable+4+eax*4]
427
428LDraw5IR:
429 cmp bp,ds:word ptr[6+ecx]
430 jl Lp4IR
431 xor eax,eax
432 mov al,ds:byte ptr[esi]
433 mov al,ds:byte ptr[_irtable+eax]
434 mov ds:word ptr[6+ecx],bp
435 mov al,ds:byte ptr[12345678h+eax]
436LPatch5IR:
437 mov ds:byte ptr[3+edi],al
438Lp4IR:
439 add edx,ds:dword ptr[tstep]
440 sbb eax,eax
441 add ebp,ds:dword ptr[lzistepx]
442 adc ebp,0
443 add ebx,ds:dword ptr[_a_sstepxfrac]
444 adc esi,ds:dword ptr[advancetable+4+eax*4]
445
446LDraw4IR:
447 cmp bp,ds:word ptr[8+ecx]
448 jl Lp5IR
449 xor eax,eax
450 mov al,ds:byte ptr[esi]
451 mov al,ds:byte ptr[_irtable+eax]
452 mov ds:word ptr[8+ecx],bp
453 mov al,ds:byte ptr[12345678h+eax]
454LPatch4IR:
455 mov ds:byte ptr[4+edi],al
456Lp5IR:
457 add edx,ds:dword ptr[tstep]
458 sbb eax,eax
459 add ebp,ds:dword ptr[lzistepx]
460 adc ebp,0
461 add ebx,ds:dword ptr[_a_sstepxfrac]
462 adc esi,ds:dword ptr[advancetable+4+eax*4]
463
464LDraw3IR:
465 cmp bp,ds:word ptr[10+ecx]
466 jl Lp6IR
467 xor eax,eax
468 mov al,ds:byte ptr[esi]
469 mov al,ds:byte ptr[_irtable+eax]
470 mov ds:word ptr[10+ecx],bp
471 mov al,ds:byte ptr[12345678h+eax]
472LPatch3IR:
473 mov ds:byte ptr[5+edi],al
474Lp6IR:
475 add edx,ds:dword ptr[tstep]
476 sbb eax,eax
477 add ebp,ds:dword ptr[lzistepx]
478 adc ebp,0
479 add ebx,ds:dword ptr[_a_sstepxfrac]
480 adc esi,ds:dword ptr[advancetable+4+eax*4]
481
482LDraw2IR:
483 cmp bp,ds:word ptr[12+ecx]
484 jl Lp7IR
485 xor eax,eax
486 mov al,ds:byte ptr[esi]
487 mov al,ds:byte ptr[_irtable+eax]
488 mov ds:word ptr[12+ecx],bp
489 mov al,ds:byte ptr[12345678h+eax]
490LPatch2IR:
491 mov ds:byte ptr[6+edi],al
492Lp7IR:
493 add edx,ds:dword ptr[tstep]
494 sbb eax,eax
495 add ebp,ds:dword ptr[lzistepx]
496 adc ebp,0
497 add ebx,ds:dword ptr[_a_sstepxfrac]
498 adc esi,ds:dword ptr[advancetable+4+eax*4]
499
500LDraw1IR:
501 cmp bp,ds:word ptr[14+ecx]
502 jl Lp8IR
503 xor eax,eax
504 mov al,ds:byte ptr[esi]
505 mov al,ds:byte ptr[_irtable+eax]
506 mov ds:word ptr[14+ecx],bp
507 mov al,ds:byte ptr[12345678h+eax]
508LPatch1IR:
509 mov ds:byte ptr[7+edi],al
510Lp8IR:
511 add edx,ds:dword ptr[tstep]
512 sbb eax,eax
513 add ebp,ds:dword ptr[lzistepx]
514 adc ebp,0
515 add ebx,ds:dword ptr[_a_sstepxfrac]
516 adc esi,ds:dword ptr[advancetable+4+eax*4]
517
518 add edi,8
519 add ecx,16
520
521 dec bx
522 jnz LDrawLoopIR
523
524 pop esi	; restore spans pointer
525LNextSpanIR:
526 add esi,offset spanpackage_t_size	; point to next span
527LNextSpanESISetIR:
528 mov edx,ds:dword ptr[spanpackage_t_count+esi]
529 cmp edx,offset -999999	; any more spans?
530 jnz LSpanLoop	; yes
531
532 pop edi
533 pop ebp	; restore the caller's stack frame
534 pop ebx	; restore register variables
535 pop esi
536 ret
537
538;=======
539; Standard One-Long Draw
540;=======
541; draw a one-long span
542
543LExactlyOneLong:
544 mov al,[_iractive]
545 cmp al,0
546 jne LExactlyOneLongIR
547
548 mov ecx,ds:dword ptr[spanpackage_t_pz+esi]
549 mov ebp,ds:dword ptr[spanpackage_t_zi+esi]
550
551 ror ebp,16	; put high 16 bits of 1/z in low word
552 mov ebx,ds:dword ptr[spanpackage_t_ptex+esi]
553
554 cmp bp,ds:word ptr[ecx]
555 jl LNextSpan
556 xor eax,eax
557 mov edi,ds:dword ptr[spanpackage_t_pdest+esi]
558 mov ah,ds:byte ptr[spanpackage_t_light+1+esi]
559 add esi,offset spanpackage_t_size	; point to next span
560 mov al,ds:byte ptr[ebx]
561 mov ds:word ptr[ecx],bp
562 mov al,ds:byte ptr[12345678h+eax]
563LPatch9:
564 mov ds:byte ptr[edi],al
565
566 jmp LNextSpanESISet
567
568
569;========
570;========
571; draw a one-long span
572
573LExactlyOneLongIR:
574
575 mov ecx,ds:dword ptr[spanpackage_t_pz+esi]
576 mov ebp,ds:dword ptr[spanpackage_t_zi+esi]
577
578 ror ebp,16	; put high 16 bits of 1/z in low word
579 mov ebx,ds:dword ptr[spanpackage_t_ptex+esi]
580
581 cmp bp,ds:word ptr[ecx]
582 jl LNextSpanIR
583 xor eax,eax
584 mov edi,ds:dword ptr[spanpackage_t_pdest+esi]
585 add esi,offset spanpackage_t_size	; point to next span
586 mov al,ds:byte ptr[ebx]
587 mov al,ds:byte ptr[_irtable+eax]
588 mov ds:word ptr[ecx],bp
589 mov al,ds:byte ptr[12345678h+eax]
590LPatch9IR:
591 mov ds:byte ptr[edi],al
592
593 jmp LNextSpanESISetIR
594
595;===================================
596;===================================
597 public _D_Aff8Patch
598_D_Aff8Patch:
599 mov eax,[_d_pcolormap]
600 mov ds:dword ptr[LPatch1-4],eax
601 mov ds:dword ptr[LPatch2-4],eax
602 mov ds:dword ptr[LPatch3-4],eax
603 mov ds:dword ptr[LPatch4-4],eax
604 mov ds:dword ptr[LPatch5-4],eax
605 mov ds:dword ptr[LPatch6-4],eax
606 mov ds:dword ptr[LPatch7-4],eax
607 mov ds:dword ptr[LPatch8-4],eax
608 mov ds:dword ptr[LPatch9-4],eax
609 mov ds:dword ptr[LPatch1IR-4],eax
610 mov ds:dword ptr[LPatch2IR-4],eax
611 mov ds:dword ptr[LPatch3IR-4],eax
612 mov ds:dword ptr[LPatch4IR-4],eax
613 mov ds:dword ptr[LPatch5IR-4],eax
614 mov ds:dword ptr[LPatch6IR-4],eax
615 mov ds:dword ptr[LPatch7IR-4],eax
616 mov ds:dword ptr[LPatch8IR-4],eax
617 mov ds:dword ptr[LPatch9IR-4],eax
618
619 ret
620
621
622
623;===================================
624;===================================
625
626height	equ		4+16
627
628 public _R_PolysetScanLeftEdge
629_R_PolysetScanLeftEdge:
630 push ebp	; preserve caller stack frame pointer
631 push esi	; preserve register variables
632 push edi
633 push ebx
634
635 mov eax,ds:dword ptr[height+esp]
636 mov ecx,ds:dword ptr[_d_sfrac]
637
638 and eax,0FFFFh
639 mov ebx,ds:dword ptr[_d_ptex]
640 or ecx,eax
641 mov esi,ds:dword ptr[_d_pedgespanpackage]
642 mov edx,ds:dword ptr[_d_tfrac]
643 mov edi,ds:dword ptr[_d_light]
644 mov ebp,ds:dword ptr[_d_zi]
645
646; %eax: scratch
647; %ebx: d_ptex
648; %ecx: d_sfrac in high word, count in low word
649; %edx: d_tfrac
650; %esi: d_pedgespanpackage, errorterm, scratch alternately
651; %edi: d_light
652; %ebp: d_zi
653
654;	do
655;	{
656
657LScanLoop:
658
659;		d_pedgespanpackage->ptex = ptex;
660;		d_pedgespanpackage->pdest = d_pdest;
661;		d_pedgespanpackage->pz = d_pz;
662;		d_pedgespanpackage->count = d_aspancount;
663;		d_pedgespanpackage->light = d_light;
664;		d_pedgespanpackage->zi = d_zi;
665;		d_pedgespanpackage->sfrac = d_sfrac << 16;
666;		d_pedgespanpackage->tfrac = d_tfrac << 16;
667 mov ds:dword ptr[spanpackage_t_ptex+esi],ebx
668 mov eax,ds:dword ptr[_d_pdest]
669 mov ds:dword ptr[spanpackage_t_pdest+esi],eax
670 mov eax,ds:dword ptr[_d_pz]
671 mov ds:dword ptr[spanpackage_t_pz+esi],eax
672 mov eax,ds:dword ptr[_d_aspancount]
673 mov ds:dword ptr[spanpackage_t_count+esi],eax
674 mov ds:dword ptr[spanpackage_t_light+esi],edi
675 mov ds:dword ptr[spanpackage_t_zi+esi],ebp
676 mov ds:dword ptr[spanpackage_t_sfrac+esi],ecx
677 mov ds:dword ptr[spanpackage_t_tfrac+esi],edx
678
679; pretouch the next cache line
680 mov al,ds:byte ptr[spanpackage_t_size+esi]
681
682;		d_pedgespanpackage++;
683 add esi,offset spanpackage_t_size
684 mov eax,ds:dword ptr[_erroradjustup]
685 mov ds:dword ptr[_d_pedgespanpackage],esi
686
687;		errorterm += erroradjustup;
688 mov esi,ds:dword ptr[_errorterm]
689 add esi,eax
690 mov eax,ds:dword ptr[_d_pdest]
691
692;		if (errorterm >= 0)
693;		{
694 js LNoLeftEdgeTurnover
695
696;			errorterm -= erroradjustdown;
697;			d_pdest += d_pdestextrastep;
698 sub esi,ds:dword ptr[_erroradjustdown]
699 add eax,ds:dword ptr[_d_pdestextrastep]
700 mov ds:dword ptr[_errorterm],esi
701 mov ds:dword ptr[_d_pdest],eax
702
703;			d_pz += d_pzextrastep;
704;			d_aspancount += d_countextrastep;
705;			d_ptex += d_ptexextrastep;
706;			d_sfrac += d_sfracextrastep;
707;			d_ptex += d_sfrac >> 16;
708;			d_sfrac &= 0xFFFF;
709;			d_tfrac += d_tfracextrastep;
710 mov eax,ds:dword ptr[_d_pz]
711 mov esi,ds:dword ptr[_d_aspancount]
712 add eax,ds:dword ptr[_d_pzextrastep]
713 add ecx,ds:dword ptr[_d_sfracextrastep]
714 adc ebx,ds:dword ptr[_d_ptexextrastep]
715 add esi,ds:dword ptr[_d_countextrastep]
716 mov ds:dword ptr[_d_pz],eax
717 mov eax,ds:dword ptr[_d_tfracextrastep]
718 mov ds:dword ptr[_d_aspancount],esi
719 add edx,eax
720
721;			if (d_tfrac & 0x10000)
722;			{
723 jnc LSkip1
724
725;				d_ptex += r_affinetridesc.skinwidth;
726;				d_tfrac &= 0xFFFF;
727 add ebx,ds:dword ptr[_r_affinetridesc+atd_skinwidth]
728
729;			}
730
731LSkip1:
732
733;			d_light += d_lightextrastep;
734;			d_zi += d_ziextrastep;
735 add edi,ds:dword ptr[_d_lightextrastep]
736 add ebp,ds:dword ptr[_d_ziextrastep]
737
738;		}
739 mov esi,ds:dword ptr[_d_pedgespanpackage]
740 dec ecx
741 test ecx,0FFFFh
742 jnz LScanLoop
743
744 pop ebx
745 pop edi
746 pop esi
747 pop ebp
748 ret
749
750;		else
751;		{
752
753LNoLeftEdgeTurnover:
754 mov ds:dword ptr[_errorterm],esi
755
756;			d_pdest += d_pdestbasestep;
757 add eax,ds:dword ptr[_d_pdestbasestep]
758 mov ds:dword ptr[_d_pdest],eax
759
760;			d_pz += d_pzbasestep;
761;			d_aspancount += ubasestep;
762;			d_ptex += d_ptexbasestep;
763;			d_sfrac += d_sfracbasestep;
764;			d_ptex += d_sfrac >> 16;
765;			d_sfrac &= 0xFFFF;
766 mov eax,ds:dword ptr[_d_pz]
767 mov esi,ds:dword ptr[_d_aspancount]
768 add eax,ds:dword ptr[_d_pzbasestep]
769 add ecx,ds:dword ptr[_d_sfracbasestep]
770 adc ebx,ds:dword ptr[_d_ptexbasestep]
771 add esi,ds:dword ptr[_ubasestep]
772 mov ds:dword ptr[_d_pz],eax
773 mov ds:dword ptr[_d_aspancount],esi
774
775;			d_tfrac += d_tfracbasestep;
776 mov esi,ds:dword ptr[_d_tfracbasestep]
777 add edx,esi
778
779;			if (d_tfrac & 0x10000)
780;			{
781 jnc LSkip2
782
783;				d_ptex += r_affinetridesc.skinwidth;
784;				d_tfrac &= 0xFFFF;
785 add ebx,ds:dword ptr[_r_affinetridesc+atd_skinwidth]
786
787;			}
788
789LSkip2:
790
791;			d_light += d_lightbasestep;
792;			d_zi += d_zibasestep;
793 add edi,ds:dword ptr[_d_lightbasestep]
794 add ebp,ds:dword ptr[_d_zibasestep]
795
796;		}
797;	} while (--height);
798 mov esi,ds:dword ptr[_d_pedgespanpackage]
799 dec ecx
800 test ecx,0FFFFh
801 jnz LScanLoop
802
803 pop ebx
804 pop edi
805 pop esi
806 pop ebp
807 ret
808
809_TEXT ENDS
810endif	;id386
811 END
812