This file contains an extremely abbreviated description of the command line
flags, initialization file statements, and data file declarations for Polyray.
See "polyray.doc" for more details.

Syntax:

   polyray datafile [ options ]

Command line options:

   -a              Perform simple antialiasing (neighbor averaging)
   -A              Perform adaptive antialiasing (based on threshold)
   -b pixels       pixels calculated between file flushes
   -B              Flush the output file every scan line
   -d probability  Dither objects using the given probability
   -D scale        Dither all rays using the given probability
   -J              Perform jittered antialiasing (fixed # of samples/pixel)
   -o filename     Output file name (default "out.tga")
   -p bits/pixel   Number of bits per pixel 8/16/24/32 (default 16)
   -P pallette     Which pallette to use [0=grey, 1=666, 2=884]
   -Q              Abort if any key is hit during trace
   -q flags        Turn on/off various global shading options
   -r renderer     Which rendering method [0=raytrace, 1=scan convert,
                   2=wireframe]
   -R              Resume an interrupted trace
   -s samples      # of samples per pixel when performing antialiasing
   -t status_vals  Status display type [0=none,1=totals,2=line,3=pixel].
   -T threshold    Threshold to start oversampling (default 0.2)
   -u              Write the output file in uncompressed form
   -v              Trace from bottom to top
   -V mode         Use VGA display while tracing [0=none,1=VGA]
   -W              Wait for key before clearing display
   -x columns      Set the x resolution
   -y lines        Set the y resolution
   -z start_line   Start a trace at a specified line

Initialization file ("polyray.ini") keywords:

   abort_test       true/false/on/off
   alias_threshold  [Value to cause adaptive anitaliasing to start]
   antialias        none/filter/jitter/adaptive
   display          none/vga
   max_level        [max depth of recursion]
   max_lights       [max # of lights]
   max_queue_size   [max # of objects in a priority queue]
   max_samples      [# of samples to use with antialiasing, or focal blur]
   pixel_size       [8, 16, 24, 32]
   pixel_encoding   none/rle
   renderer         ray_trace/scan_convert
   shade_flags      [default/bit mask of flags, see section 1.7.1.4]
   shadow_tolerance [miminum distance for blocking objects]
   status           none/totals/line/pixel
   warnings         on/off

   Any lines starting with "//" will be treated as comments & ignored.

Input file syntax:

   [viewpoint statement]
   [object declaration]
   [conditional statement]
   define token expression
   define token [object declaration]
   define token [texture declaration]
   define token transform { [rotate/translate/scale/shear statements] }
   total_frames val
   start_frame val
   end_frame val
   outfile "name"
   outfile name
   file_flush xxx
   include "filename"
   background color
   background expression
   haze coeff, starting_distance, color
   light color, location
   light location
   spot_light color, location, pointed_at, Tightness, Angle, Falloff
   spot_light location, pointed_at
   textured_light { color color_expression [rotate/translate/... statements] }
   directional_light color, direction
   directional_light direction


Viewpoint declaration:

    viewpoint {
       [ from vexper ]
       [ at vexper ]
       [ up vexper ]
       [ angle fexper ]
       [ hither fexper ]
       [ resolution fexper, fexper ]
       [ aspect fexper ]
       [ yon fexper ]
       [ dither_rays fexper ]
       [ dither_objects fexper ]
       [ max_trace_depth fexper ]
       [ aperture fexper ]
       [ focal_distance ]
       }

Object declaration:

   object {
      Shape declaration
      [ texture declaration ]
      [ Object modifier declaration ]
      }

Shape Declarations:

   bezier subdivision_type, flatness_value,
          u_subdivisions, v_subdivision,
          [ 16 comma-separated vertices, i.e.
             <x0, y0, z0>, <x1, y1, z1>, ..., <x15, y15, z15> ]

   blob threshold:
      blob_component1
      [, sphere <x, y, z>, strength, radius ]
      [, cylinder <x0, y0, z0>, <x1, y1, z1>, strength, radius ]
      [, plane <nx, ny, nz>, d, strength, distance ]

   box <x0, y0, z0>, <x1, y1, z1>

   cone <x0, y0, z0>, r0, <x1, y1, z1>, r1

   cylinder <x0, y0, z0>, <x1, y1, z1>, r

   disc <cx, cy, cz>, <nx, ny, nz>, r
   disc <cx, cy, cz>, <nx, ny, nz>, ir, or

   function f(x,y,z)

   gridded "filename", object1 object2 ...

   height_field "filename"
   smooth_height_field "filename"

   height_fn xsize, zsize, min_x, max_x, min_z, max_z, expression
   height_fn xsize, zsize, expression
   smooth_height_fn xsize, zsize, min_x, max_x, min_z, max_z, expression
   smooth_height_fn xsize, zsize, expression

   lathe type, direction, total_vertices,
      <vert1.x,vert1.y,vert1.z>
      [, <vert2.x, vert2.y, vert2.z>]
      [, etc. for total_vertices vertices]

   parabola <x0, y0, z0>, <x1, y1, z1>, r

   polygon total_vertices,
      <vert1.x,vert1.y,vert1.z>
      [, <vert2.x, vert2.y, vert2.z>]
      [, etc. for total_vertices vertices]

   polynomial f(x,y,z)

   sphere <center.x, center.y, center.z>, radius

   sweep type, direction, total_vertices,
      <vert1.x,vert1.y,vert1.z>
      [, <vert2.x, vert2.y, vert2.z>]
      [, etc. for total_vertices vertices]

   torus r0, r1, <center.x, center.y, center.z>, <dir.x, dir.y, dir.z>

   patch <vert1.x,vert1.y,vert1.z>, <norm1.x,norm1.y,norm1.z>,
         <vert2.x,vert2.y,vert2.z>, <norm2.x,norm2.y,norm2.z>,
         <vert3.x,vert3.y,vert3.z>, <norm3.x,norm3.y,norm3.z>

   object1 + object2  - Union
   object1 * object2  - Intersection
   object1 - object2  - Difference
   object1 & object2  - Clipping
   ~object1           - Inverse

Root solver declarations (for blobs, polynomials, splined lathes, and tori):

   root_solver Ferrari
   root_solver Vieta
   root_solver Sturm

Object modifier statements:

   translate <tx, ty, tz>
   rotate <rx,ry,rz>
   scale <sx,sy,sz>
   shear yx, zx, xy, zy, xz, yz
   shading_flags flag1+flag2+...
   u_steps u
   v_steps v
   bounding_box <x0,y0,z0>, <x1,y1,z1>

Shading flag values:

   1 = Shadow_Check, 2 = Reflect_Check, 4 = Transmit_Check,
   8  = Two_Sides, 16 = Cast_Shadow, 32 = Check Primary Rays


Textures:
   texture {
      [ texture declaration ]
      [ rotate/translate/scale/shear ]
      }

Texture declarations:

   surface { [ surface declarations ] }
   noise surface { [ surface declarations ] }
   special surface { [ surface declarations ] }
   checker texture1, texture2
   hexagon texture1, texture2, texture3
   layered texture1, texture2, ..., textureN

Surface declarations:

   color <r, g, b>
   ambient scale
   ambient color, scale
   diffuse scale
   diffuse color, scale
   specular color, scale
   specular scale
   reflection color, scale
   reflection scale
   transmission color, scale, ior
   transmission scale, ior
   microfacet kind angle

Microfacet kinds: Blinn, Cook, Gaussian, Phong, Reitz.

Noise Surface declarations:

   color <r, g, b>
   ambient scale
   diffuse scale
   specular color, scale
   reflection scale
   transmission scale, ior
   microfacet kind angle
   color_map(map_entries)
   bump_scale fexper
   frequency fexper
   phase fexper
   lookup_fn index
   normal_fn index
   octaves fexper
   position_fn index
   position_scale fexper
   turbulence fexper

Conditional processing:

   if (cexper)
      [single declaration]

   if (cexper) {
      [object/light/... declarations]
      }
   else {
      [other object/light/... declarations]
      }

