home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / GLOVE / OBJGLV.ZIP / SRC / DEMO4B / DRV256 / VGAXLINE.ASM < prev   
Assembly Source File  |  1993-05-12  |  15KB  |  815 lines
  1.  
  2.     TITLE   VGAsLINE - Fast line drawing routine.
  3.     NAME    VGAsLINE
  4.  
  5.     COMMENT $
  6.  
  7.     Name:           VGAsLINE
  8.  
  9.         Written and (c) by Dave Stampe 9/11/91
  10.         Not for commercial use, so get permission
  11.         before marketing code using this stuff!
  12.         For private PD use only.
  13.  
  14.         $
  15.  
  16.  
  17.  
  18.     COMMENT $
  19.  
  20.     Name:           VGALINE
  21.  
  22.     Function:       Draw a line in VGA 200 line 256 color X mode
  23.  
  24.     Caller:         C:
  25.  
  26.             void vgaline(x1, y1, x2, y2, n);
  27.                 int     x1, y1, x2, y2; /* pixel co-ords */
  28.                 int     n;              /* color */
  29.  
  30.             no checking on endpoints!
  31.  
  32.     Adapted from Richard Wilton's code (PC and PS/2 Video Systems).
  33.     Modified to use VGA X mode
  34.     Call setup_hdwe()  before drawing groups of lines
  35.  
  36.         $
  37.  
  38.  
  39.  
  40.         .MODEL LARGE
  41.         .DATA
  42.         PUBLIC    _x1clipl
  43.         PUBLIC    _x2clipl
  44.         PUBLIC    _y1clipl
  45.         PUBLIC    _y2clipl
  46. _x1clipl    dw    0
  47. _x2clipl    dw    0
  48. _y1clipl    dw    0
  49. _y2clipl    dw    0
  50.         .CODE
  51.  
  52.         extrn _dpaddr
  53.  
  54. BytesPerLine    EQU             80
  55.  
  56. egapaddr        PROC    far
  57.  
  58.         mov     cl,bl
  59.         push    dx
  60.  
  61.         mov     dx,BytesPerLine
  62.         mul     dx
  63.  
  64.         pop     dx
  65.         shr     bx,1
  66.         shr     bx,1
  67.         add     bx,ax
  68.         add     bx,word ptr ds:_dpaddr
  69.  
  70.         and     cl,3
  71.           ; xor     cl,3
  72.         mov     al,1
  73.         ret
  74.  
  75. egapaddr        endp
  76.  
  77.  
  78.  
  79. ; Stack frame addressing - LARGE CODE MODEL
  80.  
  81. ARGx1           EQU     word ptr [bp+6]
  82. ARGy1           EQU     word ptr [bp+8]
  83. ARGx2           EQU     word ptr [bp+10]
  84. ARGy2           EQU     word ptr [bp+12]
  85. ARGn            EQU     byte ptr [bp+14]
  86.  
  87. VARvertincr     EQU     word ptr [bp-6]
  88. VARincr1        EQU     word ptr [bp-8]
  89. VARincr2        EQU     word ptr [bp-10]
  90. VARroutine      EQU     word ptr [bp-12]
  91.  
  92. ByteOffsetShift EQU     2
  93. RMWbits         EQU     0
  94.  
  95.         PUBLIC  _vgaline
  96.  
  97.  
  98. _vgaline        PROC    far
  99.         .386
  100.  
  101.         push    bp              ; Set up stack frame
  102.         mov     bp,sp
  103.         sub     sp,14
  104.     push    si
  105.     push    di
  106.     push    cx
  107.     push    dx
  108.  
  109. ; set color
  110.  
  111.         mov     ax,0a000h
  112.         mov     es,ax
  113.  
  114.         mov     bl,ARGn
  115.         mov     bh,0ffh
  116.         mov     al,es:[bx]      ; load latches with color samples
  117.  
  118.         mov     dx,03C4H        ; setup for plane mask access
  119.         mov     al,2
  120.         out     dx,al
  121.         inc     dx
  122.  
  123. ; check for vertical line
  124.  
  125.         mov     si,BytesPerLine
  126.         mov     cx,ARGx2
  127.         sub     cx,ARGx1
  128.         jz      VertLine
  129.  
  130. ; force x1 < x2
  131.  
  132.         jns     L01
  133.  
  134.         neg     cx
  135.  
  136.         mov     bx,ARGx2
  137.         xchg    bx,ARGx1
  138.         mov     ARGx2,bx
  139.  
  140.         mov     bx,ARGy2
  141.         xchg    bx,ARGy1
  142.         mov     ARGy2,bx
  143.  
  144. ; calc dy = abs(y2 - y1)
  145.  
  146. L01:
  147.         mov     bx,ARGy2
  148.         sub     bx,ARGy1
  149.         jz      HorizLine
  150.         jns     L03
  151.  
  152.         neg     bx
  153.         neg     si
  154.  
  155. ; select appropriate routine for slope of line
  156.  
  157. L03:
  158.         mov     VARvertincr,si
  159.         mov     VARroutine,offset LoSlopeLine
  160.         cmp     bx,cx
  161.         jle     L04
  162.         mov     VARroutine,offset HiSlopeLine
  163.         xchg    bx,cx
  164.  
  165. ; calc initial decision variable and increments
  166.  
  167. L04:
  168.         shl     bx,1
  169.         mov     VARincr1,bx
  170.         sub     bx,cx
  171.         mov     si,bx
  172.         sub     bx,cx
  173.         mov     VARincr2,bx
  174.  
  175. ; calc first pixel address
  176.  
  177.         push    cx
  178.         mov     ax,ARGy1
  179.         mov     bx,ARGx1
  180.         call    egapaddr
  181.         mov     di,bx
  182.         shl     al,cl
  183.         mov     ah,al           ; duplicate nybble
  184.         shl     al,4
  185.         add     al,ah
  186.         mov     bl,al
  187.         pop     cx
  188.         inc     cx
  189.         jmp     VARroutine
  190.  
  191. ; routine for verticle lines
  192.  
  193. VertLine:
  194.         mov     ax,ARGy1
  195.         mov     bx,ARGy2
  196.         mov     cx,bx
  197.         sub     cx,ax
  198.         jge     L31
  199.         neg     cx
  200.         mov     ax,bx
  201.  
  202. L31:
  203.         inc     cx
  204.         mov     bx,ARGx1
  205.         push    cx
  206.         call    egapaddr
  207.  
  208.         shl     al,cl
  209.         out     dx,al
  210.         pop     cx
  211.  
  212. ; draw the line
  213.  
  214. L32:
  215.         mov     es:[bx],ah
  216.         add     bx,si
  217.         loop    L32
  218.         jmp     Lexit
  219.  
  220. ; routine for horizontal line
  221.  
  222. HorizLine:
  223.         push    ds
  224.  
  225.         mov     ax,ARGy1
  226.         mov     bx,ARGx1
  227.         call    egapaddr
  228.         mov     di,bx
  229.         mov     dl,0ffh
  230.         shl     dl,cl
  231.  
  232.         mov     cx,ARGx2
  233.         and     cl,3
  234.         mov     dh,0feH
  235.         shl     dh,cl
  236.         not     dh
  237.  
  238. ; determine byte offset of first and last pixel in line
  239.  
  240.         mov     ax,ARGx2
  241.         mov     bx,ARGx1
  242.         mov     cl,ByteOffsetShift
  243.  
  244.         shr     ax,cl
  245.         shr     bx,cl
  246.         mov     cx,ax
  247.         sub     cx,bx
  248.  
  249.         mov     ax,dx
  250.         mov     dx,03c5h
  251.  
  252. ; set pixels in leftmost byte of line
  253.  
  254.         or      cx,cx
  255.         jnz     L42
  256.         and     ah,al
  257.         jmp     short L44
  258.  
  259. L42:
  260.         out     dx,al
  261.         stosb
  262.         dec     cx
  263.  
  264. ; draw remainder of the line
  265.  
  266. L43:
  267.         mov     al,0FFH
  268.         out     dx,al
  269.         rep     stosb
  270.  
  271. ; set pixels in rightmost byte of line
  272.  
  273. L44:
  274.         mov     al,ah
  275.         out     dx,al
  276.         mov     es:[di],bl
  277.         pop     ds
  278.         jmp     short Lexit
  279.  
  280.  
  281. ; routine for dy >= dx (slope <= 1)
  282.  
  283. LoSlopeLine:
  284.  
  285. L10:
  286.         mov     al,bl
  287.  
  288. L11:
  289.         or      al,bl
  290.         rol     bl,1
  291.         jc      L14
  292.  
  293. ; bit mask not shifted out
  294.  
  295.         or      si,si
  296.         jns     L12
  297.         add     si,VARincr1
  298.         loop    L11
  299.  
  300.         out     dx,al
  301.         mov     es:[di],ah
  302.         jmp     short Lexit
  303.  
  304. L12:
  305.         add     si,VARincr2
  306.         out     dx,al
  307.         mov     es:[di],ah
  308.         add     di,VARvertincr
  309.         loop    L10
  310.         jmp     short Lexit
  311.  
  312. ; bit mask shifted out
  313.  
  314. L14:            out     dx,al
  315.         stosb
  316.         or      si,si
  317.         jns     L15
  318.         add     si,VARincr1
  319.         loop    L10
  320.         jmp     short Lexit
  321.  
  322. L15:
  323.         add     si,VARincr2
  324.         add     di,VARvertincr
  325.         loop    L10
  326.         jmp     short Lexit
  327.  
  328.  
  329.  
  330. ; routine for dy > dx (slope > 1)
  331.  
  332. HiSlopeLine:
  333.         mov     bx,VARvertincr
  334.  
  335. L21:            out     dx,al
  336.         mov     es:[di],ah
  337.         add     di,bx
  338.  
  339. L22:
  340.         or      si,si
  341.         jns     L23
  342.  
  343.         add     si,VARincr1
  344.         loop    L21
  345.         jmp     short Lexit
  346.  
  347. L23:
  348.         add     si,VARincr2
  349.         rol     al,1
  350.         adc     di,0
  351. lx21:           loop    L21
  352.  
  353. ; return to caller
  354.  
  355. Lexit:
  356.     pop     dx
  357.     pop     cx
  358.     pop     di
  359.     pop     si
  360.         mov     sp,bp
  361.         pop     bp
  362.         ret
  363.  
  364. _vgaline        endp
  365.  
  366.  
  367.     COMMENT $
  368.  
  369.     Name:           VGAPOINT
  370.  
  371.     Function:       Draw a line in VGA 200 line 256 color X mode
  372.  
  373.     Caller:         C:
  374.  
  375.             void vgapoint(x1, y1, n);
  376.                 int     x1, y1;         /* pixel co-ords */
  377.                 int     n;              /* color */
  378.  
  379.             no checking on endpoints!
  380.  
  381.     Call setup_hdwe()  before drawing groups of points
  382.  
  383.         $
  384.  
  385.         extrn _dpaddr
  386.  
  387. ; Stack frame addressing - LARGE CODE MODEL
  388.  
  389. ARGx1           EQU     word ptr [bp+6]
  390. ARGy1           EQU     word ptr [bp+8]
  391. ARGn            EQU     byte ptr [bp+10]
  392.  
  393.         PUBLIC  _vgapoint
  394.  
  395. _vgapoint       PROC    far
  396.         .386
  397.  
  398.         push    bp              ; Set up stack frame
  399.         mov     bp,sp
  400.  
  401.         mov     ax,0a000h       ; ES points to display memory
  402.         mov     es,ax
  403.  
  404.         mov     bl,ARGn
  405.         mov     bh,0ffh
  406.         mov     al,es:[bx]      ; load latches with color samples
  407.  
  408.         mov     dx,03C4H        ; setup for plane mask access
  409.         mov al,2
  410.         out     dx,al
  411.  
  412.         mov     ax,ARGy1        ; bx = y * 80 + x / 4 + pageoffset;
  413.         push    dx
  414.         mov     dx,80
  415.         mul     dx
  416.         pop     dx
  417.         mov     bx,ARGx1
  418.         mov     cx,bx
  419.         shr     bx,1
  420.         shr     bx,1
  421.         add     bx,ax
  422.         add     bx,word ptr ds:_dpaddr
  423.         and     cl,3                             ; ax = 1 << (x % 4);
  424.         mov     al,1
  425.         shl     al,cl
  426.         mov     dx,03C5H          ; setup for plane mask access
  427.         out     dx,al               ; set mask register
  428.         mov     es:[bx],ah      ; write to the display
  429.         mov     sp,bp
  430.         pop     bp
  431.         ret
  432.  
  433. _vgapoint       endp
  434.  
  435.  
  436.  
  437.      ;
  438.      ;      int clipper ()
  439.      ;
  440.      ;  /* returns 0 if unclipped, 1 if clipped, and -1 if invisible */
  441.      ;
  442.    ;  Improved assembly version of Sutherland-Cohen line clipper
  443.    ;  Much more optimized than C version, and knows when to
  444.    ;  stop clipping!
  445.    ;
  446.  
  447.     PUBLIC  _clipper
  448.  
  449. ;    EXTRN   _x1clipl              ; line to clip (assumed in ds)
  450. ;    EXTRN   _y1clipl
  451. ;    EXTRN   _x2clipl
  452. ;    EXTRN   _y2clipl
  453.  
  454. x1      EQU     word ptr _x1clipl     ; elements in point array
  455. y1      EQU     word ptr _y1clipl
  456. x2      EQU     word ptr _x2clipl
  457. y2      EQU     word ptr _y2clipl
  458.  
  459. left  equ 8                          ; clipping flag bits
  460. above equ 4
  461. right equ 2
  462. below equ 1
  463.  
  464.     EXTRN   _l_clip              ; clipping recangle (assumed in ds)
  465.     EXTRN   _r_clip
  466.     EXTRN   _t_clip
  467.     EXTRN   _b_clip
  468.  
  469. _clipper        proc    far
  470.  
  471.     .386                            ; required for jump length only
  472.  
  473.     push    bp
  474.     mov     bp,sp
  475.     dec     sp
  476.     dec     sp
  477.     push    si
  478.     push    di
  479.     push    cx
  480.     push    dx
  481.  
  482.     xor     di,di                   ; flag1 = 0
  483.  
  484.     mov     ax,x1
  485.     cmp     ax,word ptr ds:_l_clip  ; set flag bits based on pos'n
  486.     jge     short nleft1            ; for point 1
  487.     or      di,8
  488. nleft1:
  489.     cmp     ax,word ptr ds:_r_clip
  490.     jle     short nright1
  491.     or      di,2
  492. nright1:
  493.     mov     ax,y1
  494.     cmp     ax,word ptr ds:_t_clip
  495.     jge     short ntop1
  496.     or      di,4
  497. ntop1:
  498.     cmp     ax,word ptr ds:_b_clip
  499.     jle     short nbot1
  500.     or      di,1
  501. nbot1:
  502.     xor     si,si                   ; flag2 = 0
  503.  
  504.     mov     ax,x2
  505.     cmp     ax,word ptr ds:_l_clip  ; set flag bits based on pos'n
  506.     jge     short nleft2            ; for point 2
  507.     or      si,8
  508. nleft2:
  509.     cmp     ax,word ptr ds:_r_clip
  510.     jle     short nright2
  511.     or      si,2
  512. nright2:
  513.     mov     ax,y2
  514.     cmp     ax,word ptr ds:_t_clip
  515.     jge     short ntop2
  516.     or      si,4
  517. ntop2:
  518.     cmp     ax,word ptr ds:_b_clip
  519.     jle     short nbot2
  520.     or      si,1
  521. nbot2:
  522.  
  523.     mov     ax,di                   ; check if all inside rect
  524.     or      ax,si
  525.     jne     short not_in_box
  526.     xor     ax,ax                   ; return 0: not clipped
  527. rexit:
  528.     pop     dx
  529.     pop     cx
  530.     pop     di
  531.     pop     si
  532.     mov     sp,bp
  533.     pop     bp
  534.     ret
  535.  
  536. not_in_box:
  537.     test    di,si                   ; check if all out of rect
  538.     je      short needs_clipping
  539. diagerr:                                ; too many clipping (diagonal)
  540.     mov     ax,65535
  541.     jmp     rexit                   ; return -1 (out of window)
  542.  
  543. needs_clipping:                         ; gotta do some serious work...
  544.  
  545.     or      di,di                   ; quick test if pt.1 OK
  546.     jne     clip1
  547.     jmp     do2
  548.  
  549. clip1:                                  ; clipping point 1:
  550.  
  551.     test    di,8                    ; left flag?
  552.     je      short notleft1
  553.  
  554. doleft1:
  555.    ;
  556.    ;        lp->y1 += (long)(lp->y2-lp->y1)*(l_clip-lp->x1)/(lp->x2-lp->x1);
  557.    ;
  558.     mov     cx,x2                   ; denominator: 0?
  559.     sub     cx,x1
  560.     je      dontleft1
  561.  
  562.     mov     ax,y2
  563.     sub     ax,y1
  564.     mov     dx,word ptr ds:_l_clip
  565.     sub     dx,x1
  566.     imul    dx
  567.     idiv    cx
  568.     add     y1,ax
  569.  
  570. dontleft1:
  571.     mov     dx,word ptr ds:_l_clip           ; clip left
  572.     mov     x1,dx
  573.  
  574.     mov     ax,y1                   ; check if vert. clipping needed
  575.     cmp     ax,word ptr ds:_t_clip
  576.     jl      doabove1
  577.     cmp     ax,word ptr ds:_b_clip
  578.     jg      dobelow1
  579.     jmp     do2                     ; else check point 2
  580.  
  581. notleft1:
  582.     test    di,2                    ; test if right needs clipping
  583.     je      notright1
  584.  
  585. doright1:
  586.    ;
  587.    ;       lp->y1 += (long)(lp->y2-lp->y1)*(r_clip-lp->x1)/(lp->x2-lp->x1);
  588.    ;
  589.     mov     cx,x2                   ; denominator: 0?
  590.     sub     cx,x1
  591.     je      dontright1
  592.  
  593.     mov     ax,y2
  594.     sub     ax,y1
  595.     mov     dx,word ptr ds:_r_clip
  596.     sub     dx,x1
  597.     imul    dx
  598.     idiv    cx
  599.     add     y1,ax
  600.  
  601. dontright1:
  602.     mov     dx,word ptr ds:_r_clip           ; clip right
  603.     mov     x1,dx
  604.  
  605.     mov     ax,y1
  606.     cmp     ax,word ptr ds:_t_clip  ; check if vert. clipping needed
  607.     jl      doabove1
  608.     cmp     ax,word ptr ds:_b_clip
  609.     jg      dobelow1
  610.     jmp     do2
  611.  
  612. notright1:
  613.     test    di,4                    ; test if top clip needed
  614.     je      short notabove1
  615.  
  616. doabove1:
  617.    ;
  618.    ;     lp->x1 += (long)(lp->x2-lp->x1)*(t_clip-lp->y1)/(lp->y2-lp->y1);
  619.    ;
  620.     mov     cx,y2                   ; denominator: 0?
  621.     sub     cx,y1
  622.     je      dontabove1
  623.  
  624.     mov     ax,x2
  625.     sub     ax,x1
  626.     mov     dx,word ptr ds:_t_clip
  627.     sub     dx,y1
  628.     imul    dx
  629.     idiv    cx
  630.     add     x1,ax
  631.  
  632. dontabove1:
  633.     mov     dx,word ptr ds:_t_clip           ; clip top
  634.     mov     y1,dx
  635.  
  636.     mov     ax,x1
  637.     cmp     ax,word ptr ds:_l_clip  ; if hor. clip req, diagonal outside
  638.     jl      diagerr ; doleft1
  639.     cmp     ax,word ptr ds:_r_clip
  640.     jg      diagerr ;doright1
  641.     jmp     short do2
  642.  
  643. notabove1:
  644.     test    di,1                    ; test if bottom needs clipping
  645.     je      short do2
  646.  
  647. dobelow1:
  648.    ;
  649.    ;       lp->x1 += (long)(lp->x2-lp->x1)*(b_clip-lp->y1)/(lp->y2-lp->y1);
  650.    ;
  651.     mov     cx,y2                   ; denominator: 0?
  652.     sub     cx,y1
  653.     je      dontbelow1
  654.  
  655.     mov     ax,x2
  656.     sub     ax,x1
  657.     mov     dx,word ptr ds:_b_clip
  658.     sub     dx,y1
  659.     imul    dx
  660.     idiv    cx
  661.     add     x1,ax
  662.  
  663. dontbelow1:
  664.     mov     dx,word ptr ds:_b_clip
  665.     mov     y1,dx
  666.  
  667.     mov     ax,x1
  668.     cmp     ax,word ptr ds:_l_clip
  669.     jl      diagerr ;oleft1
  670.     cmp     ax,word ptr ds:_r_clip
  671.     jg      diagerr ;doright1
  672.  
  673.  
  674.  
  675.  
  676. do2:
  677.     or      si,si           ; same deal for point 2
  678.     je      done2
  679.     test    si,8
  680.     je      short notleft2
  681.  
  682. doleft2:
  683.    ;
  684.    ;      lp->y2 += (long)(lp->y1-lp->y2)*(l_clip-lp->x2)/(lp->x1-lp->x2);
  685.    ;
  686.     mov     cx,x1                   ; denominator: 0?
  687.     sub     cx,x2
  688.     je      dontleft2
  689.  
  690.     mov     ax,y1
  691.     sub     ax,y2
  692.     mov     dx,word ptr ds:_l_clip
  693.     sub     dx,x2
  694.     imul    dx
  695.     idiv    cx
  696.     add     y2,ax
  697.  
  698. dontleft2:
  699.     mov     dx,word ptr ds:_l_clip
  700.     mov     x2,dx
  701.  
  702.     mov     ax,y2
  703.     cmp     ax,word ptr ds:_t_clip
  704.     jl      doabove2
  705.     cmp     ax,word ptr ds:_b_clip
  706.     jg      dobelow2
  707.     jmp     done2
  708.  
  709. notleft2:
  710.     test    si,2                    ; test if right needs clipping
  711.     je      notright2
  712.  
  713. doright2:
  714.    ;
  715.    ;      lp->y2 += (long)(lp->y1-lp->y2)*(r_clip-lp->x2)/(lp->x1-lp->x2);
  716.    ;
  717.     mov     cx,x1                   ; denominator: 0?
  718.     sub     cx,x2
  719.     je      dontright2
  720.  
  721.     mov     ax,y1
  722.     sub     ax,y2
  723.     mov     dx,word ptr ds:_r_clip
  724.     sub     dx,x2
  725.     imul    dx
  726.     idiv    cx
  727.     add     y2,ax
  728.  
  729. dontright2:
  730.     mov     dx,word ptr ds:_r_clip
  731.     mov     x2,dx
  732.  
  733.     mov     ax,y2
  734.     cmp     ax,word ptr ds:_t_clip
  735.     jl      doabove2
  736.     cmp     ax,word ptr ds:_b_clip
  737.     jg      dobelow2
  738.     jmp     done2
  739.  
  740. notright2:
  741.     test    si,4                    ; test if top clip needed
  742.     je      short notabove2
  743.  
  744. doabove2:
  745.    ;
  746.    ;      lp->x2 += (long)(lp->x1-lp->x2)*(t_clip-lp->y2)/(lp->y1-lp->y2);
  747.    ;
  748.     mov     cx,y1                   ; denominator: 0?
  749.     sub     cx,y2
  750.     je      dontabove2
  751.  
  752.     mov     ax,x1
  753.     sub     ax,x2
  754.     mov     dx,word ptr ds:_t_clip
  755.     sub     dx,y2
  756.     imul    dx
  757.     idiv    cx
  758.     add     x2,ax
  759.  
  760. dontabove2:
  761.     mov     dx,word ptr ds:_t_clip
  762.     mov     y2,dx
  763.  
  764.     mov     ax,x2
  765.     cmp     ax,word ptr ds:_l_clip
  766.     jl      diagerr ;doleft2
  767.     cmp     ax,word ptr ds:_r_clip
  768.     jg      diagerr ;doright2
  769.     jmp     short done2
  770.  
  771. notabove2:
  772.     test    si,1                    ; test if bottom needs clipping
  773.     je      short done2
  774.  
  775. dobelow2:
  776.    ;
  777.    ;      lp->x2 += (long)(lp->x1-lp->x2)*(b_clip-lp->y2)/(lp->y1-lp->y2);
  778.    ;
  779.     mov     cx,y1                   ; denominator: 0?
  780.     sub     cx,y2
  781.     je      dontbelow2
  782.  
  783.     mov     ax,x1
  784.     sub     ax,x2
  785.     mov     dx,word ptr ds:_b_clip
  786.     sub     dx,y2
  787.     imul    dx
  788.     idiv    cx
  789.     add     x2,ax
  790.  
  791. dontbelow2:
  792.     mov     dx,word ptr ds:_b_clip
  793.     mov     y2,dx
  794.  
  795.     mov     ax,x2
  796.     cmp     ax,word ptr ds:_l_clip
  797.     jl      diagerr ;doleft2
  798.     cmp     ax,word ptr ds:_r_clip
  799.     jg      diagerr ;doright2
  800.  
  801. done2:                  ; finished point 2
  802.     mov     ax,1    ; return 1 for successful clipping
  803.     pop     dx
  804.     pop     cx
  805.     pop     di
  806.     pop     si
  807.     mov     sp,bp
  808.     pop     bp
  809.     ret
  810.  
  811. _clipper        endp
  812.  
  813.  
  814.     end
  815.