Software 2000

home *** CD-ROM | disk | FTP | other *** search

/ Software 2000 / Software 2000 Volume 1 (Disc 1 of 2).iso / utilities / u222.dms / in.adf / RayTracer / RAY.Doc < prev next >

Wrap

Text File | 1988-03-13 | 46.8 KB | 934 lines

/************************************************************************ * * * Copyright (c) 1987, David B. Wecker * * All Rights Reserved * * * * This file is part of DBW_Render * * * * DBW_Render is distributed in the hope that it will be useful, but * * WITHOUT ANY WARRANTY. No author or distributor accepts * * responsibility to anyone for the consequences of using it or for * * whether it serves any particular purpose or works at all, unless * * he says so in writing. Refer to the DBW_Render General Public * * License for full details. * * * * Everyone is granted permission to copy, modify and redistribute * * DBW_Render, but only under the conditions described in the * * DBW_Render General Public License. A copy of this license is * * supposed to have been given to you along with DBW_Render so you * * can know your rights and responsibilities. It should be in a file * * named COPYING. Among other things, the copyright notice and this * * notice must be preserved on all copies. * ************************************************************************/ Sections ~~~~~~~~ Announcement - announcement of software availability Included - what's in the package Under Development - what's currently being written Background Info - what is this package? Running RAY - how to run the ray tracer Running RAY2 - how to run the post-processor Running DISPLAY - how to run the display program Creating a .DAT file- what goes into the input file (the hardest part) Source file info - how to rebuild the package Announcement ~~~~~~~~~~~~ If you liked the ray traced images previously distributed... you're going to LOVE DBW_Render. This package is a FULL re-implementation of the Ray Tracer that I've been using on VAXen to create all those images. It will run on a standard Amiga (with 512k of memory (and can be configured to run in 256k if necessary)). By adding AI-heuristics, elapsed time to compute an image is within the same order of magnitude as a VAX-780 (even though the Amiga doesn't have hardware floating point or virtual memory)! For example "glass" computes in 50 hours on an Amiga without the heuristics. With the heuristics, the image (at full resolution) can be computed in 11 hours. Included: ~~~~~~~~~ RAY - ray tracing program RAY2 - post processor to create IFF/ILBM format files DISPLAY - general display program for RAY2's output *.DAT - sample input files *.TMP - sample RAY output files *.ILBM - sample HAM encoded pictures (RAY2 output) *.c - all MANX-Aztec C sources for the package *.h - all MANX-Aztec C include files for the package RAY.DOC - full documentation for the package COPYING - General License Agreement Please read the General License Agreement (file: COPYING) before proceeding. Under Development ~~~~~ ~~~~~~~~~~~ Depending on the level of interest in this software, I will continue work on: DBW_ED3D a full 3-dimensional graphics editor (so you don't have to mathematically specify the input file to RAY, you can just draw it). DBW_FILM which creates a film loop of HAM images (so you can create your own "juggler" type demos). ---- a version of the software using increased memory and floating point co-processor. ---- maintenance and enhancements to the current package. Background Information ~~~~~~~~~~ ~~~~~~~~~~~ The DBW_Render package uses an algorithm called Distributed Ray Tracing. In addition to neatly solving the hidden surface problem, ray tracing (in general) affords the opportunity for doing excellent (that is, highly realistic) shading and illumination calculations. This package is written in MANX-Aztec C and runs on any AMIGA system. The RAY program knows how to create images composed of four primitive geometric objects: spheres, parallelograms, triangles, and flat circular rings (disks with holes in them). Some of the features of the program are: Determination of correct shadows cast by arbitrarily shaped objects, onto arbitrarily shaped objects, due to arbitrarily placed light sources. Diffuse and specular reflections (with arbitrary levels of gloss or polish). Rudimentary modeling of object-to-object diffusely reflected light is also implemented, that among other things accurately simulates color bleed effects from adjacent contrasting colored objects. Mirror reflections, including varying levels of mirror smoothness or perfection. Refraction and translucency (which is akin to variable microscopic smoothness, like the surface of etched glass). Two types of light sources: purely directional (parallel rays from infinity) of constant intensity, and spherical sources (like light bulbs, which cast penumbral shadows as a function of radius and distance) where intensity is determined by the inverse square law. Photographic depth-of-field. That is, the virtual camera may be focused on a particular object in the scene, and the virtual camera's aperture can be manipulated to affect the sharpness of foreground and background objects. Solid texturing. Normally, a particular object (say a sphere) is considered to have constant properties (like color) over the entire surface of the object, often resulting in fake looking objects. Solid texturing is a way to algorithmically change the surface properties of an object (thus the entire surface area is no longer of constant nature) to try and model some real world material. Currently the program has built in rules for modelling wood, marble, bricks, snow covered scenes, water (with arbitrary wave sources), plus more abstract things like color blend functions. Fractals. The program implements what's known as recursive triangle subdivision, which creates all manners of natural looking surface shapes (like broken rock, mountains, etc.). The character of the fractal surface (degree of detail, roughness, etc.) is controlled by parameters fed to the program. AI heuristics to complete computation of a scene within a user specified length of time. When the RAY program runs, it reads a sort of command file, that contains a geometric description of the scene to be rendered, plus desired global lighting conditions, camera parameters, etc. Then the program computes for a long time, writing each scan line to disk as it computes it. The format of a scanline (in the .TMP) file is: <line number> - 2 bytes long <red pixels> - 160 bytes long (4 bits per pixel) <green pixels> - 160 bytes long <blue pixels> - 160 bytes long For an entire screen (400 scan lines) this file is 192,800 bytes. A second program is run (RAY2) to obtain one of three possible output files: 4096 colors (HAM) encoded interlaced 320x400 resolution 32 colors interlaced 320x400 resolution 32 colors 320x200 resolution All of the file formats are standard IFF/ILBM and may be displayed by the supplied DISPLAY program. In addition, the last version (320x200) may be edited by any standard graphic package (e.g., DPaint). Others may be able to handle the more complex first two. In all, the DBW_Render package represents about 4000 lines of C code. It is largely based on original algorithms for the VAX by Tom Dahl and Tone Engel at Digital Equipment Corporation. The AMIGA version has taken several months to create. Running RAY ~~~~~~~~~~~ REMINDER: BEFORE RUNNING ANYTHING MAKE SURE YOU BACKUP THIS DISK!!! Once you have an input file (described below in the "Creating a .DAT file" section) you can run the ray tracer. Remember that the output of the Ray Tracer (for a full screen) will be 192,800 bytes or a little over 400 blocks so make sure you have enough free space on the disk you are running on. It is NOT suggested that you direct the output to RAM: since if the machine crashes you will lose all of your work. In addition make sure you have a STACK of at least 10000 before you start! If you have a file called GLASS.DAT for input, you can type: 1> ray glass The program will start running. All of the options are in the .DAT file. See the file GLASS.DAT (distributed with the package) for an example. As the program runs, it will write to the file GLASS.TMP. If you want different names for the input and output files, then run the program with no parameters: 1> ray at which point you will be prompted for the input file: Scene description file? to which you could answer GLASS.DAT. The program will then ask for the name of the output file: File name to save picture (.tmp)? to which you could answer DF1:GLASS.TMP. The program will now compute the picture. Note that 4 extra scan lines before and after your scene are ALWAYS computed, so if you told the program to do a full screen (command "& 0 400" in the command file) you will notice that the program will start at scan line -4 and will and at scan line 403. This is due to one requirement of the AI-heuristics to fill a scan line cache before output can occur. When the program finishes, it will give you a bunch of statistics about the picture. One of the most interesting is the number of pixels GUESSED as opposed to the number of pixels COMPUTED. This will give you and idea of how high a quality output to expect (0 guessed = perfect). These numbers are affected by the amount of time you give the program to compute the picture in ("R" command in the command file). Running RAY2 ~~~~~~~ ~~~~ After RAY has completed, the output .TMP file (or files) may be post-processed by RAY2. Multiple files may be given to RAY2 for several reasons: 1) The machine crashed and so you have one partial file and another that has the rest of the scan lines in it. 2) You decided to do the picture in strips and have a seperate file for each strip. 3) You did the entire picture, but there are blurry scan lines around complex objects (like light sources) because you didn't give it enough time... so you recomputed the bad sections allowing more time. These will become clearer as we do the examples. To run the program, type: 1> ray2 glass this will open file GLASS.TMP (which was output from RAY), scan the file finding the most used colors, open a custom screen, create a HAM mode image on the screen and will then read back the image from the screen creating GLASS.ILBM. When the program is done, it will flash the screen at which point you can hit the (invisible) close gadget in the upper left corner to exit the program. While the program is creating the output file, it will complement the first pixel on each scan line it computes so that you can see its progress through the picture. An example of using ALL options for the RAY2 program is: 1> ray2 -c 1 -h 1 -l 1 -o glass.ilbm glass Where the options are: -c = is compression allowed (0 or 1) (default = yes = 1) -h = is HAM mode to be used (0 or 1) (default = yes = 1) -l = is LACE mode to be used (0 or 1) (default = yes = 1) -o = name of the output file to create <name> = upto 10 input file names The example shown will create an image exactly like the previous example (since all defaults are being taken). If we wanted the simplest picture (that something like DPaint could edit) and we had several input files, we could type: 1> ray2 -h 0 -l 0 -o glass.pic glass1 glass2 glass In this example we are using multiple input files. The program will ALWAYS use scanlines from files earlier in the command line (if possible). So for example, GLASS.TMP (on the distribution disk) contains a 12 hour complete picture. GLASS1.TMP and GLASS2.TMP contain scanlines around the light sources (that are blurry in GLASS.TMP) but with a resolution of 24 hours (so that they're much better (each took between 1 and 2 hours to compute)). This program also uses a heuristic to figure out how to fold 4096 colors into 32 when you turn HAM mode off. Running DISPLAY ~~~~~~~ ~~~~~~~ DISPLAY is a VERY simple program to run, all you need to say is: 1> display glass and GLASS.ILBM will get displayed. If you have a different extension, then type the full file name: 1> display glass.pic The picture will be displayed until you click the mouse on the invisible close gadget in the upper left corner of the screen. Remember that you can use Left-Amiga-N and Left-Amiga-M to push this screen behind the Workbench and pull it back in front. Creating a .DAT file ~~~~~~~~ ~ ~~~~ ~~~~ Okay, now the hard part: the contents of the script input file. The file is a standard ASCII text file, with each line forming a separate object or command to RAY. The lines begin with a command character (which is CASE SENSITIVE). The command characters are: R Set resolution (optional, if missing, program will default to 12.0 hours) N Global index of refraction (optional, default = 1.0) Z Produce 2D histogram, rather than true image (default true image) a Set overriding ambient proportion factor (default not overridden) A Set antialiasing parameters (default no antialiasing) F Set lens focus and aperture for depth of field (default infinite depth) M Set global diffuse lighting parameters (default off) & Define scan-line region of image to generate *,! comment, ignored b Set background color w Define a wave source g Define a color blend texture n Define a snowfall texture k Define a 3D checkerboard texture H Set global haze parameters (default no haze) f Define fractal surface parameters m Define a marble texture d Define a wood texture e Set the eye (camera) view parameters l Define a directional light source L Define a spherical light source { Start an extent } Terminate an extent s Specify a spherical object t Specify a planar triangular object x Specify a fractal triangular object q Specify a planar paralleligram object r Specify a planar ring (annular) object First, all color values consist of three numbers that range from 0 to 1. The color components are specified BLUE, GREEN, RED. All position/direction values are three numbers ranging in whatever numbering system you want. The numbers are X, Y, Z order. Assuming you are looking into the screen in the negative Z direction, positive X is to the right, positive Y is up, and positive Z is out from the screen. Okay, on to the specifics of the parameters that each command character requires. First are listed all the general (environmental) commands, then are listed the commands that create objects to be rendered in the scene. Global index of refraction (optional, default = 1.0) N INDEX This single value is taken to be the index of refraction of "the air", or put another way of the space between and outside of all objects. Set resolution (optional, default = 12.0 hours) R RESOLUTION The RESOLUTION value controls the MAXIMUM amount of time that a full screen (400 scanlines) is allowed to take. This number should typically be between 1.0 and 30.0 hours. The more time you give the program the better the picture will be that you get. Produce 2D histogram, rather than true image Z FLAG Normally, the contents of the .TMP file that the ray tracer produces is a binary pixel version of the described scene. However, for the purposes of doing performance tuning of an antialiased scene, you can include the command "Z 1" in the script file. If done, the image file that the ray tracer generates will not be the color scene that it normally is, but instead will be a sort of 2D histogram of how much computation each pixel in the scene consumed, displayed as a gray scale (the brighter the pixel, the more computation). Note that this command is only meaningfull if non-default values for the "A" command have been used. By default, basically an equal amount of time is spent on each pixel, (thus an image with Z set to 1 would come out a flat gray) but the "A" command tells the ray tracer to concentrate on certain types of details in the scene to produce alias-free images. Using the Z command with a parameter of 1 will allow you to see just where the ray tracer decided to spend more time, smoothing edges, etc. Set overriding ambient proportion factor a FACTOR As described below, each object in the scene contains parameters that control how bright the object appears if no light is shining on it. Thus you can set some objects to appear brigher when in shadow that other objects. As an alternative, you can specify the "a" command with a parameter from 0 to 1, and this will cause the ambient color of all objects in the scene to be a fraction of their diffuse brightness. When the "a" command is used, the BGR ambient values for each object are ignored (but they must still be specified). A reasonable starting point would be to set FACTOR from between .1 and .2. Set antialiasing parameters A COUNT THRESHHOLD By default, the ray tracer computes one ray into the scene for each pixel in the image (so a 320X4000 image computes ~128K rays). Quite often, some unpleasant side effects of the digital generation process become apparent in a scene generated with one ray per pixel, for example diagonal lines are rendered as a sequence of discrete stairsteps -- the dreaded jaggies. Such false features are called aliasing defects. There are numerous techniques devised to try to reduce the magnitude of these defects, collectively referred to as the process of anti-aliasing. (There are many other types of aliasing defects besides jaggies. An example of another "defect" is the razor-sharp shadows that are traditionally found in computer generated imagery -- real-world shadows are always at least a teensy bit diffuse.) The COUNT parameter determines how many rays will be traced for each pixel in the scene -- the more, the better, but the slower the computing. A good starting value is 4. What happens is that a bunch of rays (e.g. 4) are sent into the pixel cone at random -- they are "distributed" across the horizontal and vertical dimensions. Thus, this ray tracer is said to implement Distributed Ray Tracing. The THRESHHOLD value relates to a rather complicated feature in the ray tracer called Statistically Optimized Distributed Ray Tracing. The way this works is that the program computes the intensities of the bunch of rays that are distributed into the pixel. In this example, say there are four rays in the bunch. The program computes the statistical variance of the four resulting intensities. If the variance is small, the odds are that the portion of the scene being imaged is a smooth patch. Thus a good approximation to the ideal intensity of that pixel has been computed. But let's say that the pixel happens to fall on a diagonal edge. Some of the distributed rays will be cast to one side of the edge, and some of them to the other. Thus the variance will be high. The program looks at this, and if the variance is past the THRESHHOLD value, will distribute another group of (in this case) four rays into the pixel. Then the variance of the eight rays will be examined, and the process repeated until the required smoothness has been reached (or some arbitrarily large number of rays have been cast, and the process halts). Setting THRESHHOLD to value of 1.0 or higher generally will force no extra groups of rays to be cast, beyond the initial group of COUNT rays. Meaningfull values of THRESHHOLD generally fall in the .0001 to .1 range. Set lens focus and aperture for depth of field F APERTURE FOCUS This command is optional; if omitted, the scene will be rendered such that all objects will be in perfect focus (a pin-hole camera effect). With this command, you can add depth-of-field effects to a scene (though at great computation speed degradation, as described below). The APERTURE parameter specifies the radius of the hypothetical lens in the camera that is taking the picture of the scene. FOCUS sets the distance from the camera (or eye) at which objects will appear in perfect focus. The magnitude of both values depends upon the coordinate system in use by your scene, of course, but here is an example for determining a reasonable camera aperture. Say that one unit of distance represents an inch. Assume you set the focus distance to 100 inches; with this scale, a reasonable value for aperture is 0.5 to 2.0. In order to achieve a good quality smooth blurring of the foreground and background, you will need to set the antialiasing parameters up from their defaults (with the A command). A good start would be 20 to 30 rays per pixel; the THRESHHOLD value doesn't matter much; it could be set to 1. Set global diffuse lighting parameters M COUNT NUMERATOR DENOMINATOR This command relates to the realistic propagation of light as it reflects from object to object in the scene. Traditionally, computer lighting models operate such that if an object is directly visible from a light source, then the surface of the object is colored according to the material's properties, the color and strength of the light, etc. For those objects or portions of objects that are not in the path of a light source (aka are in shadow), they are rendered black. Well, this is usually artificial looking, and so a constant dim color is assigned to areas in shadow. (In fact, this program has provisions for this as well, the ambient parameters of each object, plus the "a" command.) But in reality, shadows are filled in with light bounced off walls, etc. The M command can be employed to model this diffuse propagation of light from object to object. (Sadly, once again performance suffers significantly if you choose to do this, since a great deal of information about the scene needs to be collected and analyzed to determine how the shadow fill-in should occur.) How this program does this is to, for each pixel, sample extra rays from the surface being rendered, out into the scene in random directions to see what other nearby surfaces are acting as reflectors, etc. The COUNT parameter controls how many samples to take per pixel; values from 10 on up are okay, but 100 or more are needed to render smooth color bleeding from surface to surface, etc. The NUMERATOR and DENOMINATOR derive from the recursive nature of the ray tracing process: in the process of calculating a ray on the surface being rendered, assume the ray strikes an adjacent surface. Well, from THAT surface, another COUNT set of rays will ne sampled, to determine ITS color, etc.; thus the process exponentially generates rays that need to be computed. To avoid this recursive growth, the number of sample rays that are done per recursion level is scaled from the initial COUNT value, according to the supplied NUMERATOR and DENOMINATOR values. For example values of 1 and 2 respectively will reduce by half the number of samples taken at each recursion level. Normally, even this is not a fast enough decay, so 1/3 or 1/4 is better, without much noticable loss in resulting color fidelity. In fact, setting NUMERATOR to 0 is not unreasonable. Define scan-line region of image to generate & FIRST LAST If this command is omitted, the entire image bitmap will be calculated (all 400 scan lines). This command tells the program only to produce those scans from FIRST to LAST-1 inclusive. Once done, the resulting fragment images can be combined into one whole image file. In this way, a particularly complex scene may be distributed into a number of CPUs, resulting in shorter elapsed generation time. Picture merging is accomplished by RAY2). Set background color b BLUE GREEN RED The simple color value that will be displayed if no objects are visible at a given point in the scene. Define a wave source w CENTERX CENTERY CENTERZ WAVELENGTH AMPLITUDE DAMP PROPAGATE A number of features in the program use wave sources as a basis for calculating various effects (most notably the production of rippled surfaces, such as water). You can define up to 100 wave sources per scene. There is only one "wave source table" stored by the program; all of the features that use waves use the same waves. The first three values specify the coordinate from which the concentric wave fronts emanate from. WAVELENGTH sets the crest-to-crest distance for the wave. The AMPLITUDE value determines, in an abstract manner, the height of the wave at the origin. The height is not specified in normal distance units; rather it is a fixed scale frational value, in the approximate range of 0.1 (small, flat waves) to 0.5 (strong waves). The DAMP value controls the damping of successive trains of waves. The value 1.0 means no damping; the waves will contine out to infinity from the source. Value 0.7 means that successive crests will be 70% the height of the preceeding crest. The PROPAGATE value controls what phase the wave starts broadcasting at; the value ranges from 0.0 (starting at a crest at the origin) through 0.5 (180 degrees out of phase -- a trough) and back to 1.0 (a crest). This can be used in sequenced frames to produce moving waves. Define a color blend texture g BCOLOR GCOLOR RCOLOR START RANGE Normally, an object is solidly and uniformly colored across its entire surface. This command lets you define a blend function which can be applied to any object, in such a manner that the color of the object will vary as a function of altitude (Y coordinate). For example, a sphere could be blue at the south pole, and yellow at the north pole, with the color smoothly changing in the middle. You can define up to ten blends per scene. The three COLOR values specify the target color that the surface will blend to with increasing Y coordinate (the initial color of the object at low Y coordinate values is taken from the diffuse coeficients of the object, as defined a ways below in the section on object properties). The START value defines the low-Y coordinate where blending starts; surface points below this Y level will be colored with the objects diffuse coeficients. The blending continues from START, continuing for RANGE units upward. At the level of START+RANGE, the blend would have saturated out at the new COLOR value. Points above START+RANGE will maintain the new COLOR. As an example, consider a sphere of radius 100 units positioned at the origin. If START was set to -33, and RANGE was set to 66, the result would be that the lower third of the sphere would be its base diffuse color; the middle third would gradually change color up until at the +33 level the color would attain the new COLOR; the upper third of the sphere would maintain the new COLOR. Define a snowfall texture n START ALTITUDERANGE ALTFACTOR THRESHHOLD This texture function is similar to the above blend texture. It is still under development. This is intended to be used with the fratcal surface capabilities described below. The theory is that this will distribute snow onto an object, the nature of which varies according to the local surface slope and altitude. START is the lower bound below which there can be no snowfall accumulation, even on level surfaces. Points on the surface above the level of START+ALTITUDERANGE generally are solidly blanketed with snow. ALTFACTOR is a scaler that lets you determine how important altitude is in determining snow cover; value 0 means it is irrelevant (thus it is just a function of local surface slope). Values above 1.0 generally result in a faster buildup of snow at the low end of the ALTITUDERANGE scale. THRESHHOLD controls when a surface will be solidly blanketed, if it meets the threshhold test. Values for this parameter range from 0.0 (at which everything from START and above will be solidly coated, regardless of slope) to 1.0, where coverage will be a continuous function of slope and altitude. Values around .4 result in surfaces from about 40 degrees of slope and flatter to be solidly covered. Define a 3D checkerboard texture k BCOLOR GCOLOR RCOLOR X Y Z JUNK1 JUNK2 JUNK3 You can define up to 10 checker textures per scene. This texture function determines the color of points on the surface of an object, using a 1- (layer), 2- (checker, column), or 3-dimensional (block) model. As the points on the surface of an object are colored, this texture function can be used to determine whether the color of the point in question is the object's base diffuse color, or is a different specified color (controlled the three COLOR parameters to this command). To determine whether the surface point is inside or outside which color region, the X Y Z pattern size values are checked. The X parameter defines the width of successive layers from left to right; Y defines the width of successive layers from top to bottom; Z is for front to back. Note that one or more X Y or Z values can be set to 0. This will cancel any variation in the pattern in the corresponding dimention. For example, if X and Z are set to 10 but Y is 0, the effect will be of square vertical columns of alternating color. If only Y were non-zero, the effect would be of horizontal layers of alternating color. Setting all three to non-zero creates a solid 3D block pattern. The width of the layers in X Y and Z need not be the same (so you can make long flat blocks, for example). JUNK1, JUNK2, and JUNK3 are currently not used and should be set to 0. Set global haze parameters H BCOLOR GCOLOR RCOLOR DISTANCE If this command is omitted, the color of each pixel in the scene is not affected by how far the rendered surface is from the eyepoint. By using this haze command, you can cause objects in the distance to be progressively tinted to a specified target haze color (the three COLOR values). Objects that are DISTANCE units or farther from the eyepoint will be completely tinted or blended to the haze color and thus will become effectively invisible. Objects closer than this distance will be continuously tinted from their true local color to the haze color, in a linear manner as a function of distance. Define fractal surface parameters f RECURSIONLEVEL XSCALE YSCALE ZSCALE FINALTEXTURE This texture can only be applied to 'x' objects as defined below. The ray tracer so far only knows how to render a small set of primitive object shapes, one of which is the three-sided polygon (triangle). As described in the 'x' command below, the ray tracer does have the capability to algorithmically generate compound objects that are constructed out of large numbers of adjacent triangles forming what is called a stochastic surface (often thought of as a fractal surface, though in fact the relationship to the mathemacits of fractals is limited). This command defines parameters that the ray tracer uses in constructing the mesh of triangular surface patches. You can define up to 10 fractal textures per scene. In order to define a fractal surface, you must also define at least one wave source with the "w" command (the reason for this apparently unrelated need will be explained). The general fractal construction procedure is based on recursive triangle subdivision, applying complex coordinate shifts when determining the vertices of the subdivision triangles. You start with one master triangle that controls the gross size and orientation of the final surface. The original triangle is split into four triangles (by bisecting the three sides and connecting the midpoints). The corners of the new triangles are then shifted in space, and they are recursively subdivided in turn, to the desired level. The RECUSIONLEVEL sets this depth; the higher the depth, the finer the resulting surface, but the slower the image will take to compute (on the order of four times with each successive level). Plus larger level values require substantial quantities of address space to contain the generated triangle data (on the order of thousands of 512-byte memory pages for a level of 7, for example... so BE CAREFUL!). The X Y and ZSCALE values allow you to emphasize distortion differenly in the three dimensions (X and Z of 1.0, with Y of 3.0 results in three times as much vertical relief as horizontal, for example). Values of 0 for a scale parameter cause the sub-triangles to not move in the indicated dimension (X and Y of 0 will make the resulting surface maintain a triangular silhouette as seen from above). The FINALTEXTURE value will be assigned as the texture function number for each of the sub-triangles (see the description of texture function values for objects below). Basically, this allows you to apply a uniform texture to the entire fractal object: a smooth color gradiation, a checkerboard, etc. As mentioned above, to get a good rough fractal surface, you need to also define a small number of wave sources. A good starting point is to specify five or six wave sources, whose actual XYZ coordinates are scattered about the scene. Giving them different wavelenghts and amplitudes will increase the fluctuation in the surface. Generally, the damping should be small (values of or near 1.0). The actual manner in which the waves are utilized in constructing the sub triangle vertices is beyond convenient description; suffice it to say that there is NO randomness involved, and that different wave patters will produce markedly different fractal surfaces. Experment. Define a marble texture m BVEINCOLOR GVEINCOLOR RVEINCOLOR XSCALE TURBULENCE SQUEEZE You can define up to ten marble textures per scene. This texture relies on your having defined at least one wave source, for reasons described below. The marble is modelled as a base substance that has intrusions of a second substance into the base. The base color is determined by the diffuse coefficients for the object. The intrusion color is specified in the three VEINCOLOR parameters. The actual color for the surface of the marble object is a complex blending function of the two starting colors. The basic formula for making the intrusions (veins) is to start with equally spaced vertical layers (spaced along the X axis). The spacing is determined by the XSCALE parameter (good values are from 0.1 to 1). Then turbulence is applied to the layers, deforming them into myriad whorls and streaks, etc. The amount of turbulence is set by the TURBULENCE parameter (values from 1.0 to 3.0 are nice). The rough thickness of the streaks is determined by the SQUEEZE parameter (which must be an integer -- no fractional component). The value 1 means leave them normal width; 2 means twice as thin; 3 means four times as thin; 4 means eight times, etc. Another way to think of SQUEEZE is that it affects how fast the blending occurs from the base to the vein color. The turbulence is controlled by (of all things) the wave sources that you have defined in the scene. Unfortunately, the correspondence between a particular wave source and a particular turbulent result is almost impossible to predict (but it IS possible; there is no randomness involved). All that can really be done is to give guidelines for general wave parameter values. First, four or five wave sources are needed. The wave centers should be well distributed around the scene. The wavelengths should vary amongst the source a good amount (some should be five or six times the wavelength of other sources). Not much damping should be applied (values from 1.0 down to 0.95 perhaps). Define a wood texture d BCOLOR GCOLOR RCOLOR THICKSCALE RINGSCALE TURBULENCE SQUEEZE You can define up to ten wood textures per scene. This texture relies on your having defined at least one wave source, just like for the marble textures listed above. In fact, at this time wood is modelled very similarly to marble, except that where marble consists of parallel layers of base material, wood consists of concentric cylinders of base material (aligned along the Y axis). The RINGSCALE parameter is analogous to XSCALE for marble; TURBULENCE and SQUEEZE are the same. THICKSCALE basically controls how faint or strong the grain is rendered; values above 1.0 enhance the grain; values less than 1.0 subdue the grain. Set the eye (camera) view parameters e XPOS YPOS ZPOS XVIEW YVIEW ZVIEW XUP YUP ZUP First triple sets the position of the eyepoint. Second triple defines the direction (relative to that point) that the eye will look along to define what is visible. The length of this vector determines the "wide-andle vs. telephoto" effect. To guage what different lengths mean, at the tip of the VIEW vector the screen is projected as if it were 256 units horizontally by 170 units vertically. Thus the magnitude of the numbers you choose for XYZ points interact with the view vector length to determine the cone of visibility. The third triple is the direction you want to be "up"; usually 0 1 0 is what you want. Define a directional light source l BLUE GREEN RED XDIR YDIR ZDIR The first triple is the color and intesity of the light (1 1 1 would be bright white; 0.5 0 0.5 would be dim magenta). The second triple is the direction from which the light is comming. For example 1 0 0 would mean the light is comming in straight along the X axis (from positive to negative). You can have at most 100 light sources per scene (many light sources sloooows things down -- two is reasonable!). Define a spherical light source l BLUE GREEN RED XCENTER YCENTER ZCENTER DISTANCESCALE RADIUS The first triple is the color and base intensity of the light, just as for directional light sources. The second triple is the XYZ coordionate of the center of the spherical light source; it can be anywhere inside or outside of the visible scene. (Note that if the center is within the scene, it is not a visible object per-se. For example, if you wanted a lightbulb, you would place the spherical light source where you wanted it, and also place a transparent sphere at the same coordinates and with the same radius.) The DISTANCESCALE relates to the inverse-square law with which the brightness of the light diminishes within the scene. To explain how to set a value for DISTSCALE, consider the following example. Say you wanted a full-intensity white lightbulb (i.e. its nominal BGR values would be 1 1 1) to shine onto a table. If the table were, say, 37 units of distance from the light coordinate, then you'd want to set DISTSCALE to 37 in order that the table would be fully illuminated. Thus, objects closer to the light that 37 would appear very bright (indeed, probably "overexposed") while objects farther than 37 units from the light would become increasingly dimly lit. RADIUS is the radius of the light emitting sphere; 0.0 would be a point light source. (Note that point light sources are faster to compute.) Also note that non-zero radius light sources cast penumbral shadows, though to be effective you will need to increase the antialias parameters defined by the "A" command. Now for the actual objects that compose a scene. You can about thousand objects max per scene. All objects have the same basic properties available to them. Specifically, the first portion of the command line for any object starts with: @ TEX FUZZ MIRROR IDX TRA_B TRA_G TRA_R AMB_B AMB_G AMB_R DIF_B DIF_G DIF_R "@" is the object command character (s,q,x,t,r). TEX is an integer value that specified what texture function should be applied to this object. Value 0 means no texture (plain, boring evenly colored flat surface). Positive values select from among the supported texture functions, as follows: Value Texture function ----- ---------------- 1: Y axis color gradiation Compute the color at each point on the surface as a function of the point's Y coordinate. Starting at Y=0, the color belnds from red to blue to green and back to red at Y=20. The colors repeat evern 20 units in Y. 3: Mottled diffuse The brightness of the surface of the object varies to form a mottled pattern. This texture requires some wave sources to be defined. 4: Wavy surface The surface will be rendered as being criss-crossed by overlapping waves. If reflectivity is turned on for the object, the reflections will be rippled, etc. 5: Brick pattern The object will be rendered as if it were carved out of bricks. The brick size is currently hardwired to be height=3.0, width=8.0, depth=4.0, mortar thickness=0.5. The color of the bricks is determined by the diffuse coefficients for the object; the color of the mortar is hardwired at BLUE=0.8, GREEN=0.85, RED=0.99. The bricks are aligned with the coordinate system. 10..19: Single Wave This is like texture 4, except that the surface is rippled by only one wave (rather than all of them with texture 4). Texture 10 means use the first wave, texture 11 means use the second wave, etc. up to 19 for the tenth wave. 20..29: Marble Render the object as if it were carved out of marble. The marble texture chosen depends on the texture number: texture 20 uses the first marble defined, texture 21 uses the second marble defined, etc. 40..49: Wood Render the object as if it were carved out of wood. The wood texture chosen depends on the texture number: texture 20 uses the first wood defined, texture 21 uses the second wood defined, etc. 50..59: Checkered Color the surface of the object according the the chosen checkerboard texture. Texture 50 uses the first defined checker pattern, etc. 60..69: Fractal This isn't a texture per se (in so far as most other textures operate by changing the color of surface points of the object). This texture determines what fractal surface contours should be applied to this object. This texture type may only be specified for object type X (fractal objects). Texture 6 uses the first defined fractal type, etc. 70..79: Smooth blend Render the surface of the object as a blend between the objects normal diffuse color, and the specified blend texture color. Texture 70 uses the first defined blend texture, etc. 80..89: Snow Color the surface of the object by applying the chosen snowfall texture. Texture 80 uses the first defined snow texture, etc. FUZZ is a pseudo-texture factor 0 to 1 that applies a random fuzz to the surface of the object. This can be used in a number of ways: to model soft surfaces like tennis balls; to form imperfectly reflecting mirrors, to form translucent (etched) glass, etc. MIRROR is a 0 to 1 value where 0 means no specular and mirror reflection, and 1 means 100% specular & mirror reflection. IDX is the index of refraction for the object. This is only relevant if the transparency for the object is non-zero. TRA_B, _G, _R is the transparency of the object in each color band. 0 means opaque, 1 means 100% transparent. AMB_B, _G, _R is the ambient light value for the object, 0 to 1. 0 means no pseudo-ambient light, 1 means VERY strong ambient light (generally not useful so strong -- washes the object out). DIF_B, _G, _R is the diffuse reflection values 0 to 1 for the object in the color bands. For example, glass has virtually zero diffuse reflection, while chaulk has very high (near 1) diffuse reflection. The diffuse coefficients determine the color of the object (in conjunction with the color of the light sources). From the above, notice that non-rational objects can be created. For example, a ball that is 100% transparent AND 100% reflective. Now onto each object. The parameters below FOLLOW (appear to the right of) all of the above property parameters. s CENTERX CENTERY CENTERZ RADIUS Sphere. Self-explanetory. q POSX POSY POSZ VE_X VE_Y VE_Z VP_X VP_Y VP_Z Parallelogram. The position triple defines a corner of the parallelogram. The second and third triple are two vectors that define the two sides of the object adjacent to and relative to the defining point. Here's the hard part: the order of the two vectors matters. To try to put it simply, the VE vector is the one on the left when viewed from "above," and the VP vector is the one on the right. In another way, the VP vector is clockwise from the VE vector. If the two vectors are reversed, the object will appear invisble. So you may have to experiment by reversing them. Note that the two vectors do not have to be orthogonal. t POSX POSY POSZ VE_X VE_Y VE_Z VP_X VP_Y VP_Z Triangle. Same as for a parallelegram, except that the VE, VP vectors define the two sides of the triangle. x POSX POSY POSZ POS1X POS1Y POS1Z POS2X POS2Y POS2Z Fractal. This is very much like a triangle, except that whereas the second and third set of XYZ values for triangles are relative to the base position of the triangle, for a fractal object all three XYZ triples are absolute object space positions. r CENTERX CENTERY CENTERZ VE_X VE_Y VE_Z VP_X VP_Y VP_Z MINRAD MAXRAD Ring (or annullus). Rings are sort of like parallelograms. The first triple defines the center of the ring. The VE and VP triples radiate from that point and define the plane of the ring. It is undefined as to what happens if the two vectors are not orthogonal. MINRAD is the inside radius of the ring (which may be zero, forming a disk); MAXRAD is the outside radius of the ring. The { and } command lines may be placed around any arbitrary set of object command lines. This allows RENDER to do optimized ray tracing by calculating extent spheres around the indicated primitive objects and then checking ray intersections with the extent sphere rather than one-by-one with all the inner objects. Extents may be nested. Source file information ~~~~~~ ~~~~ ~~~~~~~~~~~ Each program is kept in its own source file directory: ray_source/ makefile ray.h - all global definitaions ray.c - main module of ray tracer val.c - current intensity value of an object hit.c - calculate if an object gets hit by a ray tex.c - calculate the texture of an object ext.c - handle extents ({,} commands) rnd.c - random number table mth.c - perform vector and matrix math fil.c - file i/o int.c - find intersections with objects cal.c - top level object calculations ray2_source/ makefile ray2.c - source for post-processor display_source/ makefile display.c - source for display package