home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / VOGLE.ZIP / DOCS / VOGLE.DOC < prev    next >
Text File  |  2000-02-11  |  77KB  |  2,905 lines
  1.  
  2.  
  3.  
  4. VOGLE(3)               C Library Functions               VOGLE(3)
  5.  
  6.  
  7.  
  8. NAME
  9.      VOGLE - A very ordinary graphics learning environment.
  10.  
  11.  
  12. DESCRIPTION
  13.      VOGLE is a library of C routines for doing line drawings and
  14.      polygon  fills  in  2  and 3 Dimensions. It handles circles,
  15.      curves, arcs, patches, polygons, and software text in a dev-
  16.      ice  independent fashion. Simple hidden line removal is also
  17.      available via polygon backfacing. Access  to  hardware  text
  18.      and  double  buffering  of  drawings  depends on the driver.
  19.      There is also a FORTRAN interface but as it goes through the
  20.      C  routines FORTRAN users are warned that arrays are in row-
  21.      column order in C. A SUN Pascal interface has also been pro-
  22.      vided. The following is a brief summary of the VOGLE subrou-
  23.      tines.
  24.  
  25.   Include files.
  26.      There are two include files provided with vogle: vogle.h and
  27.      Vogle.h.   The  lowercase vogle.h is the C header file which
  28.      most vogle C programs would include. The  uppercase  Vogle.h
  29.      is   the   SUN   Pascal   header  file  which  contains  the
  30.      forward/external declarations for Pascal. This  header  file
  31.      should  be  included  just  after the program statement of a
  32.      Pascal program.
  33.  
  34.  
  35.  
  36.      The following is a brief summary of the VOGLE subroutines.
  37.  
  38.  
  39.   Using X toolkits and Sunview
  40.      For X11 and Sunview based applications, it  is  posible  for
  41.      VOGLE to use a window that is supplied by that application's
  42.      toolkit.  Under  these  circumstances,  the  toolkit  is  is
  43.      responsible  for handling of all input events, and VOGL sim-
  44.      ply draws into the supplied  window.  These calls  are  only
  45.      available  from  C.  Also  see  the directories examples/xt,
  46.      examples/xview and examples/sunview.
  47.  
  48.      For X based toolkits the following three calls may be used:
  49.  
  50.      vo_xt_window(display, xwin, width, height)
  51.           Tells VOGLE to use the supplied window xwin
  52.  
  53.                vo_xt_window(display, xwin, width, height)
  54.                     Display   *display;
  55.                     Window    xwin;
  56.                     int  width, height;
  57.  
  58.           This routine should be called before calling "vinit()".
  59.  
  60.  
  61.  
  62.  
  63. VOGLE 1.3.0         Last change: 15 Jun 1994                    1
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. VOGLE(3)               C Library Functions               VOGLE(3)
  71.  
  72.  
  73.  
  74.      vo_xt_win_size(width, height)
  75.           Tells VOGLE that the supplied window has changed size.
  76.  
  77.                vo_xt_win_size(width, height)
  78.                     int  width, height;
  79.  
  80.  
  81.      vo_xt_set_win(display, xwin, width, height)
  82.           Just tells VOGLE to draw into  that  particular  'Draw-
  83.           able'
  84.                vo_xt_set_win(display, xwin, width, height)
  85.                     Display   *display;
  86.                     Drawable xwin;
  87.                     int  width, height;
  88.  
  89.  
  90.  
  91.      vo_xt_get_display()
  92.           Returns the current display that VOGLE beleives  it  is
  93.           using.
  94.                Display *
  95.                vo_xt_get_display()
  96.  
  97.  
  98.      vo_xt_get_window()
  99.           Returns the current window that VOGLE  beleives  it  is
  100.           using.
  101.                Window
  102.                vo_xt_get_window()
  103.  
  104.  
  105.      vo_xt_get_GC()
  106.           Returns the current Graphics Context that VOGL beleives
  107.           it is using.
  108.                   GC
  109.                   vo_xt_get_GC()
  110.  
  111.  
  112.  
  113. For sunview based applications the following  two  calls  may  be
  114. used:
  115.  
  116.  
  117.      vo_sunview_canvas(canvas, width, height)
  118.           Tells VOGLE to use the supplied sunview canvas canvas
  119.  
  120.      vo_sunview_canvas(canvas, width, height)
  121.                     Canvas    canvas;
  122.                     int  width, height;
  123.  
  124.  
  125.           This routine should be called before calling "ginit()".
  126.  
  127.  
  128.  
  129. VOGLE 1.3.0         Last change: 15 Jun 1994                    2
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. VOGLE(3)               C Library Functions               VOGLE(3)
  137.  
  138.  
  139.  
  140.      vo_sunview_canvas_size(width, height)
  141.           Tells VOGLE that the supplied canvas has changed size.
  142.  
  143.                vo_sunview_canvas_size(width, height)
  144.                     int  width, height;
  145.  
  146.  
  147.  
  148.   Device routines.
  149.      vinit(device)
  150.           Initialise the device.
  151.  
  152.                Fortran:
  153.                     subroutine vinit(device)
  154.                     character *(*) device
  155.  
  156.                C:
  157.                     vinit(device);
  158.                     char     *device;
  159.  
  160.                Pascal:
  161.                     procedure Vinit(device: string_t)
  162.  
  163.  
  164.                Note 1 :- Current available devices are:
  165.                         tek - tektronix 4010 and compatibles
  166.                         hpgl - HP Graphics language and compatibles
  167.                         hpgt - HP Graphics Terminals and compatibles
  168.                         dxy - roland DXY plotter language
  169.                         postscript - mono postscript devices
  170.                         ppostscript - mono postscript devices (portrait mode)
  171.                         cps - colour postscript devices
  172.                         pcps - colour postscript devices (portrait mode)
  173.                         sun - Sun workstations running sunview
  174.                         X11 - X windows (SUN's OPenwindows etc etc)
  175.                         next - NeXTStep and other NeXT platforms
  176.                         decX11 - the decstation window manager
  177.                               (basically obsolete).
  178.                         apollo - Apollo workstations
  179.                               (basically obsolete).
  180.                         hercules - IBM PC hercules graphics card
  181.                         cga - IBM PC cga graphics card
  182.                         ega - IBM PC ega graphics card
  183.                         vga - IBM PC vga graphics card
  184.                         sigma - IBM PC sigma graphics card.
  185.                         mswin - IBM PC Microsoft Windows.
  186.                         os2pm - IBM PC OS/2 Presentation Manager
  187.                         grx   - the contributed GRX graphics library that
  188.                            is available with DJGPP (GNU for PCs).
  189.  
  190.                         Sun, X11, apollo, grx, mswin, os2pm, next, hercules, cga
  191.                         and ega support double buffering.
  192.  
  193.  
  194.  
  195. VOGLE 1.3.0         Last change: 15 Jun 1994                    3
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. VOGLE(3)               C Library Functions               VOGLE(3)
  203.  
  204.  
  205.  
  206.                Note 2 :- If device is a NULL or a null string the value
  207.                     of the environment variable "VDEVICE" is taken as the
  208.                     device type to be opened.
  209.  
  210.                Note 3 :- after init it is wise to explicitly
  211.                     clear the screen.
  212.  
  213.                e.g.: in C
  214.                     color(BLACK);
  215.                     clear();
  216.  
  217.                or    in Fortran
  218.                     call color(BLACK)
  219.                     call clear
  220.  
  221.                or    in Pascal
  222.                     Color(BLACK);
  223.                     Clear;
  224.  
  225.  
  226.      vexit()
  227.           Reset the window/terminal (must be the last VOGLE  rou-
  228.           tine called)
  229.  
  230.                Fortran:
  231.                     subroutine vexit
  232.  
  233.                C:
  234.                     vexit()
  235.  
  236.                Pascal:
  237.                     procedure Vexit;
  238.  
  239.  
  240.      voutput(path)
  241.           Redirect output from *next*  vinit  to  file  given  by
  242.           path. This routine only applies to devices drivers that
  243.           write to stdout e.g. postscript and hpgl.
  244.  
  245.                Fortran:
  246.                     subroutine voutput(path)
  247.                     character*(*) path
  248.  
  249.                C:
  250.                     voutput(path)
  251.                          char *path;
  252.  
  253.                Pascal:
  254.                     procedure Voutput(path: string_t)
  255.  
  256.  
  257.      vnewdev(device)
  258.  
  259.  
  260.  
  261. VOGLE 1.3.0         Last change: 15 Jun 1994                    4
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268. VOGLE(3)               C Library Functions               VOGLE(3)
  269.  
  270.  
  271.  
  272.           Reinitialize VOGLE to use a new device without changing
  273.           attributes,  viewport  etc.   (eg.  window and viewport
  274.           specifications)
  275.  
  276.                Fortran:
  277.                     subroutine vnewdev(device)
  278.                     character *(*) device
  279.  
  280.                C:
  281.                     vnewdev(device)
  282.                          char *device;
  283.  
  284.                Pascal:
  285.                     VnewDev(device: string_t)
  286.  
  287.  
  288.      vgetdev(device)
  289.           Gets the name of the current VOGLE device. The  C  ver-
  290.           sion  of  the  routine  also  returns a pointer to it's
  291.           argument.
  292.  
  293.                Fortran:
  294.                     subroutine vgetdev(device)
  295.                     character *(*) device
  296.  
  297.                C:
  298.                     char *
  299.                     vgetdev(device)
  300.                          char *device;
  301.  
  302.                Pascal:
  303.                     procedure VgetDev(var device: string_t)
  304.  
  305.  
  306.      pushdev(device)
  307.           Initialize a new device  without  changing  attributes,
  308.           viewport  etc, but save the previously initialised dev-
  309.           ice on a stack.
  310.  
  311.           Note, this is intended to completely change the device,
  312.           it  won't  work if you pushdev the same device that you
  313.           are already running.  (This will be fixed  at  a  later
  314.           date).
  315.  
  316.                Fortran:
  317.                     subroutine pushdev(device)
  318.                     character *(*) device
  319.  
  320.                C:
  321.                     pushdev(device)
  322.                          char *device;
  323.  
  324.  
  325.  
  326.  
  327. VOGLE 1.3.0         Last change: 15 Jun 1994                    5
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334. VOGLE(3)               C Library Functions               VOGLE(3)
  335.  
  336.  
  337.  
  338.                Pascal:
  339.                     PushDev(device: string_t)
  340.  
  341.  
  342.      popdev()
  343.           Pops a device off the device stack and  reinstates  the
  344.           previously pushed device.
  345.  
  346.  
  347.                Fortran:
  348.                     subroutine popdev()
  349.  
  350.                C:
  351.                     popdev()
  352.  
  353.                Pascal:
  354.                     PopDev
  355.  
  356.  
  357.      getdepth()
  358.           Returns the number of bit planes (or color planes)  for
  359.           a  particular  device. The number of colors displayable
  360.           by the device is then 2**(nplanes-1)
  361.  
  362.                Fortran:
  363.                     integer function  getdepth()
  364.  
  365.                C:
  366.                     int
  367.                     getdepth()
  368.  
  369.                Pascal:
  370.                     function GetDepth(): integer;
  371.  
  372.  
  373.   Routines For Setting Up Windows.
  374.      Some devices are basically window orientated - like  sunview
  375.      and  X11.  You can give vogle some information on the window
  376.      that it will use with these routines.  These can  make  your
  377.      code  very  device independant. Both routines take arguments
  378.      which are in device space. (0,  0)  is  the  top  left  hand
  379.      corner  in  device  space. To have any effect these routines
  380.      must be called before vinit.  For the X11 device,  an  entry
  381.      may   be   made   in   your  .Xdefaults  file  of  the  form
  382.      vogle.Geometry  =150x500+550+50  (where  you  specify   your
  383.      geometry as you please).
  384.  
  385.      prefposition(x, y)
  386.           Specify the preferred position of the window opened  by
  387.           the *next* vinit.
  388.  
  389.                Fortran:
  390.  
  391.  
  392.  
  393. VOGLE 1.3.0         Last change: 15 Jun 1994                    6
  394.  
  395.  
  396.  
  397.  
  398.  
  399.  
  400. VOGLE(3)               C Library Functions               VOGLE(3)
  401.  
  402.  
  403.  
  404.                     subroutine prefposition(x, y)
  405.                     integer x, y
  406.  
  407.                C:
  408.                     prefposition(x, y)
  409.                          int  x, y;
  410.  
  411.                Pascal:
  412.                     procedure PrefPosition(x, y: integer)
  413.  
  414.  
  415.      prefsize(width, height)
  416.           Specify the preferred width and height  of  the  window
  417.           opened by the *next* vinit.
  418.  
  419.                Fortran:
  420.                     subroutine prefsize(width, height)
  421.                     integer width, height
  422.  
  423.                C:
  424.                     prefsize(width, height)
  425.                          int  width, height;
  426.  
  427.                Pascal:
  428.                     procedure PrefSize(width, height: integer)
  429.  
  430.  
  431.   General Routines.
  432.      clear()
  433.           Clears the screen to the current colour.
  434.  
  435.                Fortran:
  436.                     subroutine clear
  437.  
  438.                C:
  439.                     clear()
  440.  
  441.                Pascal:
  442.                     procedure Clear
  443.  
  444.  
  445.      color(col)
  446.           Set the current colour. The  standard  colours  are  as
  447.           follows:
  448.                black = 0       red = 1         green = 2       yellow = 3
  449.                blue = 4        magenta = 5     cyan = 6        white = 7.
  450.  
  451.  
  452.                Fortran:
  453.                     subroutine color(col)
  454.                     integer col
  455.                C:
  456.  
  457.  
  458.  
  459. VOGLE 1.3.0         Last change: 15 Jun 1994                    7
  460.  
  461.  
  462.  
  463.  
  464.  
  465.  
  466. VOGLE(3)               C Library Functions               VOGLE(3)
  467.  
  468.  
  469.  
  470.                     color(col)
  471.                          int  col;
  472.  
  473.                Pascal:
  474.                     procedure Color
  475.  
  476.  
  477.      mapcolor(indx, red, green, blue)
  478.           Set the color map index indx to the  color  represented
  479.           by  (red, green, blue).  If the device has no color map
  480.           this call does nothing.
  481.  
  482.                Fortran:
  483.                     subroutine mapcolor(indx, red, green, blue)
  484.                     integer indx, red, green, blue
  485.                C:
  486.                     mapcolor(indx, red, green, blue)
  487.                          int  indx, red, green, blue;
  488.  
  489.                Pascal:
  490.                     procedure MapColor(indx, red, green, blue: integer)
  491.  
  492.  
  493.      clipping(onoff)
  494.           Turn clipping on or off.  Non-zero  is  considered  on.
  495.           Note: on some devices turning clipping off may not be a
  496.           good idea.
  497.  
  498.                Fortran:
  499.                     subroutine clipping(onoff)
  500.                     logical onoff
  501.                C:
  502.                     clipping(onoff)
  503.                          int  onoff;
  504.  
  505.                Pascal:
  506.                     procedure Clipping(onoff: boolean)
  507.  
  508.  
  509.      getkey()
  510.           Return the ascii ordinal of the next key typed  at  the
  511.           keyboard.  If the device has no keyboard getkey returns
  512.           -1.
  513.  
  514.                Fortran:
  515.                     integer function getkey
  516.                C:
  517.                     int
  518.                     getkey()
  519.  
  520.                Pascal:
  521.                     function GetKey(): integer;
  522.  
  523.  
  524.  
  525. VOGLE 1.3.0         Last change: 15 Jun 1994                    8
  526.  
  527.  
  528.  
  529.  
  530.  
  531.  
  532. VOGLE(3)               C Library Functions               VOGLE(3)
  533.  
  534.  
  535.  
  536.      checkkey()
  537.           Returns zero if no key is pressed or the ascii  ordinal
  538.           of the key that was pressed.
  539.  
  540.                Fortran:
  541.                     integer function checkkey()
  542.                C:
  543.                     int
  544.                     checkey()
  545.  
  546.                Pascal:
  547.                     function CheckKey(): integer;
  548.  
  549.  
  550.      getstring(bcol, string)
  551.           Read in a string, echoing it in the current font, using
  552.           the  current color and the current transformation. bcol
  553.           is the background color which is used for erasing char-
  554.           acters  after  a backspace or a delete key is received.
  555.           Getstring interprets the Backspace key  (ascii  8)  and
  556.           the  Del  key (ascii 127) as erasing characters. An EOT
  557.           (ascii 4) or a Carraige return  (ascii  13)  will  ter-
  558.           minate  input.  Getstring returns the number of charac-
  559.           ters read. Getstring does not check for overflow in the
  560.           input buffer string
  561.  
  562.                Fortran:
  563.                     integer function getstring(bcol, string)
  564.                     integer bcol
  565.                     character *(*) string
  566.                C:
  567.                     int
  568.                     getstring(bcol, string)
  569.                          int  bcol;
  570.                          char *string;
  571.  
  572.                Pascal:
  573.                     function GetString(bcol: integer; var string: string_t): integer;
  574.  
  575.  
  576.      locator(xaddr, yaddr)
  577.           Find out where the cursor is. xaddr and yaddr  are  set
  578.           to the current location in world coordinates. The func-
  579.           tion returns a bit pattern which indicates  which  but-
  580.           tons  are  being held down eg. if mouse buttons 1 and 3
  581.           are down locator returns binary 101  (decimal  7).  The
  582.           function  returns -1 if the device has no locator capa-
  583.           bility. Note: if you have  been  doing  a  lot  of  3-D
  584.           transformations  xaddr  and yaddr may not make a lot of
  585.           sense. In this case use slocator.
  586.  
  587.                Fortran:
  588.  
  589.  
  590.  
  591. VOGLE 1.3.0         Last change: 15 Jun 1994                    9
  592.  
  593.  
  594.  
  595.  
  596.  
  597.  
  598. VOGLE(3)               C Library Functions               VOGLE(3)
  599.  
  600.  
  601.  
  602.                     integer function locator(xaddr, yaddr)
  603.                     real xaddr, yaddr
  604.                C:
  605.                     int
  606.                     locator(xaddr, yaddr)
  607.                          float     *xaddr, *yaddr;
  608.  
  609.                Pascal:
  610.                     function Locator(var xaddr, yaddr: real): integer;
  611.  
  612.  
  613.      slocator(xaddr, yaddr)
  614.           Find out where the cursor is. xaddr and yaddr  are  set
  615.           to  the  current  location  in  screen coordinates. The
  616.           return value of the function is set up in the same  way
  617.           as  with  locator.  If the device has no locator device
  618.           slocator returns -1.
  619.  
  620.                Fortran:
  621.                     integer function slocator(xaddr, yaddr)
  622.                     real xaddr, yaddr
  623.                C:
  624.                     int
  625.                     slocator(xaddr, yaddr)
  626.                          float     *xaddr, *yaddr;
  627.  
  628.                Pascal:
  629.                     function Slocator(var xaddr, yaddr: real): integer;
  630.  
  631.  
  632.      On some devices (particularly X11) considerable speedups  in
  633.      display can be achieved by not flushing each graphics primi-
  634.      tive call to  the  actual  display  until  necessary.  VOGLE
  635.      automatically delays flushing under in following cases:
  636.  
  637.           - Within a callobj() call.
  638.           - Within curves and patches.
  639.           - Within Hershey software text.
  640.           - When double buffering (the flush is only done within swapbuffers).
  641.  
  642.      There are two user routines that  can  be  used  to  control
  643.      flushing.
  644.  
  645.      vsetflush(yesno)
  646.           Set global flushing status. If yesno = 0 (.false.) then
  647.           don't  do  any  flushing  (except  in swapbuffers(), or
  648.           vflush()). If yesno = 1 (.true.) then do  the  flushing
  649.           as described above.
  650.                Fortran:
  651.                     subroutine vsetflush(yesno)
  652.                     logical yesno
  653.  
  654.  
  655.  
  656.  
  657. VOGLE 1.3.0         Last change: 15 Jun 1994                   10
  658.  
  659.  
  660.  
  661.  
  662.  
  663.  
  664. VOGLE(3)               C Library Functions               VOGLE(3)
  665.  
  666.  
  667.  
  668.                C:
  669.                     void
  670.                     vsetflush(yesno)
  671.                          int  yesno;
  672.  
  673.                Pascal:
  674.                     procedure VsetFlush(yesno: boolean);
  675.  
  676.  
  677.      vflush()
  678.           Call the device flush or syncronisation  routine.  This
  679.           forces a flush.
  680.                Fortran:
  681.                     subroutine vflush
  682.  
  683.                C:
  684.                     void
  685.                     vflush();
  686.  
  687.                Pascal:
  688.                     procedure Vflush;
  689.  
  690.  
  691.   Viewport Routines.
  692.      viewport(left, right, bottom, top)
  693.           Specify which part of the  screen  to  draw  in.  Left,
  694.           right,  bottom, and top are real values in screen coor-
  695.           dinates (-1.0 to 1.0).
  696.  
  697.                Fortran:
  698.                     subroutine viewport(left, right, bottom, top)
  699.                     real left, right, bottom, top
  700.  
  701.                C:
  702.                     viewport(left, right, bottom, top)
  703.                          float      left, right, bottom, top;
  704.  
  705.                Pascal:
  706.                     procedure ViewPort(left, right, bottom, top: real);
  707.  
  708.  
  709.      pushviewport()
  710.           Save current viewport.
  711.  
  712.                Fortran:
  713.                     subroutine pushviewport
  714.  
  715.                C:
  716.                     pushviewport()
  717.  
  718.                Pascal:
  719.                     procedure PushViewPort;
  720.  
  721.  
  722.  
  723. VOGLE 1.3.0         Last change: 15 Jun 1994                   11
  724.  
  725.  
  726.  
  727.  
  728.  
  729.  
  730. VOGLE(3)               C Library Functions               VOGLE(3)
  731.  
  732.  
  733.  
  734.      popviewport()
  735.           Retrieve last viewport.
  736.  
  737.                Fortran:
  738.                     subroutine popviewport
  739.  
  740.                C:
  741.                     popviewport()
  742.  
  743.                Pascal:
  744.                     procedure PopViewPort;
  745.  
  746.  
  747.      getviewport(left, right, bottom, top)
  748.           Returns the left, right, bottom and top limits  of  the
  749.           current viewport in screen coordinates (-1.0 to 1.0).
  750.  
  751.                Fortran:
  752.                     subroutine getviewport(left, right, bottom, top)
  753.                     real left, right, bottom, top
  754.  
  755.                C:
  756.                     getviewport(left, right, bottom, top)
  757.                          float      *left, *right, *bottom, *top;
  758.  
  759.                Pascal:
  760.                     procedure GetViewPort(var left, right, bottom, top: real)
  761.  
  762.  
  763.   Getting the aspect details
  764.      Often the screen is not perfectly square  and  it  would  be
  765.      nice  to use the extra space without having to turn clipping
  766.      off. The following routines are provided to get  the  values
  767.      needed to adjust the calls to viewport, etc as needed.
  768.  
  769.      getaspect()
  770.           Returns the ratio height over width of the display dev-
  771.           ice.
  772.  
  773.                Fortran:
  774.                     real function getaspect()
  775.  
  776.                C:
  777.                     float
  778.                     getaspect()
  779.  
  780.                Pascal:
  781.                     function GetAspect(): real;
  782.  
  783.  
  784.      getfactors(wfact, hfact)
  785.           Returns wfact as the width over  min(width  of  device,
  786.  
  787.  
  788.  
  789. VOGLE 1.3.0         Last change: 15 Jun 1994                   12
  790.  
  791.  
  792.  
  793.  
  794.  
  795.  
  796. VOGLE(3)               C Library Functions               VOGLE(3)
  797.  
  798.  
  799.  
  800.           height   of  device)  and  hfact  as  the  height  over
  801.           min(width of device, height of device).
  802.  
  803.                Fortran:
  804.                     subroutine getfactors(w, h)
  805.                     real w, h
  806.  
  807.                C:
  808.                     getfactors(w, h)
  809.                          float     *w, *h;
  810.  
  811.                Pascal:
  812.                     procedure GetFactors(var w, h: real)
  813.  
  814.  
  815.      getdisplaysize(w, h)
  816.           Returns the width and height of the device in pixels in
  817.           w and h respectively.
  818.  
  819.                Fortran:
  820.                     subroutine getdisplaysize(w, h)
  821.                     real w, h
  822.  
  823.                C:
  824.                     getdisplaysize(w, h)
  825.                          float     *w, *h;
  826.  
  827.                Pascal:
  828.                     procedure GetDisplaySize(var w, h: real)
  829.  
  830.  
  831.      expandviewport()
  832.           When Vogle does viewport calculations, it will normally
  833.           begin  by  using the largest square it can fit onto the
  834.           actual display device. This call says to use the  whole
  835.           device...  however  you must then take into account any
  836.           distortion that will occur due to the non  square  map-
  837.           ping.  Thus,  a viewport of (-1.0, 1.0, -1.0, 1.0) will
  838.           map into the whole display device.
  839.  
  840.                Fortran:
  841.                     subroutine expandviewport
  842.  
  843.                C:
  844.                     expandviewport()
  845.  
  846.                Pascal:
  847.                     procedure ExpandViewport
  848.  
  849.  
  850.      unexpandviewport()
  851.           Does  the  reverse  of  expandviewport.  Basically,  it
  852.  
  853.  
  854.  
  855. VOGLE 1.3.0         Last change: 15 Jun 1994                   13
  856.  
  857.  
  858.  
  859.  
  860.  
  861.  
  862. VOGLE(3)               C Library Functions               VOGLE(3)
  863.  
  864.  
  865.  
  866.           returns vogle to using the largest square of the device
  867.           for it's viewport calculations.
  868.  
  869.                Fortran:
  870.                     subroutine unexpandviewport
  871.  
  872.                C:
  873.                     unexpandviewport()
  874.  
  875.                Pascal:
  876.                     procedure UnExpandViewport
  877.  
  878.  
  879.  
  880.  
  881.   Attribute Stack Routines.
  882.      The attribute stack contains the following details:
  883.      current color index
  884.      filling/hatching status
  885.      hatch pitch and angle
  886.      Linestyle and linestyle status
  887.      Doublebuffer status
  888.      Text rotation
  889.      Text size
  890.      Text justification
  891.      Text fixedwidth status
  892.      Text status (hardware or software)
  893.      Text font.
  894.      If you need to prevent object calls form changing these, use
  895.      pushattributes before the call and popattributes after.
  896.  
  897.      pushattributes()
  898.           Save the current attributes on the attribute stack.
  899.  
  900.                Fortran:
  901.                     subroutine pushattributes
  902.  
  903.                C:
  904.                     pushattributes()
  905.  
  906.                Pascal:
  907.                     procedure PushAttributes;
  908.  
  909.  
  910.      popattributes()
  911.           Restore the attributes to what they were  at  the  last
  912.           pushattribute().
  913.  
  914.                Fortran:
  915.                     subroutine popattributes
  916.  
  917.                C:
  918.  
  919.  
  920.  
  921. VOGLE 1.3.0         Last change: 15 Jun 1994                   14
  922.  
  923.  
  924.  
  925.  
  926.  
  927.  
  928. VOGLE(3)               C Library Functions               VOGLE(3)
  929.  
  930.  
  931.  
  932.                     popattributes()
  933.  
  934.                Pascal:
  935.                     procedure PopAttributes;
  936.  
  937.  
  938.   Projection Routines.
  939.      All the projection  routines  define  a  new  transformation
  940.      matrix,  and  consequently the world units. Parallel projec-
  941.      tions are defined by ortho or  ortho2.  Perspective  projec-
  942.      tions can be defined by perspective and window.
  943.  
  944.      ortho(left, right, bottom, top, near, far)
  945.           Define x (left, right), y (bottom, top), and  z  (near,
  946.           far)  clipping planes. The near and far clipping planes
  947.           are actually specified as distances along the  line  of
  948.           sight.  These  distances  can  also  be  negative.  The
  949.           actual location of the clipping planes is z  =  -near_d
  950.           and z = -far_d.
  951.  
  952.                Fortran:
  953.                     subroutine ortho(left, right, bottom, top, near_d, far_d)
  954.                     real left, right, bottom, top, near_d, far_d
  955.  
  956.                C:
  957.                     ortho(left, right, bottom, top, near_d, far_d)
  958.                          float     left, right, bottom, top, near_d, far_d;
  959.  
  960.                Pascal:
  961.                     procedure Ortho(left, right, bottom, top, near_d, far_d: real)
  962.  
  963.  
  964.      ortho2(left, right, bottom, top)
  965.           Define x (left, right), and y  (bottom,  top)  clipping
  966.           planes.
  967.  
  968.                Fortran:
  969.                     subroutine ortho2(left, right, bottom, top)
  970.                     real left, right, bottom, top
  971.  
  972.                C:
  973.                     ortho2(left, right, bottom, top)
  974.                          float     left, right, bottom, top;
  975.  
  976.                Pascal:
  977.                     procedure Ortho2(left, right, bottom, top: real)
  978.  
  979.  
  980.      perspective(fov, aspect, near, far)
  981.           Specify a perspective viewing pyramid in world  coordi-
  982.           nates  by  giving a field of view, aspect ratio and the
  983.           distance from the eye of  the  near  and  far  clipping
  984.  
  985.  
  986.  
  987. VOGLE 1.3.0         Last change: 15 Jun 1994                   15
  988.  
  989.  
  990.  
  991.  
  992.  
  993.  
  994. VOGLE(3)               C Library Functions               VOGLE(3)
  995.  
  996.  
  997.  
  998.           plane.
  999.  
  1000.           The fov, specifies the field of view in  the  y  direc-
  1001.           tion. It is the range of the area that is being viewed.
  1002.           The aspect ratio is the ratio x/y (width/height)  which
  1003.           determines the fov in the x direction.
  1004.  
  1005.  
  1006.                Fortran:
  1007.                     subroutine perspective(fov, aspect, near, far)
  1008.                     real fov, aspect, near, far
  1009.  
  1010.                C:
  1011.                     perspective(fov, aspect, near, far)
  1012.                          float     fov, aspect, near, far;
  1013.  
  1014.                Pascal:
  1015.                     procedure Perspective(fov, aspect, near, far: real)
  1016.  
  1017.      window(left, right, bot, top, near, far)
  1018.           Specify a perspective viewing pyramid in world coordinates by
  1019.           give the rectangle closest to the eye (ie. at the near clipping
  1020.           plane) and the distances to the near and far clipping planes.
  1021.  
  1022.                Fortran:
  1023.                     subroutine window(left, right, bot, top, near, far)
  1024.                     real left, right, bot, top, near, far
  1025.  
  1026.                C:
  1027.                     window(left, right, bot, top, near, far)
  1028.                          float     left, right, bot, top, near, far;
  1029.  
  1030.  
  1031.                Pascal:
  1032.                     procedure Window(left, right, bot, top, near, far: real)
  1033.  
  1034.  
  1035.   Matrix Stack Routines.
  1036.      pushmatrix()
  1037.           Save the current transformation matrix  on  the  matrix
  1038.           stack.
  1039.  
  1040.                Fortran:
  1041.                     subroutine pushmatrix
  1042.  
  1043.                C:
  1044.                     pushmatrix()
  1045.  
  1046.                Pascal:
  1047.                     procedure PushMatrix
  1048.  
  1049.  
  1050.  
  1051.  
  1052.  
  1053. VOGLE 1.3.0         Last change: 15 Jun 1994                   16
  1054.  
  1055.  
  1056.  
  1057.  
  1058.  
  1059.  
  1060. VOGLE(3)               C Library Functions               VOGLE(3)
  1061.  
  1062.  
  1063.  
  1064.      popmatrix()
  1065.           Retrieve the last matrix pushed and make it the current
  1066.           transformation matrix.
  1067.  
  1068.                Fortran:
  1069.                     subroutine popmatrix
  1070.  
  1071.                C:
  1072.                     popmatrix()
  1073.  
  1074.                Pascal:
  1075.                     procedure PopMatrix
  1076.  
  1077.  
  1078.   Viewpoint Routines.
  1079.      Viewpoint routines alter the current tranformation matrix.
  1080.  
  1081.      polarview(dist, azim, inc, twist)
  1082.           Specify the viewer's position in polar  coordinates  by
  1083.           giving  the  distance  from  the viewpoint to the world
  1084.           origin, the azimuthal angle in the x-y plane,  measured
  1085.           from  the y-axis, the incidence angle in the y-z plane,
  1086.           measured from the z-axis, and the twist angle about the
  1087.           line of sight.
  1088.  
  1089.                Fortran:
  1090.                     subroutine polarview(dist, azim, inc, twist)
  1091.                     real dist, azim, inc, twist
  1092.  
  1093.                C:
  1094.                     polarview(dist, azim, inc, twist)
  1095.                          float     dist, azim, inc, twist;
  1096.  
  1097.                Pascal:
  1098.                     procedure PolarView(dist, azim, inc, twist: real)
  1099.  
  1100.  
  1101.      up(x, y, z)
  1102.           Specify the world up.  This  can  be  used  to  prevent
  1103.           lookat's sometimes annoying habit of turning everything
  1104.           upside down due to  the  line  of  sight  crossing  the
  1105.           appropriate axis.
  1106.  
  1107.                Fortran:
  1108.                     subroutine up(x, y, z)
  1109.                     real x, y, z
  1110.  
  1111.                C:
  1112.                     up(x, y, z)
  1113.                          float     x, y, z;
  1114.  
  1115.                Pascal:
  1116.  
  1117.  
  1118.  
  1119. VOGLE 1.3.0         Last change: 15 Jun 1994                   17
  1120.  
  1121.  
  1122.  
  1123.  
  1124.  
  1125.  
  1126. VOGLE(3)               C Library Functions               VOGLE(3)
  1127.  
  1128.  
  1129.  
  1130.                     procedure Up(x, y, z: real)
  1131.  
  1132.  
  1133.      lookat(vx, vy, vz, px, py, pz, twist)
  1134.           Specify the viewer's position by giving a viewpoint and
  1135.           a  reference  point in world coordinates. A twist about
  1136.           the line of sight may also be given.
  1137.  
  1138.           The viewpoint is at (vx, vy,  vz).  The  reference  (or
  1139.           viewed)  point  is at (px, py, pz). ie the line of site
  1140.           is from v to p. The  twist  parameter  is  a  righthand
  1141.           rotation about the line of site.
  1142.  
  1143.  
  1144.                Fortran:
  1145.                     subroutine lookat(vx, vy, vz, px, py, pz, twist)
  1146.                     real vx, vy, vz, px, py, pz, twist
  1147.  
  1148.                C:
  1149.                     lookat(vx, vy, vz, px, py, pz, twist)
  1150.                          float     vx, vy, vz, px, py, pz, twist;
  1151.  
  1152.                Pascal:
  1153.                     procedure LookAt(vx, vy, vz, px, py, pz, twist: real)
  1154.  
  1155.  
  1156.   Move Routines.
  1157.      move(x, y, z)
  1158.           Move current graphics position to (x, y, z). (x, y,  z)
  1159.           is a point in world coordinates.
  1160.  
  1161.                Fortran:
  1162.                     subroutine move(x, y, z)
  1163.                     real x, y, z
  1164.  
  1165.                C:
  1166.                     move(x, y, z)
  1167.                          float     x, y, z;
  1168.  
  1169.                Pascal:
  1170.                     procedure Move(x, y, z: real)
  1171.  
  1172.  
  1173.      rmove(deltax, deltay, deltaz)
  1174.           Relative move. deltax, deltay, and deltaz  are  offsets
  1175.           in world units.
  1176.  
  1177.                Fortran:
  1178.                     subroutine rmove(deltax, deltay, deltaz)
  1179.                     real deltax, deltay, deltaz
  1180.  
  1181.                C:
  1182.  
  1183.  
  1184.  
  1185. VOGLE 1.3.0         Last change: 15 Jun 1994                   18
  1186.  
  1187.  
  1188.  
  1189.  
  1190.  
  1191.  
  1192. VOGLE(3)               C Library Functions               VOGLE(3)
  1193.  
  1194.  
  1195.  
  1196.                     rmove(deltax,deltay)
  1197.                          float   deltax, deltay, deltaz;
  1198.  
  1199.                Pascal:
  1200.                     procedure Rmove(deltax, deltay, deltaz: real)
  1201.  
  1202.  
  1203.      move2(x, y)
  1204.           Move graphics position to point (x, y).  (x,  y)  is  a
  1205.           point in world coordinates.
  1206.  
  1207.                Fortran:
  1208.                     subroutine move2(x, y)
  1209.                     real x, y
  1210.  
  1211.                C:
  1212.                     move2(x, y)
  1213.                          float     x, y;
  1214.  
  1215.                Pascal:
  1216.                     procedure Move2(x, y: real)
  1217.  
  1218.  
  1219.      rmove2(deltax, deltay)
  1220.           Relative move2. deltax and deltay are offsets in  world
  1221.           units.
  1222.  
  1223.                Fortran:
  1224.                     subroutine rmove2(deltax, deltay)
  1225.                     real deltax, deltay
  1226.  
  1227.                C:
  1228.                     rmove2(deltax, deltay)
  1229.                          float     deltax, deltay;
  1230.  
  1231.                Pascal:
  1232.                     procedure Rmove2(deltax, deltay: real)
  1233.  
  1234.  
  1235.      smove2(x, y)
  1236.           Move current graphics position  in  screen  coordinates
  1237.           (-1.0 to 1.0).
  1238.  
  1239.                Fortran:
  1240.                     subroutine smove2(x, y)
  1241.                     real x, y
  1242.  
  1243.                C:
  1244.                     smove2(x, y)
  1245.                          float     x, y;
  1246.  
  1247.                Pascal:
  1248.  
  1249.  
  1250.  
  1251. VOGLE 1.3.0         Last change: 15 Jun 1994                   19
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257.  
  1258. VOGLE(3)               C Library Functions               VOGLE(3)
  1259.  
  1260.  
  1261.  
  1262.                     procedure Smove2(x, y: real)
  1263.  
  1264.  
  1265.      rsmove2(deltax, deltay)
  1266.           Relative smove2. deltax,  and  deltay  are  offsets  in
  1267.           screen units (-1.0 to 1.0).
  1268.  
  1269.                Fortran:
  1270.                     subroutine rsmove2(deltax, deltay)
  1271.                     real deltax, deltay
  1272.  
  1273.                C:
  1274.                     rsmove2(deltax, deltay)
  1275.                          float     deltax, deltay;
  1276.  
  1277.                Pascal:
  1278.                     procedure Rsmove2(deltax, deltay: real)
  1279.  
  1280.  
  1281.   Linestyles.
  1282.      Linestyles are specified by giving a  nominal  length  of  a
  1283.      single dash and a character string consisting of 1's and 0's
  1284.      (zeros) that specify when to draw a dash  and  when  not  to
  1285.      draw  a  dash. Linestyles will follow curves and "go around"
  1286.      corners. If a linestyle is set  or  reset,  the  accumulated
  1287.      information as to where on a curve (or line) a dash is to be
  1288.      draw is also reset.
  1289.  
  1290.      For example, with a nominal view of -1  to  1,  setting  the
  1291.      dash  length to 0.5, and the linestyle to '11010' would draw
  1292.      a line(or curve) with a 1.0 unit solid part, followed  by  a
  1293.      0.5  unit  blank part followed by a 0.5 unit solid part fol-
  1294.      lowed by a 0.5 unit blank part.  The  linestyle  would  then
  1295.      repeat itself.
  1296.  
  1297.      The   dash   sizes   are    affected    by    the    current
  1298.      viewport/transformation  scaling  factors,  meaning  that in
  1299.      perspective, the dashes look smaller the farther  away  they
  1300.      are.
  1301.  
  1302.      setdash(dashlen)
  1303.           Set the current dash length  (in  world  units)  to  be
  1304.           dashlen.
  1305.  
  1306.                Fortran:
  1307.                     subroutine setdash(dashlen)
  1308.                     real dashlen
  1309.  
  1310.                C:
  1311.                     setdash(dashlen)
  1312.                          float     dashlen;
  1313.  
  1314.  
  1315.  
  1316.  
  1317. VOGLE 1.3.0         Last change: 15 Jun 1994                   20
  1318.  
  1319.  
  1320.  
  1321.  
  1322.  
  1323.  
  1324. VOGLE(3)               C Library Functions               VOGLE(3)
  1325.  
  1326.  
  1327.  
  1328.                Pascal:
  1329.                     procedure SetDash(dashlen: real)
  1330.  
  1331.  
  1332.      linestyle(style)
  1333.           Set the current linestyle to style.
  1334.  
  1335.                Fortran:
  1336.                     subroutine linestyle(style)
  1337.                     character *(*) style
  1338.  
  1339.                C:
  1340.                     linesyle(style)
  1341.                          char *style;
  1342.  
  1343.                Pascal:
  1344.                     procedure LineStyle(style: string_t)
  1345.  
  1346.  
  1347.  
  1348.   Drawing Routines.
  1349.      draw(x, y, z)
  1350.           Draw from current graphics position to (x, y,  z).  (x,
  1351.           y, z) is a point in world coordinates.
  1352.  
  1353.                Fortran:
  1354.                     subroutine draw(x, y, z)
  1355.                     real x, y, z
  1356.  
  1357.                C:
  1358.                     draw(x, y, z)
  1359.                          float     x, y, z;
  1360.  
  1361.                Pascal:
  1362.                     procedure Draw(x, y, z: real)
  1363.  
  1364.  
  1365.      rdraw(deltax, deltay, deltaz)
  1366.           Relative draw. deltax, deltay, and deltaz  are  offsets
  1367.           in world units.
  1368.  
  1369.                Fortran:
  1370.                     subroutine rdraw(deltax, deltay, deltaz)
  1371.                     real deltax, deltay, deltaz
  1372.  
  1373.                C:
  1374.                     rdraw(deltax, deltay, deltaz)
  1375.                          float   deltax, deltay, deltaz;
  1376.  
  1377.                Pascal:
  1378.                     procedure Rdraw(deltax, deltay, deltaz: real)
  1379.  
  1380.  
  1381.  
  1382.  
  1383. VOGLE 1.3.0         Last change: 15 Jun 1994                   21
  1384.  
  1385.  
  1386.  
  1387.  
  1388.  
  1389.  
  1390. VOGLE(3)               C Library Functions               VOGLE(3)
  1391.  
  1392.  
  1393.  
  1394.      draw2(x, y)
  1395.           Draw from current graphics position to  point  (x,  y).
  1396.           (x, y) is a point in world coordinates.
  1397.  
  1398.                Fortran:
  1399.                     subroutine draw2(x, y)
  1400.                     real x, y
  1401.  
  1402.                C:
  1403.                     draw2(x, y)
  1404.                          float     x, y;
  1405.  
  1406.                Pascal:
  1407.                     procedure Draw2(x, y: real)
  1408.  
  1409.  
  1410.      rdraw2(deltax,deltay)
  1411.           Relative draw2. deltax and deltay are offsets in  world
  1412.           units.
  1413.  
  1414.                Fortran:
  1415.                     subroutine rdraw2(deltax, deltay)
  1416.                     real deltax, deltay
  1417.  
  1418.                C:
  1419.                     rdraw2(deltax, deltay)
  1420.                          float   deltax, deltay;
  1421.  
  1422.                Pascal:
  1423.                     procedure Rdraw2(deltax, deltay: real)
  1424.  
  1425.  
  1426.      sdraw2(x, y)
  1427.           Draw in screen coordinates (-1.0 to 1.0).
  1428.  
  1429.                Fortran:
  1430.                     subroutine sdraw2(x, y)
  1431.                     real x, y
  1432.  
  1433.                C:
  1434.                     sdraw2(x, y)
  1435.                          float     x, y;
  1436.  
  1437.                Pascal:
  1438.                     procedure Sdraw2(x, y: real)
  1439.  
  1440.  
  1441.      rsdraw2(deltax, deltay)
  1442.           Relative sdraw2. delatx and deltay are in screen  units
  1443.           (-1.0 to 1.0).
  1444.  
  1445.                Fortran:
  1446.  
  1447.  
  1448.  
  1449. VOGLE 1.3.0         Last change: 15 Jun 1994                   22
  1450.  
  1451.  
  1452.  
  1453.  
  1454.  
  1455.  
  1456. VOGLE(3)               C Library Functions               VOGLE(3)
  1457.  
  1458.  
  1459.  
  1460.                     subroutine rsdraw2(deltax, deltay)
  1461.                     real deltax, deltay
  1462.                C:
  1463.                     rsdraw2(deltax, deltay)
  1464.                          float     deltax, deltay;
  1465.  
  1466.                Pascal:
  1467.                     procedure Rsdraw2(deltax, deltay: real)
  1468.  
  1469.  
  1470.   Arcs and Circles.
  1471.      circleprecision(nsegs)
  1472.           Set the number of line segments  making  up  a  circle.
  1473.           Default  is  currently 32. The number of segments in an
  1474.           arc or sector is calculated from  nsegs  according  the
  1475.           span  of  the arc or sector.  This replaces the routine
  1476.           arcprecision.
  1477.                Fortran:
  1478.                     subroutine circleprecision(nsegs)
  1479.                     integer   nsegs
  1480.                C:
  1481.                     circleprecision(nsegs)
  1482.                          int  nsegs;
  1483.  
  1484.                Pascal:
  1485.                     procedure CirclePrecision(nsegs: integer)
  1486.  
  1487.  
  1488.      arc(x, y, radius, startang, endang)
  1489.           Draw an arc. x, y,  and  radius  are  values  in  world
  1490.           units.
  1491.  
  1492.                Fortran:
  1493.                     subroutine arc(x, y, radius, startang, endang)
  1494.                     real x, y, radius;
  1495.                     real startang, endang;
  1496.                C:
  1497.                     arc(x, y, radius, startang, endang)
  1498.                          float  x, y, radius;
  1499.                          float  startang, endang;
  1500.  
  1501.                Pascal:
  1502.                     procedure Arc(x, y, radius, startang, endang: real)
  1503.  
  1504.  
  1505.      sector(x, y, radius, startang, endang)
  1506.           Draw a sector. x, y, and radius  are  values  in  world
  1507.           units.  Note:  sectors  are regarded as polygons, so if
  1508.           polyfill or polyhatch has been called with 1, the  sec-
  1509.           tors will be filled or hatched accordingly.
  1510.  
  1511.                Fortran:
  1512.  
  1513.  
  1514.  
  1515. VOGLE 1.3.0         Last change: 15 Jun 1994                   23
  1516.  
  1517.  
  1518.  
  1519.  
  1520.  
  1521.  
  1522. VOGLE(3)               C Library Functions               VOGLE(3)
  1523.  
  1524.  
  1525.  
  1526.                     subroutine sector(x, y, radius, startang, endang)
  1527.                     real x, y, radius;
  1528.                     real startang, endang;
  1529.                C:
  1530.                     sector(x, y, radius, startang, endang)
  1531.                          float  x, y, radius;
  1532.                          float  startang, endang;
  1533.  
  1534.                Pascal:
  1535.                     procedure Sector(x, y, radius, startang, endang: real)
  1536.  
  1537.  
  1538.      circle(x, y, radius)
  1539.           Draw a circle. x, y, and radius  are  values  in  world
  1540.           units.  Note:  circles  are regarded as polygons, so if
  1541.           polyfill or polyhatch has been called with 1, the  cir-
  1542.           cle will be filled or hatched accordingly.
  1543.                x and y real coordinates in user units.
  1544.  
  1545.                Fortran:
  1546.                     subroutine circle(x, y, radius)
  1547.                     real x, y, radius
  1548.                C:
  1549.                     circle(x, y, radius)
  1550.                          float     x, y, radius;
  1551.  
  1552.                Pascal:
  1553.                     procedure Circle(x, y, radius: real)
  1554.  
  1555.  
  1556.   Curve Routines.
  1557.      curvebasis(basis)
  1558.           Define a basis matrix for a curve.
  1559.  
  1560.                Fortran:
  1561.                     subroutine curvebasis(basis)
  1562.                     real basis(4,4)
  1563.                C:
  1564.                     curvebasis(basis)
  1565.                          float     basis[4][4];
  1566.  
  1567.                Pascal:
  1568.                     procedure CurveBasis(basis: Matrix44_t)
  1569.  
  1570.  
  1571.      curveprecision(nsegs)
  1572.           Define the number of  line  segments  used  to  draw  a
  1573.           curve.
  1574.  
  1575.                Fortran:
  1576.                     subroutine curveprecision(nsegs)
  1577.                     integer nsegs
  1578.  
  1579.  
  1580.  
  1581. VOGLE 1.3.0         Last change: 15 Jun 1994                   24
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587.  
  1588. VOGLE(3)               C Library Functions               VOGLE(3)
  1589.  
  1590.  
  1591.  
  1592.                C:
  1593.                     curveprecision(nsegs)
  1594.                          int  nsegs;
  1595.  
  1596.                Pascal:
  1597.                     procedure CurvePrecision(nsegs: integer)
  1598.  
  1599.  
  1600.      rcurve(geom)
  1601.           Draw a rational curve.
  1602.  
  1603.                Fortran:
  1604.                     subroutine rcurve(geom)
  1605.                     real geom(4,4)
  1606.                C:
  1607.                     rcurve(geom)
  1608.                          float     geom[4][4];
  1609.  
  1610.                Pascal:
  1611.                     procedure Rcurve(geom: Matrix44_t)
  1612.  
  1613.  
  1614.      curve(geom)
  1615.           Draw a curve.
  1616.  
  1617.                Fortran:
  1618.                     subroutine curve(geom)
  1619.                     real geom(3,4)
  1620.                C:
  1621.                     curve(geom)
  1622.                          float     geom[4][3];
  1623.  
  1624.                Pascal:
  1625.                     procedure Curve(geom: Matrix43_t)
  1626.  
  1627.  
  1628.      curven(n, geom)
  1629.           Draw n - 3 overlapping curve segments. Note: n must  be
  1630.           at least 4.
  1631.  
  1632.                Fortran:
  1633.                     subroutine curven(n, geom)
  1634.                     integer n
  1635.                     real geom(3,n)
  1636.                C:
  1637.                     curven(n, geom)
  1638.                          int  n;
  1639.                          float     geom[][3];
  1640.  
  1641.                Pascal:
  1642.                     procedure Curven(n: integer; geom: GeomMat_t)
  1643.  
  1644.  
  1645.  
  1646.  
  1647. VOGLE 1.3.0         Last change: 15 Jun 1994                   25
  1648.  
  1649.  
  1650.  
  1651.  
  1652.  
  1653.  
  1654. VOGLE(3)               C Library Functions               VOGLE(3)
  1655.  
  1656.  
  1657.  
  1658.   Rectangles and General Polygon Routines.
  1659.      rect(x1, y1, x2, y2)
  1660.           Draw a rectangle.
  1661.  
  1662.                Fortran:
  1663.                     subroutine rect(x1, y1, x2, y2)
  1664.                     real x1, y1, x1, y2
  1665.                C:
  1666.                     rect(x1, y1, x2, y2)
  1667.                          float     x1, y1, x2, y2;
  1668.  
  1669.                Pascal:
  1670.                     procedure Rect(x1, y1, x2, y2: real)
  1671.  
  1672.  
  1673.      polyfill(onoff)
  1674.           Set the polygon fill flag. This will  always  turn  off
  1675.           hatching. A non-zero
  1676.            (.true. ) turns polyfill on.
  1677.  
  1678.                Fortran:
  1679.                     subroutine polyfill(onoff)
  1680.                     logical onoff
  1681.                C:
  1682.                     polyfill(onoff)
  1683.                          int  onoff;
  1684.  
  1685.                Pascal:
  1686.                     procedure PolyFill(onoff: boolean)
  1687.  
  1688.  
  1689.      polyhatch(onoff)
  1690.           Set the polygon hatch flag. This will always  turn  off
  1691.           fill. A non-zero
  1692.            (.true.)  turns  polyhatch  on.  Note   that   hatched
  1693.           polygons must initially be defined parrallel to the X-Y
  1694.           plane.
  1695.  
  1696.                Fortran:
  1697.                     subroutine polyhatch(onoff)
  1698.                     logical   onoff
  1699.                C:
  1700.                     polyhatch(onoff)
  1701.                          int  onoff;
  1702.  
  1703.                Pascal:
  1704.                     procedure PolyHatch(onoff: boolean)
  1705.  
  1706.  
  1707.      hatchang(angle)
  1708.           Set the angle of the hatch lines.
  1709.  
  1710.  
  1711.  
  1712.  
  1713. VOGLE 1.3.0         Last change: 15 Jun 1994                   26
  1714.  
  1715.  
  1716.  
  1717.  
  1718.  
  1719.  
  1720. VOGLE(3)               C Library Functions               VOGLE(3)
  1721.  
  1722.  
  1723.  
  1724.                Fortran:
  1725.                     subroutine hatchang(angle)
  1726.                     real angle
  1727.                C:
  1728.                     hatchang(angle)
  1729.                          float     angle;
  1730.  
  1731.                Pascal:
  1732.                     procedure HatchAng(angle: real)
  1733.  
  1734.  
  1735.      hatchpitch(pitch)
  1736.           Set the distance between hatch lines.
  1737.  
  1738.                Fortran:
  1739.                     subroutine hatchpitch(pitch)
  1740.                     real pitch
  1741.                C:
  1742.                     hatchpitch(pitch)
  1743.                          float     pitch;
  1744.  
  1745.                Pascal:
  1746.                     procedure HatchPitch(pitch: real)
  1747.  
  1748.  
  1749.      poly2(n, points)
  1750.           Construct an (x, y) polygon from  an  array  of  points
  1751.           provided by the user.
  1752.  
  1753.                Fortran:
  1754.                     subroutine poly2(n, points)
  1755.                     integer   n
  1756.                     real points(2, n)
  1757.                C:
  1758.                     poly2(n,  points)
  1759.                          int  n;
  1760.                          float     points[][2];
  1761.  
  1762.                Pascal:
  1763.                     procedure Poly2(n: integer; points: Poly2_array_t)
  1764.  
  1765.  
  1766.      poly(n, points)
  1767.           Construct a polygon from an array of points provided by
  1768.           the user.
  1769.  
  1770.                Fortran:
  1771.                     subroutine poly(n, points)
  1772.                     integer   n
  1773.                     real points(3, n)
  1774.                C:
  1775.                     poly(n,  points)
  1776.  
  1777.  
  1778.  
  1779. VOGLE 1.3.0         Last change: 15 Jun 1994                   27
  1780.  
  1781.  
  1782.  
  1783.  
  1784.  
  1785.  
  1786. VOGLE(3)               C Library Functions               VOGLE(3)
  1787.  
  1788.  
  1789.  
  1790.                          int  n;
  1791.                          float     points[][3];
  1792.  
  1793.                Pascal:
  1794.                     procedure Poly(n: integer; points: Poly3_array_t)
  1795.  
  1796.  
  1797.      makepoly()
  1798.           makepoly opens up a polygon which  will  then  be  con-
  1799.           structed  by  a  series  of  move-draws and closed by a
  1800.           closepoly.
  1801.  
  1802.                Fortran:
  1803.                     subroutine makepoly
  1804.                C:
  1805.                     makepoly()
  1806.  
  1807.                Pascal:
  1808.                     procedure MakePoly
  1809.  
  1810.  
  1811.      closepoly()
  1812.           Terminates a polygon opened by makepoly.
  1813.  
  1814.                Fortran:
  1815.                     subroutine closepoly
  1816.                C:
  1817.                     closepoly()
  1818.  
  1819.                Pascal:
  1820.                     procedure ClosePoly
  1821.  
  1822.  
  1823.      backface(onoff)
  1824.           Turns on culling of backfacing polygons. A  polygon  is
  1825.           backfacing  if  it's  orientation in *screen* coords is
  1826.           clockwise, unless a call to backfacedir is made.
  1827.  
  1828.                Fortran:
  1829.                     subroutine backface(onoff)
  1830.                     integer onoff
  1831.  
  1832.                C:
  1833.                     backface(onoff)
  1834.                          int  onoff;
  1835.  
  1836.                Pascal:
  1837.                     procedure BackFace(onoff: boolean)
  1838.  
  1839.  
  1840.      backfacedir(clockwise)
  1841.           Sets  the  backfacing   direction   to   clockwise   or
  1842.  
  1843.  
  1844.  
  1845. VOGLE 1.3.0         Last change: 15 Jun 1994                   28
  1846.  
  1847.  
  1848.  
  1849.  
  1850.  
  1851.  
  1852. VOGLE(3)               C Library Functions               VOGLE(3)
  1853.  
  1854.  
  1855.  
  1856.           anticlockwise depending on whether clockwise is 1 or 0.
  1857.  
  1858.                Fortran:
  1859.                     subroutine backfacedir(clockwise)
  1860.                     integer clockwise
  1861.  
  1862.                C:
  1863.                     backfacedir(clockwise)
  1864.                          int  clockwise;
  1865.  
  1866.                Pascal:
  1867.                     procedure BackFaceDir(clockwise: boolean)
  1868.  
  1869.  
  1870.   Text Routines.
  1871.      VOGLE supports hardware and  software  fonts.  The  software
  1872.      fonts  are  based on the character set digitized by Dr Allen
  1873.      V. Hershey while working at the U.  S.  National  Bureau  of
  1874.      Standards. Exactly what hardware fonts are supported depends
  1875.      on the device, but it is guaranteed that the  names  "large"
  1876.      and  "small"  will  result  in  something  readable. For X11
  1877.      displays the default large and small fonts used by the  pro-
  1878.      gram  can be overridden by placing the following defaults in
  1879.      the ~/.Xdefaults file:
  1880.              vogle.smallfont: <font name>
  1881.              vogle.largefont: <font name>
  1882.  
  1883.  
  1884.      It is noted here that text is always  assumed  to  be  drawn
  1885.      parallel  to  the (x, y) plane, using whatever the current z
  1886.      coordinate is. The following software fonts are supported:
  1887.           astrology       cursive         cyrillic        futura.l
  1888.           futura.m        gothic.eng      gothic.ger      gothic.ita
  1889.           greek           markers         math.low        math.upp
  1890.           meteorology     music           script          symbolic
  1891.           times.g         times.i         times.ib        times.r
  1892.           times.rb        japanese
  1893.  
  1894.      A markers font "markers" is also provided for doing  markers
  1895.      -  you  need to have centertext on for this to give sensible
  1896.      results - with the markers starting at 'A' and 'a'.
  1897.  
  1898.      If the environment variable "VFONTLIB" is  set  VOGLE  looks
  1899.      for the software fonts in the directory given by this value.
  1900.  
  1901.      font(fontname)
  1902.           Set the current font
  1903.  
  1904.                Fortran:
  1905.                     subroutine font(fontname)
  1906.                     character*(*) fontname
  1907.                C:
  1908.  
  1909.  
  1910.  
  1911. VOGLE 1.3.0         Last change: 15 Jun 1994                   29
  1912.  
  1913.  
  1914.  
  1915.  
  1916.  
  1917.  
  1918. VOGLE(3)               C Library Functions               VOGLE(3)
  1919.  
  1920.  
  1921.  
  1922.                     font(fontname)
  1923.                          char *fontname
  1924.  
  1925.                Pascal:
  1926.                     procedure Font(fontname: string_t)
  1927.  
  1928.  
  1929.      numchars()
  1930.           Return the number of characters in  the  current  font.
  1931.           Applicable only to software fonts.
  1932.  
  1933.                Fortran:
  1934.                     integer function numchars
  1935.                C:
  1936.                     int
  1937.                     numchars()
  1938.  
  1939.                Pascal:
  1940.                     function NumChars: integer;
  1941.  
  1942.  
  1943.      textsize(width, height)
  1944.           Set the maximum size of  a  character  in  the  current
  1945.           font.  Width and height are values in world units. This
  1946.           only applies to software text. This must be done  after
  1947.           the font being scaled is loaded.
  1948.  
  1949.                Fortran:
  1950.                     subroutine textsize(width, height)
  1951.                     real width, height
  1952.                C:
  1953.                     textsize(width, height)
  1954.                          float     width, height;
  1955.  
  1956.                Pascal:
  1957.                     procedure TextSize(width, height: real)
  1958.  
  1959.  
  1960.      textang(ang)
  1961.           Set the text angle. This angles strings and chars. This
  1962.           routine only affects software text.
  1963.  
  1964.                Fortran:
  1965.                     subroutine textang(ang)
  1966.                     real ang
  1967.                C:
  1968.                     textang(ang)
  1969.                          float     ang;
  1970.  
  1971.                Pascal:
  1972.                     procedure TexTang(ang: real)
  1973.  
  1974.  
  1975.  
  1976.  
  1977. VOGLE 1.3.0         Last change: 15 Jun 1994                   30
  1978.  
  1979.  
  1980.  
  1981.  
  1982.  
  1983.  
  1984. VOGLE(3)               C Library Functions               VOGLE(3)
  1985.  
  1986.  
  1987.  
  1988.      fixedwidth(onoff)
  1989.           Turns fixedwidth text on or off. Non-zero  (.true.)  is
  1990.           on. Causes all text to be printed fixedwidth. This rou-
  1991.           tine only affects software text.
  1992.  
  1993.                Fortran:
  1994.                     subroutine fixedwidth(onoff)
  1995.                     logical onoff
  1996.                C:
  1997.                     fixedwidth(onoff)
  1998.                          int onoff;
  1999.  
  2000.                Pascal:
  2001.                     procedure FixedWidth(onoff: boolean)
  2002.  
  2003.  
  2004.      centertext(onoff)
  2005.           Turns centertext text on or off. Non-zero  (.true.)  is
  2006.           on.  This  centres strings and chars. This routine only
  2007.           affects  software  text.  All  other  justification  is
  2008.           turned  off.  The  text is centered in both the x and y
  2009.           directions.
  2010.  
  2011.                Fortran:
  2012.                     subroutine centertext(onoff)
  2013.                     logical onoff
  2014.  
  2015.                C:
  2016.                     centertext(onoff)
  2017.                          int onoff;
  2018.  
  2019.                Pascal:
  2020.                     procedure CenterText(onoff: boolean)
  2021.  
  2022.  
  2023.      textjustify(val)
  2024.           General (direct) control  of  text  justification.  The
  2025.           value  of  val is made up of the logical OR of the fol-
  2026.           lowing predefines constants in vogle.h  (FOR  C  only).
  2027.           LEFT, RIGHT, XCENTERED, TOP, BOTTOM, YCENTERED. Center-
  2028.           ing takes priority, as does RIGHT and TOP justification
  2029.           (if  you  were silly enough to set it to LEFT|RIGHT for
  2030.           example  that  is).  A  value  of  0  (zero)  (in   all
  2031.           languages) resets the textjustification to the default.
  2032.  
  2033.                Fortran:
  2034.                     subroutine textjustify(val)
  2035.                     integer val
  2036.  
  2037.                C:
  2038.                     textjustify(val)
  2039.                          unsigned val;
  2040.  
  2041.  
  2042.  
  2043. VOGLE 1.3.0         Last change: 15 Jun 1994                   31
  2044.  
  2045.  
  2046.  
  2047.  
  2048.  
  2049.  
  2050. VOGLE(3)               C Library Functions               VOGLE(3)
  2051.  
  2052.  
  2053.  
  2054.                Pascal:
  2055.                     procedure CenterText(val: integer)
  2056.  
  2057.  
  2058.      leftjustify()
  2059.           Left justifies text. The text string will begin at  the
  2060.           current  position  and  extend  to  the notional right.
  2061.           Right justifcation and X centering are turned off.
  2062.  
  2063.                Fortran:
  2064.                     subroutine leftjustify
  2065.  
  2066.                C:
  2067.                     leftjustify()
  2068.  
  2069.                Pascal:
  2070.                     procedure LeftJustify
  2071.  
  2072.  
  2073.      rightjustify()
  2074.           Right justifies text. The text string will begin  at  a
  2075.           point  to the notional left of the current position and
  2076.           finish at the current position. Left justification  and
  2077.           X centering are turned off.
  2078.  
  2079.                Fortran:
  2080.                     subroutine rightjustify
  2081.  
  2082.                C:
  2083.                     rightjustify()
  2084.  
  2085.                Pascal:
  2086.                     procedure RightJustify
  2087.  
  2088.  
  2089.      xcentertext()
  2090.           Centers text in the X direction. The text  string  will
  2091.           begin  at  a  point to the notional left of the current
  2092.           position and finish at a point  to  the  right  of  the
  2093.           current position. Left justification and Right justifi-
  2094.           cation are turned off.
  2095.  
  2096.                Fortran:
  2097.                     subroutine xcentertext
  2098.  
  2099.                C:
  2100.                     xcentertext()
  2101.  
  2102.                Pascal:
  2103.                     procedure XcenterText
  2104.  
  2105.  
  2106.  
  2107.  
  2108.  
  2109. VOGLE 1.3.0         Last change: 15 Jun 1994                   32
  2110.  
  2111.  
  2112.  
  2113.  
  2114.  
  2115.  
  2116. VOGLE(3)               C Library Functions               VOGLE(3)
  2117.  
  2118.  
  2119.  
  2120.      topjustify()
  2121.           Top justifies text. The text string will be drawn  with
  2122.           it's  upper  edge  aligned with the current Y position.
  2123.           Bottom justification and Y centering are turned off.
  2124.  
  2125.                Fortran:
  2126.                     subroutine topjustify
  2127.  
  2128.                C:
  2129.                     topjustify()
  2130.  
  2131.                Pascal:
  2132.                     procedure TopJustify
  2133.  
  2134.  
  2135.      bottomjustify()
  2136.           Bottom justifies text. The text string  will  be  drawn
  2137.           with  it's  lower edge aligned with the current Y posi-
  2138.           tion.  Top justification and  Y  centering  are  turned
  2139.           off.
  2140.  
  2141.                Fortran:
  2142.                     subroutine bottomjustify
  2143.  
  2144.                C:
  2145.                     bottomjustify()
  2146.  
  2147.                Pascal:
  2148.                     procedure BottomJustify
  2149.  
  2150.  
  2151.      ycentertext()
  2152.           Centers text in the Y direction. The text  string  will
  2153.           so  that it's center line is aligned with the current y
  2154.           position.  Top justification and  Bottom  justification
  2155.           are turned off.
  2156.  
  2157.                Fortran:
  2158.                     subroutine ycentertext
  2159.                C:
  2160.                     ycentertext()
  2161.  
  2162.                Pascal:
  2163.                     procedure YcenterText
  2164.  
  2165.  
  2166.      getcharsize(c, width, height)
  2167.           Get the width and height of a character. At the  moment
  2168.           the
  2169.  
  2170.      getcharsize(c, width, height)
  2171.           Get the width and height of a character. At the  moment
  2172.  
  2173.  
  2174.  
  2175. VOGLE 1.3.0         Last change: 15 Jun 1994                   33
  2176.  
  2177.  
  2178.  
  2179.  
  2180.  
  2181.  
  2182. VOGLE(3)               C Library Functions               VOGLE(3)
  2183.  
  2184.  
  2185.  
  2186.           the  height  returned  is always that of the difference
  2187.           between the maximum descender and ascender.
  2188.  
  2189.                Fortran:
  2190.                     subroutine getcharsize(c, width, height)
  2191.                     character*1 c
  2192.                     real width, height
  2193.                C:
  2194.                     getcharsize(c, width, height)
  2195.                          char c;
  2196.                          float     *width, *height;
  2197.  
  2198.                Pascal:
  2199.                     procedure GetCharSize(c: char; var width, height: real)
  2200.  
  2201.  
  2202.      getfontsize(width, height)
  2203.           Get the maximum width and height of a  character  in  a
  2204.           font.
  2205.  
  2206.                Fortran:
  2207.                     subroutine getfontsize(width, height)
  2208.                     real width, height
  2209.                C:
  2210.                     getfontsize(width, height)
  2211.                          float     *width, *height;
  2212.  
  2213.                Pascal:
  2214.                     procedure GetFontSize(var width, height: real)
  2215.  
  2216.  
  2217.      drawchar(c)
  2218.           Draw the character c.  The  current  graphics  position
  2219.           represents the bottom left hand corner of the character
  2220.           space, unless centertext has  been  enabled,  where  it
  2221.           represents the "centre" of the character.
  2222.  
  2223.                Fortran:
  2224.                     subroutine drawchar(c)
  2225.                     character c
  2226.                C:
  2227.                     drawchar(str)
  2228.                          char c;
  2229.  
  2230.                Pascal:
  2231.                     procedure DrawChar(c: char)
  2232.  
  2233.  
  2234.      drawstr(str)
  2235.           Draw the text in  str  at  the  current  position.  The
  2236.           current  graphics  position  represents the bottom left
  2237.           hand corner of the character space,  unless  centertext
  2238.  
  2239.  
  2240.  
  2241. VOGLE 1.3.0         Last change: 15 Jun 1994                   34
  2242.  
  2243.  
  2244.  
  2245.  
  2246.  
  2247.  
  2248. VOGLE(3)               C Library Functions               VOGLE(3)
  2249.  
  2250.  
  2251.  
  2252.           has  been  enabled, where it represents the "centre" of
  2253.           the string.
  2254.  
  2255.                Fortran:
  2256.                     subroutine drawstr(str)
  2257.                     character*(*) str
  2258.                C:
  2259.                     drawstr(str)
  2260.                          char *str;
  2261.  
  2262.                Pascal:
  2263.                     procedure DrawStr(str: string_t)
  2264.  
  2265.  
  2266.      strlength(str)
  2267.           Return the length of the string s in world units.
  2268.  
  2269.                Fortran:
  2270.                     real function strlength(str)
  2271.                     character*(*) str
  2272.                C:
  2273.                     float
  2274.                     strlength(str)
  2275.                          char *str;
  2276.  
  2277.                Pascal:
  2278.                     function StrLength(str: string_t): real;
  2279.  
  2280.  
  2281.      boxtext(x, y, l, h, s)
  2282.           Draw the string s so that it fits in the imaginary  box
  2283.           defined  with bottom left hand corner at (x, y), length
  2284.           l, and hieght h. This only applies to software text.
  2285.  
  2286.                Fortran:
  2287.                     subroutine boxtext(x, y, l, h, s)
  2288.                     real x, y, l, h
  2289.                     character*(*)
  2290.                C:
  2291.                     boxtext(x, y, l, h, s)
  2292.                          float     x, y, l, h;
  2293.                          char *s;
  2294.  
  2295.                Pascal:
  2296.                     procedure BoxText(x, y, l, h: real; s: string_t)
  2297.  
  2298.  
  2299.      boxfit(l, h, nchars)
  2300.           Set scale for text so that  a  string  of  the  biggest
  2301.           characters  in the font will fit in a box l by h. l and
  2302.           h are real  values  in  world  dimensions.   This  only
  2303.           applies to software text.
  2304.  
  2305.  
  2306.  
  2307. VOGLE 1.3.0         Last change: 15 Jun 1994                   35
  2308.  
  2309.  
  2310.  
  2311.  
  2312.  
  2313.  
  2314. VOGLE(3)               C Library Functions               VOGLE(3)
  2315.  
  2316.  
  2317.  
  2318.                Fortran:
  2319.                     subroutine boxfit(l, h, nchars)
  2320.                     real l, h
  2321.                     integer nchars
  2322.                C:
  2323.                     boxfit(l, h, nchars)
  2324.                          float     l, h
  2325.                          int  nchars
  2326.  
  2327.                Pascal:
  2328.                     procedure BoxFit(l, h: real; nchars: integer)
  2329.  
  2330.  
  2331.   Transformations Routines.
  2332.      All transformations are cumulative, so if you  rotate  some-
  2333.      thing  and  then do a translate you are translating relative
  2334.      to the rotated axes. If you need  to  preserve  the  current
  2335.      transformation  matrix use pushmatrix(), do the drawing, and
  2336.      then call popmatrix() to get back where you were before.
  2337.  
  2338.      translate(x, y, z)
  2339.           Set up a translation.
  2340.  
  2341.                Fortran:
  2342.                     subroutine translate(x, y, z)
  2343.                     real x, y, z
  2344.                C:
  2345.                     translate(x, y, z)
  2346.                          float     x, y, z;
  2347.  
  2348.                Pascal:
  2349.                     procedure Translate(x, y, z: real)
  2350.  
  2351.  
  2352.      scale(x, y, z)
  2353.           Set up scaling factors in x, y, and z axis.
  2354.  
  2355.                Fortran:
  2356.                     subroutine scale(x, y, z)
  2357.                     real x, y, z
  2358.                C:
  2359.                     scale(x, y, z)
  2360.                          float     x, y, z;
  2361.  
  2362.                Pascal:
  2363.                     procedure Scale(x, y, z: real)
  2364.  
  2365.  
  2366.      rotate(angle, axis)
  2367.           Set up a rotation in axis axis. Where axis  is  one  of
  2368.           'x', 'y', or 'z'.
  2369.  
  2370.  
  2371.  
  2372.  
  2373. VOGLE 1.3.0         Last change: 15 Jun 1994                   36
  2374.  
  2375.  
  2376.  
  2377.  
  2378.  
  2379.  
  2380. VOGLE(3)               C Library Functions               VOGLE(3)
  2381.  
  2382.  
  2383.  
  2384.                Fortran:
  2385.                     subroutine rotate(angle, axis)
  2386.                     real angle
  2387.                     character axis
  2388.                C:
  2389.                     rotate(angle, axis)
  2390.                          float     angle;
  2391.                          char axis;
  2392.  
  2393.                Pascal:
  2394.                     procedure Rotate(angle: real; axis: char)
  2395.  
  2396.  
  2397.   Patch Routines.
  2398.      patchbasis(tbasis, ubasis)
  2399.           Define the t and u basis matrices of a patch.
  2400.  
  2401.                Fortran:
  2402.                     subroutine patchbasis(tbasis, ubasis)
  2403.                     real tbasis(4, 4), ubasis(4, 4)
  2404.                C:
  2405.                     patchbasis(tbasis, ubasis)
  2406.                          float     tbasis[4][4], ubasis[4][4];
  2407.  
  2408.                Pascal:
  2409.                     procedure PatchBasis(tbasis, ubasis: Matrix44_t)
  2410.  
  2411.  
  2412.      patchprecision(tseg, useg)
  2413.           Set the minimum  number  of  line  segments  making  up
  2414.           curves in a patch.
  2415.  
  2416.                Fortran:
  2417.                     subroutine patchprecision(tseg, useg)
  2418.                     integer tseg, useg
  2419.                C:
  2420.                     patchprecision(tseg, useg)
  2421.                          int     tseg, useg;
  2422.  
  2423.                Pascal:
  2424.                     procedure PatchPrecision(tseg, useg: integer)
  2425.  
  2426.  
  2427.      patchcurves(nt, nu)
  2428.           Set the number of curves making up a patch.
  2429.  
  2430.                Fortran:
  2431.                     subroutine patchcurves(nt, nu)
  2432.                     integer nt, nu
  2433.                C:
  2434.                     patchcurves(nt, nu)
  2435.                          int     nt, nu;
  2436.  
  2437.  
  2438.  
  2439. VOGLE 1.3.0         Last change: 15 Jun 1994                   37
  2440.  
  2441.  
  2442.  
  2443.  
  2444.  
  2445.  
  2446. VOGLE(3)               C Library Functions               VOGLE(3)
  2447.  
  2448.  
  2449.  
  2450.                Pascal:
  2451.                     procedure PatchCurves(nt, nu: integer)
  2452.  
  2453.  
  2454.      rpatch(gx, gy, gz, gw)
  2455.           Draws a rational patch in the current basis,  according
  2456.           to the geometry matrices gx, gy, gz, and gw.
  2457.  
  2458.                Fortran:
  2459.                     subroutine rpatch(gx, gy, gz, gw)
  2460.                     real  gx(4,4), gy(4,4), gz(4,4), gw(4,4)
  2461.                C:
  2462.                     rpatch(gx, gy, gz, gw)
  2463.                         float  gx[4][4], gy[4][4], gz[4][4], gw[4][4];
  2464.  
  2465.                Pascal:
  2466.                     procedure Rpatch(gx, gy, gz, gw: Matrix44_t)
  2467.  
  2468.  
  2469.      patch(gx, gy, gz)
  2470.           Draws a patch in the current basis,  according  to  the
  2471.           geometry matrices gx, gy, and gz.
  2472.  
  2473.                Fortran:
  2474.                     subroutine patch(gx, gy, gz)
  2475.                     real  gx(4,4), gy(4,4), gz(4,4)
  2476.                C:
  2477.                     patch(gx, gy, gz)
  2478.                          float  gx[4][4], gy[4][4], gz[4][4];
  2479.  
  2480.                Pascal:
  2481.                     procedure Patch(gx, gy, gz: Matrix44_t)
  2482.  
  2483.  
  2484.   Point Routines.
  2485.      point(x, y, z)
  2486.           Draw a point at x, y, z
  2487.  
  2488.                Fortran:
  2489.                     subroutine point(x, y, z)
  2490.                     real x, y, z
  2491.                C:
  2492.                     point(x, y, z)
  2493.                          real x, y, z;
  2494.  
  2495.                Pascal:
  2496.                     procedure Point(x, y, z: real)
  2497.  
  2498.  
  2499.      point2(x, y)
  2500.           Draw a point at x, y.
  2501.  
  2502.  
  2503.  
  2504.  
  2505. VOGLE 1.3.0         Last change: 15 Jun 1994                   38
  2506.  
  2507.  
  2508.  
  2509.  
  2510.  
  2511.  
  2512. VOGLE(3)               C Library Functions               VOGLE(3)
  2513.  
  2514.  
  2515.  
  2516.                Fortran:
  2517.                     subroutine point2(x, y)
  2518.                     real x, y
  2519.                C:
  2520.                     point2(x, y)
  2521.                          float     x, y;
  2522.  
  2523.                Pascal:
  2524.                     procedure Point2(x, y: real)
  2525.  
  2526.  
  2527.   Object Routines.
  2528.      Objects are graphical entities created by the  drawing  rou-
  2529.      tines  called  between  makeobj and closeobj. Objects may be
  2530.      called from within other objects. When an object is  created
  2531.      most  of  the  calculations required by the drawing routines
  2532.      called within it are  done  up  to  where  the  calculations
  2533.      involve the current transformation matrix. So if you need to
  2534.      draw the same thing several times on the screen but in  dif-
  2535.      ferent  places  it is faster to use objects than to call the
  2536.      appropriate drawing routines each time.  Objects  also  have
  2537.      the  advantage  of being saveable to a file, from where they
  2538.      can be reloaded for later reuse. Routines which draw or move
  2539.      in  screen coordinates, or change device, cannot be included
  2540.      in objects.
  2541.  
  2542.      makeobj(n)
  2543.           Commence the object number n.
  2544.  
  2545.                Fortran:
  2546.                     subroutine makeobj(n)
  2547.                     integer n
  2548.                C:
  2549.                     makeobj(n)
  2550.                          int  n;
  2551.  
  2552.                Pascal:
  2553.                     procedure MakeObj(n: integer)
  2554.  
  2555.  
  2556.      closeobj()
  2557.           Close the current object.
  2558.  
  2559.                Fortran:
  2560.                     subroutine closeobj()
  2561.                C:
  2562.                     closeobj()
  2563.  
  2564.                Pascal:
  2565.                     procedure CloseObj
  2566.  
  2567.  
  2568.  
  2569.  
  2570.  
  2571. VOGLE 1.3.0         Last change: 15 Jun 1994                   39
  2572.  
  2573.  
  2574.  
  2575.  
  2576.  
  2577.  
  2578. VOGLE(3)               C Library Functions               VOGLE(3)
  2579.  
  2580.  
  2581.  
  2582.      genobj()
  2583.           Returns a unique object identifier.
  2584.  
  2585.                Fortran:
  2586.                     integer function genobj()
  2587.                C:
  2588.                     int
  2589.                     genobj()
  2590.  
  2591.                Pascal:
  2592.                     function GenObj: integer
  2593.  
  2594.  
  2595.      getopenobj()
  2596.           Return the number of the current object.
  2597.  
  2598.                Fortran:
  2599.                     integer function getopenobj()
  2600.                C:
  2601.                     int
  2602.                     getopenobj()
  2603.  
  2604.                Pascal:
  2605.                     function GetOpenObj: integer
  2606.  
  2607.  
  2608.      callobj(n)
  2609.           Draw object number n.
  2610.  
  2611.                Fortran:
  2612.                     subroutine callobj(n)
  2613.                     integer n
  2614.                C:
  2615.                     callobj(n)
  2616.                          int  n;
  2617.  
  2618.                Pascal:
  2619.                     procedure CallObj(n: integer)
  2620.  
  2621.  
  2622.      isobj(n)
  2623.           Returns non-zero if there is an object of number n.
  2624.  
  2625.                Fortran:
  2626.                     logical function isobj(n)
  2627.                     integer n
  2628.                C:
  2629.                     int
  2630.                     isobj(n)
  2631.                          int  n;
  2632.  
  2633.                Pascal:
  2634.  
  2635.  
  2636.  
  2637. VOGLE 1.3.0         Last change: 15 Jun 1994                   40
  2638.  
  2639.  
  2640.  
  2641.  
  2642.  
  2643.  
  2644. VOGLE(3)               C Library Functions               VOGLE(3)
  2645.  
  2646.  
  2647.  
  2648.                     function IsObj(n: integer): boolean;
  2649.  
  2650.  
  2651.  
  2652.      delobj(n)
  2653.           Delete the object number n.
  2654.  
  2655.                Fortran:
  2656.                     subroutine delobj(n)
  2657.                     integer n
  2658.  
  2659.                C:
  2660.                     delobj(n)
  2661.                          Object    n;
  2662.  
  2663.                Pascal:
  2664.                     procedure DelObj(n: integer);
  2665.  
  2666.  
  2667.  
  2668.      loadobj(n, filename)
  2669.           Load the object in the file filename a object number n.
  2670.  
  2671.                Fortran:
  2672.                     subroutine loadobj(n, filename)
  2673.                     integer n
  2674.                     character*(*) filename
  2675.                C:
  2676.                     loadobj(n, filename)
  2677.                          int     n;
  2678.                          char    *filename;
  2679.  
  2680.                Pascal:
  2681.                     procedure LoadObj(n: integer; filename: string_t)
  2682.  
  2683.  
  2684.      saveobj(n, filename)
  2685.           Save the object number n into the file  filename.  This
  2686.           call does not save objects called inside object n.
  2687.  
  2688.                Fortran:
  2689.                     saveobj(n, filename)
  2690.                     integer   n
  2691.                     character*(*) filename
  2692.                C:
  2693.                     saveobj(n, filename)
  2694.                          int  n;
  2695.                          char *filename;
  2696.  
  2697.                Pascal:
  2698.                     procedure SaveObj(n: integer; filename: string_t)
  2699.  
  2700.  
  2701.  
  2702.  
  2703. VOGLE 1.3.0         Last change: 15 Jun 1994                   41
  2704.  
  2705.  
  2706.  
  2707.  
  2708.  
  2709.  
  2710. VOGLE(3)               C Library Functions               VOGLE(3)
  2711.  
  2712.  
  2713.  
  2714.   Double Buffering.
  2715.      Where possible VOGLE allows for front and  back  buffers  to
  2716.      enable  things  like  animation  and  smooth updating of the
  2717.      screen. The routine backbuffer is used to initialise  double
  2718.      buffering.
  2719.  
  2720.      backbuffer()
  2721.           Make VOGLE draw in the backbuffer. Returns  -1  if  the
  2722.           device is not up to it.
  2723.  
  2724.                Fortran:
  2725.                     integer function backbuffer
  2726.  
  2727.                C:
  2728.                     backbuffer()
  2729.  
  2730.                Pascal:
  2731.                     function BackBuffer:integer
  2732.  
  2733.  
  2734.      frontbuffer()
  2735.           Make VOGLE draw in the front buffer. This  will  always
  2736.           work.
  2737.  
  2738.                Fortran:
  2739.                     subroutine frontbuffer
  2740.  
  2741.                C:
  2742.                     frontbuffer()
  2743.  
  2744.                Pascal:
  2745.                     procedure FrontBuffer
  2746.  
  2747.  
  2748.      swapbuffers()
  2749.           Swap the front and back buffers.
  2750.  
  2751.                Fortran:
  2752.                     subroutine swapbuffers
  2753.  
  2754.                C:
  2755.                     swapbuffers()
  2756.  
  2757.                Pascal:
  2758.                     procedure SwapBuffers
  2759.  
  2760.  
  2761.   Position Routines.
  2762.      getgp(x, y, z)
  2763.           Gets the current graphics position in world coords.
  2764.  
  2765.                Fortran:
  2766.  
  2767.  
  2768.  
  2769. VOGLE 1.3.0         Last change: 15 Jun 1994                   42
  2770.  
  2771.  
  2772.  
  2773.  
  2774.  
  2775.  
  2776. VOGLE(3)               C Library Functions               VOGLE(3)
  2777.  
  2778.  
  2779.  
  2780.                     subroutine getgp(x, y, z)
  2781.                     real x, y, z
  2782.  
  2783.                C:
  2784.                     getgp(x, y, z)
  2785.                          float *x, *y, *z;
  2786.  
  2787.                Pascal:
  2788.                     procedure GetGp(var x, y, z: real)
  2789.  
  2790.  
  2791.      getgpt(x, y, z, w)
  2792.           Gets the current transformed graphics position in world
  2793.           coords.
  2794.  
  2795.                Fortran:
  2796.                     subroutine getgpt(x, y, z, w)
  2797.                     real x, y, z, w
  2798.  
  2799.                C:
  2800.                     getgpt(x, y, z, w)
  2801.                          float *x, *y, *z, *w;
  2802.  
  2803.                Pascal:
  2804.                     procedure GetGpT(var x, y, z, w: real)
  2805.  
  2806.  
  2807.      getgp2(x, y)
  2808.           Gets the current graphics position in world coords.
  2809.  
  2810.                Fortran:
  2811.                     subroutine getgp2(x, y)
  2812.                     real x, y
  2813.  
  2814.                C:
  2815.                     getgp2(x, y)
  2816.                          float *x, *y;
  2817.  
  2818.                Pascal:
  2819.                     procedure GetGp2(var x, y: real)
  2820.  
  2821.  
  2822.      sgetgp2(x, y)
  2823.           Gets the current screen  graphics  position  in  screen
  2824.           coords (-1 to 1)
  2825.  
  2826.                Fortran:
  2827.                     subroutine sgetgp2(x, y)
  2828.                     real x, y
  2829.  
  2830.                C:
  2831.                     sgetgp2(x, y)
  2832.  
  2833.  
  2834.  
  2835. VOGLE 1.3.0         Last change: 15 Jun 1994                   43
  2836.  
  2837.  
  2838.  
  2839.  
  2840.  
  2841.  
  2842. VOGLE(3)               C Library Functions               VOGLE(3)
  2843.  
  2844.  
  2845.  
  2846.                          float *x, *y;
  2847.                Pascal:
  2848.                     procedure SgetGp2(var x, y: real)
  2849.  
  2850.  
  2851.  
  2852. BUGS
  2853.      We had to make up the font names based on some books of type
  2854.      faces.
  2855.  
  2856.      Polygon hatching will give  unexpected  results  unless  the
  2857.      polygon is initially defined in the X-Y plane.
  2858.  
  2859.      Double buffering isn't supported on all devices.
  2860.  
  2861.      We don't recommend the use of the smove/sdraw routines.
  2862.  
  2863.      The yobbarays may be turned on or they may be turned off.
  2864.  
  2865.  
  2866.  
  2867.  
  2868.  
  2869.  
  2870.  
  2871.  
  2872.  
  2873.  
  2874.  
  2875.  
  2876.  
  2877.  
  2878.  
  2879.  
  2880.  
  2881.  
  2882.  
  2883.  
  2884.  
  2885.  
  2886.  
  2887.  
  2888.  
  2889.  
  2890.  
  2891.  
  2892.  
  2893.  
  2894.  
  2895.  
  2896.  
  2897.  
  2898.  
  2899.  
  2900.  
  2901. VOGLE 1.3.0         Last change: 15 Jun 1994                   44
  2902.  
  2903.  
  2904.  
  2905.