Rectangles and General Polygon Routines.

rect(x1, y1, x2, y2)

Draw a rectangle. Note: rectangles are regarded as polygons, so if polyfill or polyhatch has been called with 1, the rectangle will be filled or hatched accordingly.

    Fortran:
         subroutine rect(x1, y1, x2, y2)
         real x1, y1, x1, y2
    C:
         rect(x1, y1, x2, y2)
              float     x1, y1, x2, y2;

    Pascal:
         procedure Rect(x1, y1, x2, y2: real)

polyfill(onoff)

Set the polygon fill flag. This will always turn off hatching. A non-zero (.true. ) turns polyfill on.

    Fortran:
         subroutine polyfill(onoff)
         logical onoff
    C:
         polyfill(onoff)
              int  onoff;

    Pascal:
         procedure PolyFill(onoff: boolean)

polyhatch(onoff)

Set the polygon hatch flag. This will always turn off fill. A non-zero (.true.) turns polyhatch on. Note that hatched polygons must initially be defined parallel to the X-Y plane.

    Fortran:
         subroutine polyhatch(onoff)
         logical   onoff
    C:
         polyhatch(onoff)
              int  onoff;

    Pascal:
         procedure PolyHatch(onoff: boolean)

hatchang(angle)

Set the angle of the hatch lines.

    Fortran:
         subroutine hatchang(angle)
         real angle
    C:
         hatchang(angle)
              float     angle;

    Pascal:
         procedure HatchAng(angle: real)

hatchpitch(pitch)

Set the distance between hatch lines.

    Fortran:
         subroutine hatchpitch(pitch)
         real pitch
    C:
         hatchpitch(pitch)
              float     pitch;

    Pascal:
         procedure HatchPitch(pitch: real)

poly2(n, points)

Construct an (x, y) polygon from an array of points provided by the user.

    Fortran:
         subroutine poly2(n, points)
         integer   n
         real points(2, n)
    C:
         poly2(n,  points)
              int  n;
              float     points[][2];

    Pascal:
         procedure Poly2(n: integer; points: Poly2_array_t)

poly(n, points)

Construct a polygon from an array of points provided by the user.

    Fortran:
         subroutine poly(n, points)
         integer   n
         real points(3, n)
    C:
         poly(n,  points)
              int  n;
              float     points[][3];

    Pascal:
         procedure Poly(n: integer; points: Poly3_array_t)

makepoly()

makepoly opens up a polygon which will then be constructed by a series of move-draws and closed by a closepoly.

    Fortran:
         subroutine makepoly
    C:
         makepoly()

    Pascal:
         procedure MakePoly

closepoly()

Terminates a polygon opened by makepoly.

    Fortran:
         subroutine closepoly
    C:
         closepoly()

    Pascal:
         procedure ClosePoly

backface(onoff)

Turns on culling of backfacing polygons. A polygon is backfacing if it's orientation in *screen* coords is clockwise, unless a call to backfacedir is made.

    Fortran:
         subroutine backface(onoff)
         logical onoff

    C:
         backface(onoff)
              int  onoff;

    Pascal:
         procedure BackFace(onoff: boolean)

backfacedir(clockwise)

Sets the backfacing direction to clockwise or anti-clockwise depending on whether clockwise is 1 or 0. 1 = clockwise (in screen coords) 0 = anticlockwise.

    Fortran:
         subroutine backfacedir(clockwise)
         integer clockwise

    C:
         backfacedir(clockwise)
              int  clockwise;

    Pascal:
         procedure BackFaceDir(clockwise: boolean)