![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fastline.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 / i386|
Return to fastline.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 / i386 |
1.1 root 1: ;---------------------------Module-Header------------------------------;
2: ; Module Name: fastline.asm
3: ;
4: ; This module draws solid lines using the line hardware of the S3.
5: ; It handles entirely unclipped lines, or lines clipped to a single
6: ; rectangle by using the S3's hardware clipping.
7: ;
8: ; All lines that have integer end-points are drawn directly using the
9: ; line hardware, and any lines having fractional end-points and are
10: ; less than 256 pels long are also drawn directly by the line hardware.
11: ; (Fractional end-point lines require 4 more bits of precision from the
12: ; DDA hardware than do integer end-point lines, and the S3 has but 13
13: ; bits to use. Lines longer than 255 pels are punted to the general
14: ; purpose strip routines, which won't overflow the hardware).
15: ;
16: ; There are a number of ways unclipped lines can be sped up on the S3:
17: ;
18: ; 1) Optimize NT's GDI. This isn't an option for everybody.
19: ;
20: ; 2) Use memory-mapped I/O.
21: ;
22: ; 3) If you can't use memory-mapped I/O, you can at least minimize
23: ; outs and ins because they are so painfully expensive. One
24: ; way to do this is to amortize the cost of the in used for checking
25: ; the FIFO: do one in to make sure a large number of entries on
26: ; the FIFO are free (perhaps 6), then do the next 6 outs without
27: ; having to check the FIFO.
28: ;
29: ; This will be a win on figures not requiring many outs (such as when
30: ; radial lines are drawn as with a rectangle), assuming the hardware
31: ; isn't always being overdriven.
32: ;
33: ; 4) In conjunction with 3) above, since short integer lines occur so
34: ; frequently with CAD programs, it would be beneficial to use short-
35: ; stroke vectors to do those lines, as they could reduce the number
36: ; of outs required. Perhaps any line 10 pels or shorter could be
37: ; output by using an array lookup to determine the short stroke vectors
38: ; needed to represent that line.
39: ;
40: ; 5) Numerous other things I haven't thought of.
41: ;
42: ; Other improvements that should be done to make lines faster in general:
43: ;
44: ; 1) Simple clipping should be improved. Currently, we simply set the
45: ; clip rectangle and let the hardware do everything. We should at least
46: ; perform a trivial clip test to see if there's no chance the line
47: ; intersects the clip rectangle.
48: ;
49: ; Also, for single lines it's expensive to do the 4 outs required to
50: ; set the S3's clip rectangle, draw the line, then do 4 outs to reset
51: ; the clip rectangle again. In those cases, it would be faster to do the
52: ; clipping entirely in software.
53: ;
54: ; 2) This code can be enhanced to also handle styled lines, and to do
55: ; complex clipping more efficiently than the strips routines.
56: ;
57: ; 3) It is possible to derive the mathematical algorithm for drawing any
58: ; GIQ line in NT's 32 bit space using the limited bit precision of the
59: ; S3's hardware. What this means is that absolutely any GIQ line can
60: ; be drawn precisely with at most two drawing commands to the line
61: ; hardware (and so the strips line drawing routine could be eliminated
62: ; entirely). Just be careful of your math...
63: ;
64: ; 4) Numerous other things I haven't thought of.
65: ;
66: ; Copyright (c) 1992-1993 Microsoft Corporation
67: ;-----------------------------------------------------------------------;
68:
69: .386
70:
71: .model small,c
72:
73: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT
74: assume fs:nothing,gs:nothing
75:
76: .xlist
77: include stdcall.inc ;calling convention cmacros
78: include i386\strucs.inc
79: include i386\lines.inc
80: .list
81:
82: ; Line coordinates are given in 28.4 fixed point format:
83:
84: F equ 16
85: FLOG2 equ 4
86:
87: ; The S3's hardware can have 13 bits of significance for the error and
88: ; step terms:
89:
90: NUM_DDA_BITS equ 13
91:
92: ; GIQ lines have to dedicate 4 bits to the fractional term, so the largest
93: ; delta we can handle for GIQ lines is calculated as follows (scaled by F
94: ; so we can do the test in GIQ coordinates), and remembering that one bit
95: ; has to be used as a sign bit:
96:
97: MAX_GIQ_DELTA equ (((1 shl (NUM_DDA_BITS - 5)) - 1) * F)
98:
99: ; The following values must match those in winddi.h!
100:
101: PD_BEGINSUBPATH equ 00000001h
102: PD_ENDSUBPATH equ 00000002h
103: PD_RESETSTYLE equ 00000004h
104: PD_CLOSEFIGURE equ 00000008h
105: PD_BEZIERS equ 00000010h
106:
107: PATHDATA struc
108:
109: pd_flags dd ?
110: pd_count dd ?
111: pd_pptfx dd ?
112:
113: PATHDATA ends
114:
115: ;-------------------------------------------------------------------------;
116: ; I felt a compelling need to use 'ebp' as a 7th general register, and we
117: ; have no nifty macros for dereferencing frame variables off 'esp'. So
118: ; with this structure I am rolling my own stack frame:
119:
120: STATE_MEM_SIZE equ 4 ;4 dwords
121: PROC_MEM_SIZE equ 7 ;7 dwords
122:
123: STACK_FRAME struc
124:
125: ; State variables (don't add/delete fields without modifying STATE_MEM_SIZE!)
126:
127: sf_ulOurEbp dd ? ;useful for debugging
128: sf_ulOriginalEbx dd ?
129: sf_ulOriginalEdi dd ?
130: sf_ulOriginalEsi dd ?
131:
132: ; Frame variables (feel free to add/delete fields):
133:
134: sf_y0 dd ? ;GIQ variables
135: sf_y1 dd ?
136: sf_x1 dd ?
137: sf_ptlOrg db (size POINTL) dup (?)
138: ;our origin for normalizing the line
139: sf_ptfxLast db (size POINTL) dup (?)
140: ;the most recent point
141: sf_ptfxStartFigure db (size POINTL) dup (?)
142: ;the figure's 1st point
143: sf_bMore dd ? ;more path records to get?
144: sf_pptfxEnd dd ? ;points to last point in record
145: sf_pptfx dd ? ;points to current point
146: sf_pd db (size PATHDATA) dup (?)
147: ;pathdata structure
148: sf_ptfxStart db (size POINTL) dup (?)
149: ;temporary spot for saving start point
150: sf_ptfxEnd db (size POINTL) dup (?)
151: ;temporary spot for saving end point
152: sf_ulCmd dd ? ;S3 draw command
153: sf_cPels dd ? ;length of line in pels
154: sf_bSetCP dd ? ;1 if first line in figure, 0 otherwise
155: sf_ulLastLength dd ? ;last value set as LINE_MAX
156: sf_ulErrorTerm dd ? ;error term for line
157:
158: ; Procedure variables (don't add/delete fields without modifying
159: ; PROC_MEM_SIZE!)
160:
161: sf_ulOriginalEbp dd ?
162: sf_ulOriginalReturn dd ?
163: sf_ppdev dd ?
164: sf_ppo dd ?
165: sf_prclClip dd ?
166: sf_apfn dd ?
167: sf_flags dd ?
168:
169: STACK_FRAME ends
170:
171: .data
172:
173: EXTRNP PATHOBJ_bEnum,8
174: EXTRNP bLines,36
175:
176: .code
177:
178: ROUND_X_DOWN equ 01h
179: ROUND_Y_DOWN equ 02h
180: ROUND_SLOPE_ONE equ 04h
181: ROUND_X_AND_Y_DOWN equ (ROUND_X_DOWN + ROUND_Y_DOWN)
182: ROUND_X_DOWN_SLOPE_ONE equ (ROUND_X_DOWN + ROUND_SLOPE_ONE)
183: ROUND_Y_DOWN_SLOPE_ONE equ (ROUND_Y_DOWN + ROUND_SLOPE_ONE)
184:
185: ;--------------------------------Macro----------------------------------;
186: ; GIQ flags
187: ;
188: ; This macros computes the start pixel, the number of pixels to
189: ; be lit, and the initial error term given a GIQ line. The line must
190: ; have already been normalized such that dM >= dN, dN >= 0.
191: ;
192: ; Input: ebx - M0
193: ; ecx - N0
194: ; esi - dM
195: ; edi - dN
196: ; Trashes:
197: ; eax, edx
198: ; [esp].sf_ptlOrg.ptl_x, [esp].sf_ptlOrg.ptl_y
199: ; Output:
200: ; [esp].sf_x1 - x-coordinate of last pixel (exclusive)
201: ; ebx - x-coordinate of first pixel
202: ; ecx - error term
203: ; esi - dM
204: ; edi - dN
205: ; ebp - y-coordinate of first pixel
206: ;-----------------------------------------------------------------------;
207:
208: GIQ macro flags
209: local compute_x1, compute_error_term
210:
211: ; We normalize our coordinate system so that if the start point is
212: ; (M0/F, N0/F), the origin is at (floor(M0/F), (N0/F)):
213:
214: mov eax,ebx
215: mov ebp,ecx
216: sar eax,FLOG2
217: sar ebp,FLOG2
218: mov [esp].sf_ptlOrg.ptl_x,eax
219: ;ptlOrg.x = floor(M0 / F)
220: mov [esp].sf_ptlOrg.ptl_y,ebp
221: ;ptlOrg.y = floor(N0 / F)
222:
223: ; Calculate the correct [esp].sf_x1:
224:
225: lea ebp,[ecx + edi] ;ebp = N1
226: and ebp,F - 1
227:
228: if (flags AND ROUND_X_DOWN)
229:
230: if (flags AND ROUND_SLOPE_ONE)
231: lea edx,[ebx + esi]
232: and edx,F - 1 ;edx = M1
233: sub edx,8
234: cmp edx,ebp ;cmp M1 - 8, N1
235: jne short compute_x1
236:
237: lea edx,[ebx + esi]
238: sar edx,FLOG2
239: jmp short compute_error_term
240: endif
241:
242: compute_x1:
243:
244: cmp ebp,1
245: sbb ebp,8 ;N1 -= 8
246: else
247: sub ebp,8 ;N1 -= 8
248: endif
249: sbb eax,eax
250: xor ebp,eax
251: sub ebp,eax ;N1 = ABS(N1)
252:
253: lea edx,[ebx + esi]
254: mov eax,edx
255: sar edx,FLOG2
256: and eax,F - 1
257: jz short @f ;special case for M1 == 0
258: cmp eax,ebp ;cmp M1, N1
259: sbb edx,-1 ;edx is now one pixel past the actual
260: @@: ; end coordinate (note that it hasn't
261: ; been affected by the origin shift)
262:
263: compute_error_term:
264:
265: ; ebx = M0
266: ; ecx = N0
267: ; edx = x1
268: ; esi = dM
269: ; edi = dN
270:
271: and ecx,F - 1
272: mov [esp].sf_x1,edx ;save x1
273:
274: ; Calculate our error term for x = 0.
275: ;
276: ; NOTE: Since this routine is used only for lines that are unclipped, we
277: ; are guaranteed by our screen size that the values will be far less
278: ; than 32 bits in significance, and so we don't worry about overflow.
279: ; If this is used for clipped lines, these multiplies will have to
280: ; be converted to give 64 bit results, because we can have 36 bits of
281: ; significance!
282:
283:
284: lea ebp,[ecx + 8] ;ebp = N0 + 8
285: mov eax,esi
286: imul eax,ebp ;eax = dM * (N0 + 8)
287: mov ebp,edi
288:
289: ; We have to special case when M0 is 0 -- we know x0 will be zero.
290: ; So we jump ahead a bit to a place where 'ebx' is assumed to contain
291: ; x0 -- and it just so happens 'ebx' is zero in this case:
292:
293: and ebx,F - 1
294: jz short @f
295: imul ebp,ebx ;ebp = dN * M0
296: sub eax,ebp
297:
298: ; Calculate the x-coordinate of the first pixel:
299:
300: if (flags AND ROUND_X_DOWN)
301:
302: if (flags AND ROUND_SLOPE_ONE)
303: cmp ecx,8
304: sbb ecx,-1
305: endif
306:
307: cmp ecx,1
308: sbb ecx,8 ;N0 -= 8
309: else
310: sub ecx,8 ;N0 -= 8
311: endif
312: sbb ebp,ebp
313: xor ecx,ebp
314: sub ecx,ebp ;N0 = ABS(N0)
315: cmp ebx,ecx
316: sbb ebx,ebx
317: not ebx ;ebx = -x0
318:
319: ; Now adjust the error term accordingly:
320:
321: @@:
322: if (flags AND ROUND_Y_DOWN)
323: dec eax
324: endif
325: sar eax,FLOG2 ;eax = floor((N0 + 8) dM - M0 dN] / 16)
326:
327: mov ecx,[esp].sf_ptlOrg.ptl_x
328: mov ebp,[esp].sf_ptlOrg.ptl_y
329:
330: sub ecx,ebx ;ecx = ptlOrg.ptl_x + x0
331:
332: and ebx,edi
333: add ebx,eax
334: sub ebx,esi ;ebx = dN * x0 + initial error - dM
335: jl short @f ;if the error term >= 0, we have to
336: sub ebx,esi ; add 1 to the y position and subtract
337: inc ebp ; dM off again
338: @@:
339: xchg ebx,ecx
340:
341: endm
342:
343: ;--------------------------------Macro----------------------------------;
344: ; GIQR flags
345: ;
346: ; Same as above, except it handles flips about the line x = y.
347: ;
348: ; Input: ebx - M0
349: ; ecx - N0
350: ; esi - dM
351: ; edi - dN
352: ; Trashes:
353: ; eax, edx
354: ; [esp].sf_ptlOrg.ptl_x, [esp].sf_ptlOrg.ptl_y
355: ; Output:
356: ; [esp].sf_y1 - y-coordinate of last pixel (exclusive)
357: ; ebx - x-coordinate of first pixel
358: ; ecx - error term
359: ; esi - dM
360: ; edi - dN
361: ; ebp - y-coordinate of first pixel
362: ;-----------------------------------------------------------------------;
363:
364: GIQR macro flags
365:
366: ; We normalize our coordinate system so that if the start point is
367: ; (M0/F, N0/F), the origin is at (floor(M0/F), (N0/F)):
368:
369: mov eax,ebx
370: mov ebp,ecx
371: sar eax,FLOG2
372: sar ebp,FLOG2
373: mov [esp].sf_ptlOrg.ptl_x,eax
374: ;ptlOrg.x = floor(M0 / F)
375: mov [esp].sf_ptlOrg.ptl_y,ebp
376: ;ptlOrg.y = floor(N0 / F)
377:
378: ; Calculate the correct [esp].sf_y1:
379:
380: lea ebp,[ebx + esi] ;ebp = M1
381: and ebp,F - 1
382:
383: if (flags AND ROUND_Y_DOWN)
384: cmp ebp,1
385: sbb ebp,8 ;M1 -= 8
386: else
387: sub ebp,8 ;M1 -= 8
388: endif
389: sbb eax,eax
390: xor ebp,eax
391: sub ebp,eax ;M1 = ABS(M1)
392:
393: lea edx,[ecx + edi]
394: mov eax,edx
395: sar edx,FLOG2
396: and eax,F - 1
397: jz short @f ;special case for N1 == 0
398: cmp eax,ebp ;cmp N1, M1
399: sbb edx,-1 ;edx is now one pixel past the actual
400: @@: ; end coordinate (note that it hasn't
401: ; been affected by the origin shift)
402: and ebx,F - 1
403: mov [esp].sf_y1,edx
404:
405: ; Calculate our error term for y = 0.
406: ;
407: ; NOTE: Since this routine is used only for lines that are unclipped, we
408: ; are guaranteed by our screen size that the values will be far less
409: ; than 32 bits in significance, and so we don't worry about overflow.
410: ; If this is used for clipped lines, these multiplies will have to
411: ; be converted to give 64 bit results, because we can have 36 bits of
412: ; significance!
413:
414: lea ebp,[ebx + 8] ;ebp = M0 + 8
415: mov eax,edi
416: imul eax,ebp ;eax = dN * (M0 + 8)
417: mov ebp,esi
418:
419: ; We have to special case when N0 is 0 -- we know y0 will be zero.
420: ; So we jump ahead a bit to a place where 'ecx' is assumed to contain
421: ; y0 -- and it just so happens 'ecx' is zero in this case:
422:
423: and ecx,F - 1
424: jz short @f
425: imul ebp,ecx ;ebp = dM * N0
426: sub eax,ebp
427:
428: ; Calculate the x-coordinate of the first pixel:
429:
430: if (flags AND ROUND_Y_DOWN)
431: cmp ebx,1
432: sbb ebx,8 ;M0 -= 8
433: else
434: sub ebx,8 ;M0 -= 8
435: endif
436: sbb ebp,ebp
437: xor ebx,ebp
438: sub ebx,ebp ;M0 = ABS(M0)
439: cmp ecx,ebx
440: sbb ecx,ecx
441: not ecx ;ecx = -y0
442:
443: ; Now adjust the error term accordingly:
444:
445: @@:
446: if (flags AND ROUND_X_DOWN)
447: dec eax
448: endif
449: sar eax,FLOG2 ;eax = floor((M0 + 8) dN - N0 dM] / 16)
450:
451: mov ebx,[esp].sf_ptlOrg.ptl_x
452: mov ebp,[esp].sf_ptlOrg.ptl_y
453:
454: sub ebp,ecx ;ebp = ptlOrg.ptl_y + y0
455:
456: and ecx,esi
457: add ecx,eax
458: sub ecx,edi ;ecx = dM * x0 + initial error - dN
459: jl short @f ;if the error term >= 0, we have to
460: sub ecx,edi ; add 1 to the x position and subtract
461: inc ebx ; dN off again
462: @@:
463:
464: endm
465:
466: ;---------------------------Public-Routine------------------------------;
467: ; vFastLine(ppdev, ppo, prclClip, apfn, flags)
468: ;
469: ; Draws fast lines. Or at least attempts to.
470: ;
471: ; Input:
472: ;
473: ; ppdev - PDEV pointer
474: ; ppo - path
475: ; prclClip - pointer to rectangle array for passing to 'bLines'
476: ; apfn - pointer to strip routines for passing to 'bLines'
477: ; flags - status flag for passing to 'bLines'
478: ;
479: ;-----------------------------------------------------------------------;
480:
481: ; NOTE: Don't go changing parameters without also changing STACK_FRAME!
482:
483: cProc vFastLine,20,< \
484: uses esi edi ebx, \
485: ebp_ppdev: ptr, \
486: ebp_ppo: ptr, \
487: ebp_prclClip: ptr, \
488: ebp_apfn: ptr, \
489: ebp_flags: dword >
490:
491: ; Leave room for our stack frame.
492: ;
493: ; NOTE: Don't add local variables here -- you can't reference them with
494: ; ebp anyway! Add them to the STACK_FRAME structure.
495:
496: local aj[(size STACK_FRAME) - 4 * (STATE_MEM_SIZE + PROC_MEM_SIZE)]: byte
497:
498: ; We save 'ebp' on the stack (note that STACK_FRAME accounts for this push):
499:
500: push ebp
501:
502: mov [esp].sf_ulLastLength,-1;make sure first line in path resets
503: ; LINE_MAX value
504:
505: ; Now get some path stuff:
506:
507: next_record:
508:
509: mov eax,[esp].sf_ppo
510: lea ebx,[esp].sf_pd
511: cCall PATHOBJ_bEnum,<eax,ebx>
512: mov [esp].sf_bMore,eax ;save away return code for later
513:
514: mov ebx,[esp].sf_pd.pd_count;if 0 points in record, get outta here
515: or ebx,ebx
516: jz check_for_closefigure
517:
518: lea ebp,[8 * ebx - 8]
519: add ebp,[esp].sf_pd.pd_pptfx
520: mov [esp].sf_pptfxEnd,ebp ;points to last point in record
521:
522: mov ecx,[esp].sf_pd.pd_flags
523: test ecx,PD_BEGINSUBPATH
524: jz short continue_subpath
525:
526: ; Handle a new sub-path:
527:
528: mov eax,[esp].sf_pd.pd_pptfx
529: add eax,8
530: mov [esp].sf_pptfx,eax
531:
532: mov esi,[ebp].ptl_x ;remember last point in case we have
533: mov edi,[ebp].ptl_y ; to continue to another record
534: mov [esp].sf_ptfxLast.ptl_x,esi
535: mov [esp].sf_ptfxLast.ptl_y,edi
536:
537: mov ebx,[eax - 8].ptl_x ;load up current start and end point
538: mov ecx,[eax - 8].ptl_y
539: mov esi,[eax].ptl_x
540: mov edi,[eax].ptl_y
541: mov [esp].sf_ptfxStartFigure.ptl_x,ebx
542: mov [esp].sf_ptfxStartFigure.ptl_y,ecx
543:
544: mov [esp].sf_bSetCP,1 ;this line is first in figure
545:
546: cmp eax,[esp].sf_pptfxEnd ;we have to be careful when the only
547: ; point in the record is the start-
548: ; figure point (pretty rare)
549: jbe new_line
550: jmp short next_record
551:
552: continue_subpath:
553:
554: ; This record continues the path:
555:
556: mov eax,[esp].sf_pd.pd_pptfx
557: mov ebx,[esp].sf_ptfxLast.ptl_x ;load up current start point
558: mov ecx,[esp].sf_ptfxLast.ptl_y
559:
560: mov esi,[ebp].ptl_x ;remember last point in case we have
561: mov edi,[ebp].ptl_y ; to continue to another record
562: mov [esp].sf_ptfxLast.ptl_x,esi
563: mov [esp].sf_ptfxLast.ptl_y,edi
564:
565: mov esi,[eax].ptl_x ;load up current end point
566: mov edi,[eax].ptl_y
567: mov [esp].sf_pptfx,eax
568:
569: jmp new_line
570:
571: ;/////////////////////////////////////////////////////////////////////
572: ;// Next Line Stuff
573: ;/////////////////////////////////////////////////////////////////////
574:
575: handle_closefigure:
576: mov [esp].sf_pd.pd_flags,0
577: mov ebx,[esp].sf_ptfxLast.ptl_x
578: mov ecx,[esp].sf_ptfxLast.ptl_y
579: mov esi,[esp].sf_ptfxStartFigure.ptl_x
580: mov edi,[esp].sf_ptfxStartFigure.ptl_y
581:
582: jmp new_line
583:
584: ; Before getting the next path record, see if we have to do a closefigure:
585:
586: check_for_closefigure:
587: test [esp].sf_pd.pd_flags,PD_CLOSEFIGURE
588: jnz handle_closefigure
589: mov esi,[esp].sf_bMore
590: or esi,esi
591: jnz next_record
592:
593: all_done:
594:
595: pop ebp
596: cRet vFastLine
597:
598: ;/////////////////////////////////////////////////////////////////////
599: ;// Output Integer Line
600: ;/////////////////////////////////////////////////////////////////////
601:
602: ; ebx = x
603: ; ecx = y
604: ; esi = dx
605: ; edi = dy
606: ; [esp].sf_ulErrorTerm = incomplete error term (actual value is 'dx - bias')
607: ; [esp].sf_ulCmd = draw command
608:
609: ; NOTE: The port values retrieved from the PDEV are word values, and word
610: ; moves have a one cycle penalty. For this reason, the values should
611: ; actually be defined as dwords in the PDEV...
612:
613: public int_output_line
614: int_output_line:
615: mov ebp,[esp].sf_ppdev ;ebp = ppdev
616: cmp [esp].sf_bSetCP,0
617: je short int_current_position_already_set
618:
619: mov dx,[ebp].pdev_gp_stat
620: @@: in ax,dx
621: and eax,FIFO_7_EMPTY ;wait for 7 entries
622: jnz short @b
623:
624: mov dx,[ebp].pdev_cur_x
625: mov eax,ebx
626: out dx,ax
627:
628: mov dx,[ebp].pdev_cur_y
629: mov eax,ecx
630: out dx,ax
631:
632: mov [esp].sf_bSetCP,0 ;the next integer line in this figure
633: ; will have the CP set correctly
634:
635: jmp short int_output_common
636:
637: int_current_position_already_set:
638: mov dx,[ebp].pdev_gp_stat
639: @@: in ax,dx
640: and eax,FIFO_5_EMPTY ;wait for 5 entries
641: jnz short @b
642:
643: public int_output_common
644: int_output_common:
645: cmp esi,[esp].sf_ulLastLength
646: je short @f
647:
648: mov dx,[ebp].pdev_line_max
649: mov eax,esi
650: out dx,ax
651: mov [esp].sf_ulLastLength,eax
652: @@:
653: mov dx,[ebp].pdev_axstp
654: mov eax,edi
655: out dx,ax ;axial = dy
656:
657: mov dx,[ebp].pdev_diastp
658: sub eax,esi
659: out dx,ax ;diag = dy - dx
660:
661: mov edx,[esp].sf_ulErrorTerm
662: sar edx,1
663: add eax,edx
664: mov dx,[ebp].pdev_err_term
665: out dx,ax ;err = dy - dx + floor((dx - bias) / 2)
666:
667: mov dx,[ebp].pdev_cmd
668: mov eax,[esp].sf_ulCmd
669: out dx,ax ;draw that puppy
670:
671: ;/////////////////////////////////////////////////////////////////////
672: ;// Main Loop
673: ;/////////////////////////////////////////////////////////////////////
674:
675: public next_line
676: next_line:
677: mov eax,[esp].sf_pptfx
678: cmp eax,[esp].sf_pptfxEnd
679: jae check_for_closefigure
680:
681: mov ebx,[eax].ptl_x
682: mov ecx,[eax].ptl_y
683: mov esi,[eax+8].ptl_x
684: mov edi,[eax+8].ptl_y
685: add eax,8
686: mov [esp].sf_pptfx,eax
687:
688: public new_line
689: new_line:
690:
691: ; Octants are numbered as follows:
692: ;
693: ; \ 5 | 6 /
694: ; \ | /
695: ; 4 \ | / 7
696: ; \ /
697: ; -----+-----
698: ; /|\
699: ; 3 / | \ 0
700: ; / | \
701: ; / 2 | 1 \
702: ;
703:
704: ; ebx = M0
705: ; ecx = N0
706: ; esi = M1 (dM)
707: ; edi = N1 (dN)
708:
709: mov [esp].sf_ptfxStart.ptl_x,ebx
710: mov [esp].sf_ptfxStart.ptl_y,ecx
711: mov [esp].sf_ptfxEnd.ptl_x,esi
712: mov [esp].sf_ptfxEnd.ptl_y,edi
713: ;save points in case we have to punt
714: mov eax,ebx
715: or eax,ecx
716: or eax,esi
717: or eax,edi
718: and eax,F-1
719: jnz non_integer
720:
721: ;/////////////////////////////////////////////////////////////////////
722: ;// Integer Lines
723: ;/////////////////////////////////////////////////////////////////////
724:
725: sar ebx,FLOG2 ;x0
726: sar ecx,FLOG2 ;y0
727: sar esi,FLOG2 ;x1 (soon to be dx)
728: sar edi,FLOG2 ;y1 (soon to be dy)
729:
730: sub esi,ebx
731: jl int_2_3_4_5
732: jz int_radial_90_270
733: sub edi,ecx
734: jl int_6_7
735: jz int_radial_0
736: cmp esi,edi
737: jl int_1
738: je int_radial_315
739:
740: int_0:
741: lea ebp,[esi - 1]
742: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y + PLUS_X
743: mov [esp].sf_ulErrorTerm,ebp
744:
745: jmp int_output_line
746:
747: public int_1
748: int_1:
749: xchg esi,edi
750: lea ebp,[esi - 1]
751: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y + PLUS_X + MAJOR_Y
752: mov [esp].sf_ulErrorTerm,ebp
753:
754: jmp int_output_line
755:
756: public int_2_3_4_5
757: int_2_3_4_5:
758: neg esi
759: sub edi,ecx
760: jl int_4_5
761: jz int_radial_180
762: cmp esi,edi
763: jl int_2
764: je int_radial_225
765:
766: public int_3
767: int_3:
768: lea ebp,[esi - 1]
769: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y
770: mov [esp].sf_ulErrorTerm,ebp
771:
772: jmp int_output_line
773:
774: public int_2
775: int_2:
776: xchg esi,edi
777: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y + MAJOR_Y
778: mov [esp].sf_ulErrorTerm,esi
779:
780: jmp int_output_line
781:
782: public int_4_5
783: int_4_5:
784: neg edi
785: cmp esi,edi
786: jl int_5
787: je int_radial_135
788:
789: int_4:
790: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD
791: mov [esp].sf_ulErrorTerm,esi
792:
793: jmp int_output_line
794:
795: public int_5
796: int_5:
797: xchg esi,edi
798: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + MAJOR_Y
799: mov [esp].sf_ulErrorTerm,esi
800:
801: jmp int_output_line
802:
803: public int_6_7
804: int_6_7:
805: neg edi
806: cmp esi,edi
807: jg int_7
808: je int_radial_45
809:
810: int_6:
811: xchg esi,edi
812: lea ebp,[esi - 1]
813: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + MAJOR_Y + PLUS_X
814: mov [esp].sf_ulErrorTerm,ebp
815:
816: jmp int_output_line
817:
818: public int_7
819: int_7:
820: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_X
821: mov [esp].sf_ulErrorTerm,esi
822:
823: jmp int_output_line
824:
825: ;/////////////////////////////////////////////////////////////////////
826: ;// Lines In The 8 Cardinal Directions
827: ;/////////////////////////////////////////////////////////////////////
828:
829: public int_radial_45
830: int_radial_45:
831: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
832: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_45
833: jmp short int_output_radial
834:
835: public int_radial_135
836: int_radial_135:
837: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
838: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_135
839: jmp short int_output_radial
840:
841: public int_radial_225
842: int_radial_225:
843: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
844: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_225
845: jmp short int_output_radial
846:
847: public int_radial_315
848: int_radial_315:
849: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
850: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_315
851: jmp short int_output_radial
852:
853: public int_radial_90_270
854: int_radial_90_270:
855: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
856: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_270
857: mov esi,edi
858: sub esi,ecx
859: jg short int_output_radial ;if top-to-bottom vertical line
860: jz next_line ;if zero length line
861:
862: neg esi
863: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
864: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_90
865: jmp short int_output_radial
866:
867: public int_radial_180
868: int_radial_180:
869: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
870: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_180
871: jmp short int_output_radial
872:
873: int_radial_0:
874: mov ebp,DRAW_LINE + DRAW + DIR_TYPE_RADIAL + WRITE + \
875: LAST_PIXEL_OFF + MULTIPLE_PIXELS + DRAWING_DIRECTION_0
876:
877: ; ebx = x
878: ; ecx = y
879: ; esi = dx (length of radial line since it's normalized)
880: ; ebp = drawing command
881:
882: public int_output_radial
883: int_output_radial:
884: mov edi,[esp].sf_ppdev
885: cmp [esp].sf_bSetCP,0
886: je short int_radial_continue_figure
887:
888: mov dx,[edi].pdev_gp_stat
889: @@: in ax,dx
890: and eax,FIFO_4_EMPTY
891: jnz short @b
892:
893: mov dx,[edi].pdev_cur_x
894: mov eax,ebx
895: out dx,ax
896:
897: mov dx,[edi].pdev_cur_y
898: mov eax,ecx
899: out dx,ax
900:
901: mov [esp].sf_bSetCP,0 ;the next integer line in this figure
902: ; will have the CP set correctly
903:
904: cmp esi,[esp].sf_ulLastLength
905: je short @f
906:
907: mov dx,[edi].pdev_line_max
908: mov eax,esi
909: out dx,ax
910: mov [esp].sf_ulLastLength,eax
911: @@:
912: mov dx,[edi].pdev_cmd
913: mov eax,ebp
914: out dx,ax
915: jmp next_line
916:
917: ; Jump to here if we don't have to update the current position first:
918:
919: public int_radial_continue_figure
920: int_radial_continue_figure:
921: cmp esi,[esp].sf_ulLastLength
922: je short int_radial_skip_length
923:
924: mov dx,[edi].pdev_gp_stat
925: @@: in ax,dx
926: and eax,FIFO_2_EMPTY
927: jnz short @b
928:
929: mov dx,[edi].pdev_line_max
930: mov eax,esi
931: out dx,ax
932: mov [esp].sf_ulLastLength,eax
933:
934: mov dx,[edi].pdev_cmd
935: mov eax,ebp
936: out dx,ax
937: jmp next_line
938:
939: ; Jump to here if we don't have to update the current position or the
940: ; line length variable:
941:
942: public int_radial_skip_length
943: int_radial_skip_length:
944: mov dx,[edi].pdev_gp_stat
945: @@: in ax,dx
946: and eax,FIFO_1_EMPTY
947: jnz short @b
948:
949: mov dx,[edi].pdev_cmd
950: mov eax,ebp
951: out dx,ax
952: jmp next_line
953:
954: ;/////////////////////////////////////////////////////////////////////
955: ;// Non-Integer Lines
956: ;/////////////////////////////////////////////////////////////////////
957:
958: public non_integer
959: non_integer:
960: sub esi,ebx
961: jl non_int_2_3_4_5
962: sub edi,ecx
963: jl non_int_6_7
964: cmp esi,edi
965: jl non_int_1
966: je non_int_0_slope_one
967:
968: non_int_0:
969: cmp esi,MAX_GIQ_DELTA
970: jg punt_line
971:
972: GIQ ROUND_X_AND_Y_DOWN
973:
974: non_int_0_common:
975: add ecx,edi ;err += dN
976: mov [esp].sf_ulErrorTerm,ecx
977:
978: mov eax,[esp].sf_x1
979: sub eax,ebx
980: jle next_line
981: mov [esp].sf_cPels,eax
982: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y + PLUS_X
983:
984: public non_int_x_major
985: non_int_x_major:
986: mov ecx,[esp].sf_ppdev
987: mov dx,[ecx].pdev_gp_stat
988: @@: in ax,dx
989: and eax,FIFO_7_EMPTY ;wait for 7 entries
990: jnz short @b
991:
992: ; Fractional end-point lines aren't usually going to have the current
993: ; position already set correctly, so we explicitly set the CP each time:
994:
995: mov dx,[ecx].pdev_cur_x
996: mov eax,ebx
997: out dx,ax ;x0
998:
999: mov dx,[ecx].pdev_cur_y
1000: mov eax,ebp
1001: out dx,ax ;y0
1002:
1003: mov [esp].sf_bSetCP,1 ;the next integer line in this figure
1004: ; will not necessarily have the CP set
1005: ; correctly
1006:
1007: mov eax,[esp].sf_cPels
1008: cmp eax,[esp].sf_ulLastLength
1009: je short @f
1010:
1011: mov dx,[ecx].pdev_line_max
1012: out dx,ax ;length = cPels
1013: mov [esp].sf_ulLastLength,eax
1014: @@:
1015: mov dx,[ecx].pdev_axstp
1016: mov eax,edi
1017: out dx,ax ;axial = dN
1018:
1019: mov dx,[ecx].pdev_diastp
1020: sub eax,esi
1021: out dx,ax ;diag = dN - dM
1022:
1023: mov dx,[ecx].pdev_err_term
1024: mov eax,[esp].sf_ulErrorTerm
1025: out dx,ax ;error term
1026:
1027: mov dx,[ecx].pdev_cmd
1028: mov eax,[esp].sf_ulCmd
1029: out dx,ax ;output it
1030:
1031: jmp next_line
1032:
1033: ; Lines of slope one have a special rounding rule: when the line
1034: ; runs exactly half way between two pixels, the upper or right pel
1035: ; is illuminated. This translates into x=1/2 rounding up in value,
1036: ; and y=1/2 rounding down:
1037:
1038: public non_int_0_slope_one
1039: non_int_0_slope_one:
1040: or esi,esi
1041: jz next_line ;quick check for a zero length GIQ line
1042:
1043: cmp esi,MAX_GIQ_DELTA
1044: jg punt_line
1045:
1046: GIQ ROUND_Y_DOWN_SLOPE_ONE
1047: jmp non_int_0_common
1048:
1049: public non_int_1
1050: non_int_1:
1051: cmp edi,MAX_GIQ_DELTA
1052: jg punt_line
1053:
1054: GIQR ROUND_X_AND_Y_DOWN
1055: add ecx,esi ;err += dM
1056: mov [esp].sf_ulErrorTerm,ecx
1057:
1058: mov eax,[esp].sf_y1
1059: sub eax,ebp
1060: jle next_line
1061: mov [esp].sf_cPels,eax
1062: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y + PLUS_X + MAJOR_Y
1063:
1064: public non_int_y_major
1065: non_int_y_major:
1066: mov ecx,[esp].sf_ppdev
1067: mov dx,[ecx].pdev_gp_stat
1068: @@: in ax,dx
1069: and eax,FIFO_7_EMPTY ;wait for 7 entries
1070: jnz short @b
1071:
1072: ; Fractional end-point lines aren't usually going to have the current
1073: ; position already set correctly, so we explicitly set the CP each time:
1074:
1075: mov dx,[ecx].pdev_cur_x
1076: mov eax,ebx
1077: out dx,ax ;x0
1078:
1079: mov dx,[ecx].pdev_cur_y
1080: mov eax,ebp
1081: out dx,ax ;y0
1082:
1083: mov [esp].sf_bSetCP,1 ;the next integer line in this figure
1084: ; will not necessarily have the CP set
1085: ; correctly
1086:
1087: mov eax,[esp].sf_cPels
1088: cmp eax,[esp].sf_ulLastLength
1089: je short @f
1090:
1091: mov dx,[ecx].pdev_line_max
1092: out dx,ax ;length = cPels
1093: mov [esp].sf_ulLastLength,eax
1094: @@:
1095: mov dx,[ecx].pdev_axstp
1096: mov eax,esi
1097: out dx,ax ;axial = dM
1098:
1099: mov dx,[ecx].pdev_diastp
1100: sub eax,edi
1101: out dx,ax ;diag = dM - dN
1102:
1103: mov dx,[ecx].pdev_err_term
1104: mov eax,[esp].sf_ulErrorTerm
1105: out dx,ax ;error term
1106:
1107: mov dx,[ecx].pdev_cmd
1108: mov eax,[esp].sf_ulCmd
1109: out dx,ax ;output it
1110:
1111: jmp next_line
1112:
1113: public non_int_2_3_4_5
1114: non_int_2_3_4_5:
1115: neg esi ;dM = -dM (now positive)
1116: neg ebx ;M0 = -M0
1117: sub edi,ecx
1118: jl non_int_4_5
1119: cmp esi,edi
1120: jl non_int_2
1121:
1122: non_int_3:
1123: cmp esi,MAX_GIQ_DELTA
1124: jg punt_line
1125:
1126: GIQ ROUND_Y_DOWN
1127: add ecx,edi ;err += dN
1128: mov [esp].sf_ulErrorTerm,ecx
1129:
1130: neg ebx ;untransform x0
1131:
1132: mov eax,[esp].sf_x1
1133: add eax,ebx
1134: jle next_line
1135: mov [esp].sf_cPels,eax
1136: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y
1137:
1138: jmp non_int_x_major
1139:
1140: public non_int_2
1141: non_int_2:
1142: cmp edi,MAX_GIQ_DELTA
1143: jg punt_line
1144:
1145: GIQR ROUND_Y_DOWN
1146: add ecx,esi ;err += dM
1147: mov [esp].sf_ulErrorTerm,ecx
1148:
1149: neg ebx ;untransform x0
1150:
1151: mov eax,[esp].sf_y1
1152: sub eax,ebp
1153: jle next_line
1154: mov [esp].sf_cPels,eax
1155: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_Y + MAJOR_Y
1156:
1157: jmp non_int_y_major
1158:
1159: public non_int_4_5
1160: non_int_4_5:
1161: neg edi ;dN = -dN (now positive)
1162: neg ecx ;N0 = -N0
1163: cmp esi,edi
1164: jl non_int_5
1165: je non_int_4_slope_one
1166:
1167: public non_int_4
1168: non_int_4:
1169: cmp esi,MAX_GIQ_DELTA
1170: jg punt_line
1171:
1172: GIQ 0
1173:
1174: non_int_4_common:
1175: add ecx,edi ;err += dN
1176: mov [esp].sf_ulErrorTerm,ecx
1177:
1178: neg ebx ;untransform x0
1179: neg ebp ;untransform y0
1180:
1181: mov eax,[esp].sf_x1
1182: add eax,ebx
1183: jle next_line
1184: mov [esp].sf_cPels,eax
1185: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD
1186:
1187: jmp non_int_x_major
1188:
1189: ; Lines of slope one have a special rounding rule.
1190:
1191: public non_int_4_slope_one
1192: non_int_4_slope_one:
1193: cmp esi,MAX_GIQ_DELTA
1194: jg punt_line
1195:
1196: GIQ ROUND_X_DOWN_SLOPE_ONE
1197: jmp non_int_4_common
1198:
1199: public non_int_5
1200: non_int_5:
1201: cmp edi,MAX_GIQ_DELTA
1202: jg punt_line
1203:
1204: GIQR 0
1205: add ecx,esi ;err += dM
1206: mov [esp].sf_ulErrorTerm,ecx
1207:
1208: neg ebx ;untransform x0
1209: neg ebp ;untransform y0
1210:
1211: mov eax,[esp].sf_y1
1212: add eax,ebp
1213: jle next_line
1214: mov [esp].sf_cPels,eax
1215: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + MAJOR_Y
1216:
1217: jmp non_int_y_major
1218:
1219: public non_int_6_7
1220: non_int_6_7:
1221: neg edi ;dN = -dN (now positive)
1222: neg ecx ;M0 = -M0
1223: cmp esi,edi
1224: je non_int_7_slope_one
1225: jg non_int_7
1226:
1227: public non_int_6
1228: non_int_6:
1229: cmp edi,MAX_GIQ_DELTA
1230: jg punt_line
1231:
1232: GIQR ROUND_X_DOWN
1233: add ecx,esi ;err += dM
1234: mov [esp].sf_ulErrorTerm,ecx
1235:
1236: neg ebp ;untransform y0
1237:
1238: mov eax,[esp].sf_y1
1239: add eax,ebp
1240: jle next_line
1241: mov [esp].sf_cPels,eax
1242: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + MAJOR_Y + PLUS_X
1243:
1244: jmp non_int_y_major
1245:
1246: public non_int_7
1247: non_int_7:
1248: cmp esi,MAX_GIQ_DELTA
1249: jg punt_line
1250:
1251: GIQ ROUND_X_DOWN
1252:
1253: non_int_7_common:
1254: add ecx,edi ;err += dN
1255: mov [esp].sf_ulErrorTerm,ecx
1256:
1257: neg ebp ;untransform y0
1258:
1259: mov eax,[esp].sf_x1
1260: sub eax,ebx
1261: jle next_line
1262: mov [esp].sf_cPels,eax
1263: mov [esp].sf_ulCmd,DEFAULT_DRAW_CMD + PLUS_X
1264:
1265: jmp non_int_x_major
1266:
1267: public non_int_7_slope_one
1268: non_int_7_slope_one:
1269: cmp esi,MAX_GIQ_DELTA
1270: jg punt_line
1271:
1272: GIQ ROUND_X_DOWN_SLOPE_ONE
1273: jmp non_int_7_common
1274:
1275: ;/////////////////////////////////////////////////////////////////////
1276: ;// Punt Line
1277: ;/////////////////////////////////////////////////////////////////////
1278:
1279: ; If the line is too long, we punt to our strip drawing routine.
1280:
1281: public punt_line
1282: punt_line:
1283: mov esi,esp
1284: lea eax,[esp].sf_ptfxStart
1285: lea ebx,[esp].sf_ptfxEnd
1286:
1287: cCall bLines,<[esi].sf_ppdev, eax, ebx, 0, 1, 0, \
1288: [esi].sf_prclClip, [esi].sf_apfn, [esi].sf_flags>
1289:
1290: mov [esp].sf_bSetCP,1 ;Always reset CP after punting
1291: mov [esp].sf_ulLastLength,-1;Always reset line length after punting
1292:
1293: jmp next_line
1294:
1295: endProc vFastLine
1296:
1297: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.