RenderStar Technical Information

Directory Specifications

Renderstar uses three directories. By default RenderStar is installed 
in the directory dcad6\rstar2. 

Directory Contents

bin

The bin directory contains these RenderStar engine, user interface, 
converter program, the interface configuration, color setup, icons, and 
font files:

fli2vga.exe     320x200 VGA fli display
rs2vga.exe      VGA and super-VGA gif/tga display
rs2xxxx.exe     High resolution graphics card gif/tga display (optional)
pcx2gif.exe     pcs to gif converter
tga2gif.exe     tga to gif converter
rs2pcx.exe      gif to pcs converter
rs2tga.exe      gif to tga converter (8 bit)
rs2eps.exe      gif to encapsulated postscript converter
render2.exe     The RenderStar executable
rshell.exe      The interface shell
rshell.mnu      The interface menus
rshell.txt      The interface text strings
rshell.cfg      Window configuration file
rshell.col      Current color setup
original.col    Default color setup
pic1_38.@       The icon file
small.@         The default font file
rmn9_08.@       Larger fonts
rmn9_14.@       Larger fonts
rmn9_19.@       Larger fonts

default

The default directory contains the default render files, as you can see 
in the list below:

render.rc1      The default render file, contains default parameters for 
		the interface and engine.
standard.cmf    The standard color/material file, used when starting a 
		rendering project
standard.mat    The standard material file, used when starting up a 
		rendering project.
standard.mlf    The standard multiple light file, used when starting up a 
		rendering project.
standard.pal    The standard palette file, used when starting a rendering 
		project.
4x64.pal        A 4 color by 64 shade palette.
8x32.pal        An 8 color by 32 shade palette.
16x16.pal       A 16 color by 16 shade palette.
xxxxxxxx.gif    A number of gif texture file examples.
xxxxxxxx.tga    A number of tga texture file examples.

render.rc1 uses these default files when no other files are selected by 
the user. You can use these default files as a base to copy and change; 
making them specific to a project. You can also change the standard.pal 
and standard.cmf files to accommodate the colors you use in DataCAD.

tmp

The tmp directory contains the following temporary file:

wndx.swp        A swap file used by the wndx software of the interface.

File Specifications

Operation Order of RenderStar

RenderStar uses a large number of parameters when rendering an image. 
These render parameters are defined and stored in render files when using 
the graphical RenderShell. You can edit render files from outside RenderStar, 
as all render files are in ASCII format. Editing the render files from 
outside the RenderShell can have some advantages, for instance:

With the RenderShell only a fixed number of viewports can be set which to 
render in one rendering sequence. When editing the render files from 
outside the shell, you can work with an unlimited number of viewports and 
change settings for shadow, materials or lights between different views. 
In this way, you can create animations in which lights dim or materials 
change color.

You can create render files with macros or routines that operate within a 
CAD package.

This section describes the processing order of RenderStar, and specifies 
the file format of the different render files.

RenderStar (render.exe) generates images using: 

	The model files (VOL files); the VOL files are created after 
	converting a model file, for instance a DXF file.
	
	A number of system parameters such as the maximum number of planes 
	(faces) that can be processed, the directory where the files can 
	be found and the directory where the generated image and animation 
	files have to be saved, the resolution at which the images have to 
	be rendered, etc.

	The parameters for creating the special effects, such as color, 
	material textures, light, shadow, etc.

	The viewports.

The model files are created in a CAD program. All other parameters are 
stored in the render files. Render files can be edited using any ASCII 
text editor. 

The Render Files 

RC1     The Render Command File is the file that controls RenderStar. 
	Every project has its own RC1. The model converter generates both 
	an RC1 and a VOL file, when converting the model. 

	All parameters necessary for RenderStar can be stored in the RC1. 
	The different information types are usually stored in different 
	file types for convenience. All parameters defining the color 
	palette are stored in the color palette file with extension 
	.pal, all material information is stored in the MAT file, and 
	all light sources are stored in the MLF multiple light file. 
	The RC1 contains the names of the palette, light, and material 
	files to use. 

MAT     The material file contains the material definitions. 

PAL     The palette file defines the color palette. 

MLF     The multiple light file defines the types of the light sources, 
	and their co-ordinates and intensities.

CMF     The color material file defines which materials and colors are 
	used for which layers, or for which colors, from the CAD model. 

Default Values

Default values are defined in the default files: render.rc1, standard.mat, 
standard.pal, standard.cmf, and standard.mlf, which all reside in the 
default directory.

The render.rc1 file contains a number of default values and pointers to 
the other standard files (mat, pal, cmf, and mlf). The project.rc1 file 
defines which models to render, and which views to use. project.rc1 can 
also change some of the standard values set in the render.rc1 file.

The last parameter values that were read by RenderStar are used. In this 
way default values from the render.rc1 file can be overwritten by the 
latest values used in the project.rc1 or pal, mat, cmf, and mlf files 
that are created for this project. You can create a project.rc1 that 
only describes which model files to render, and which views to use. 
All other effects are set by the render.rc1 file. When using special 
effects, specify only those effects that are different from the effects 
set in the render.rc1 file.

Render Command File: RC1

The Render Command file controls the rendering process. It contains; 

Parameters      Resolution information, output file type, directory 
		information, names of all model files, and switches that 
		specify the use of effects.

Other render information
		Name and directory for the palette, multiple light, 
		material, and color material files.

Viewports       One or more viewports that define the zoom scale, the 
		perspective distance, the viewpoint and the target point 
		for each view.

RC1 File Format

RC1 files have the following structure:

fileID + (n x Fieldline) + ViewportID + (n x Fieldline) + 'end'

Use the following definitions:

FileID          "RenderStar-2"
FieldLine       Field FieldSep values (CommentChar Comment) EOL
Field           FieldName_FieldID
FieldSep        ':'
values          value valsep value ... value
valsep          ' '
EOL             EOL or CommentChar
CommentChar     '#'
Comment         Chars until EOL
ViewportID      "Viewports"

Valid Field IDs

FieldID         Meaning         Range/Maximum
_dir            a directory     8 chars
_ext            filename ext    3 chars
_file           a filename      8 chars
_files          filename filename ... filename  
				Total 120 chars
_str            a string until eol      
				80 chars (spaces allowed)
_mode           on or off       NA
_type           any set of strings      
				80 chars
_int(n)         n x integers    -32,786 to 32,767
_lint(n)        n x long integers       
				-2,147,483,648 to 2,147,483,647
_float(n)       n x floats      +/- 8.43e-37 to +/- 3.37e38

Shell Variables

You can define the following fields in the RC1:

Field           Format          Meaning
maxvports_int1  number          Viewports (for interface only)
maxlights_int   number          Maximum light sources
maxbitmaps_int1 number          Maximum texture bitmaps
maxdata_int1    number          Maximum datafiles
maxmats_int1    number          Maximum materials

With these settings you can configure RenderStar to use the available 
memory in a way most suitable to your specific needs. All allocations 
are performed dynamically. When trying to allocate more memory than is 
free, an error message appears to let you lower the total amount of 
allocated memory.

Field           Format          Meaning
maxplane_lintl  maxplanes       To set maxplanes
maxobject       maxobjects      To set maxobjects

A _lint can have a range of up to 2,142,483,647, but the total amount of 
polygons is linked to available memory. 1MB allows for 6000 to 10,000 
polygons, depending on how the model is created. On DOS versions, you are 
usually limited to about 100,000 - 150,000 polygons.

Field           Format          Meaning
bios_int3       bm x y          biosmod (in HEX) and xy-rez

VGA mode 12h (640 x 480 x 16) is fully supported by RenderStar.

Field           Format          Meaning
convert_file :  abc             Name of converter
convert_str :   -x -y           Default converter options
convert_ext :   ext             The extension of the file to convert 

You can select different converter styles by setting the converter options. 
convert_ext is the extension which signals that a conversion must happen. 
Executing rs2 test, for instance, when only test.xxx is in the current 
directory and convert_ext = 'xxx', starts up the conversion.

Field           Format          Meaning
render_file :   abc             Name of render
render_str :    -x -y           Default render options
render_type :   main / fullmem  To signal shell memory use
	main    Keep shell in memory because the engine does not need full 
		DOS memory (for instance if the engine runs on a another 
		processor like the i860 or uses a pc-nfs call to run the 
		engine on the network server), and needs less than 360KB 
		to run.
	fullmem Use all DOS memory and restart shell after rendering.

The render_file can be a batch file. The current directory is restored by 
the shell on returning.

Field           Format          Meaning
show_file :     abc             Name of default image shower program
show_str :      -x -y           Default image shower options
show_type :     main / second / fullmem 
				To signal shell
	main    Keeps shell in memory; the display needs less than 360KB 
		to run (for instance rs2svga, fli2vga). 
	second  Same as main but rendering appears on a second monitor. 
		The shell surface does not have to be rebuilt. This is 
		needed for some high resolution display cards.
	fullmem Use all DOS memory, and restart the shell after displaying 
		the image.
showvga_file :  abc             Name of VGA image shower
showvga_str :   -x -y           VGA image shower options
showvga_type :  main / second / fullmem 
				To signal shell memory use
play_file :     abc             Name of default player
play_str :      -x -y           Default player options
prog1_file :    name or dir\name.ext
				file1 to execute
prog1_type :    main / fullmem  How to call program1
prog1_str :     name            Name to put in menu bar

showvga_file can be a batch file. The current directory is restored by the 
shell on returning.

For prog2 to prog8 the same as above. Progx_type works like render_type. 
Progx_file can be a batch file.

These are the eight slots for external programs. They can be used to jump 
to other programs. When accessing a protected mode application set 'fullmem'. 
For DOS only applications you can use 'main'. 

Field           Format          Meaning
hotkey_file :   abc             name of program to react to hot key

Ctrl-X executes this program from the shell. This can be used for VGA 
screen grabbers for documentation purposes. For developers and translators 
vga2gif.exe is available from RenderStar Technology.

RC1 Header Variables

Consult the documentation in the reference manual on the operation of the 
following fields:

Field           Format          Meaning
info_str :      abc [ab] ab     Any comment to eol 
scr_str :       abc             Echo string to screen
data_files :    abc abc ... abc         
				Data files to load 
output_ext :    gif / fli / tga Output file type 
output_type :   8bit / 24bit    Generation type
output_dir :    abc             Directory for output
output_file :   abc             Name of output file series 
	If output_file = 'no_file' don't save an image file.
gds_float1 :    scale           Global data scale
sun_float3 :    x y z           Direction of sun
rez_int2 :      across down     Set screen resolution
bgr_int1 :      b               Background gradient color
efx_mode :      on / off        Special effects
mlf_mode :      on / off        Lights
mlfcast_mode :  on / off        Lights shadow casting
mat_mode :      on / off        Materials
sdw_type :      no / make / use Shadow buffer status
smooth_mode :   on / off        Smooth shading
bgr_mode :      on / off        Background gradient
backcl_mode :   on / off        Back plane culling 
depshd_mode :   on / off        Depth shading 
aalias_mode :   on / off        Anti-alias (only in 24 bit/TGA)
smalign_type :  keep / align    Keep or align polygon normals (only for
				smooth shading)
sdw2_type :     int / ext       Shadow for interior or exterior
sdw_file :      abc             Name of shadow buffer 
mlf_file :      abc             Name of multiple light file
mat_file :      abc             Name of material file 
cmf_file :      abc             Name of col/mat file 
pal_file :      abc             Name of palette file 
	If abc = "no_file" don't load a xxx_file.

Material Templates

Field           Format          Meaning
def_str :       {name} (any FieldID's)  
				Defines a template
{name}_struct : According to struct def         
				Uses a template

Viewports

Field           Format          Meaning
vport_float8 :  p s cx cy cz tx ty tz   
				Standard viewport 
				p = perspective distance
				s = scale value
				cx, cy, cz = observer location
				tx, ty, tz = target location

The render.rc1

The render.rc1 contains a number of default values, which you can change 
and use for each project. This is not possible for the 'standard material 
structure definitions'. These entries define the way in which the standard 
material structures are defined in the MAT files and may not be changed.

render.rc1 file default values:
Field           Parameter       Meaning 
RenderStar-2    
info_str        : -------- VGA screen mode and rez --------------------------
bios_int3        12 640 480     # Biosmode (in HEX) xy-rez
info_str        : --------- Links to other RenderStar programs --------------
convert_file    : convert.exe   # Name of converter
convert_str     : -d2           # Convert opts (-d = dxf) (-2 = R*2)
convert_ext     : dxf           # The extension to convert on
render_file     : render2.exe   # Name of render engine
render_str      :               # Render options
render_type     : fullmem       # How to call
show_file       : rs2svga.exe   # Default display utility
show_str        : -n            # Default display options
show_type       : main          # Default image display
showvga_file    : rs2svga.exe   # Name of VGA
showvga_str     : -nV0          # VGA options
showvga_type    : main          # Where image goes
play_file       : fli2vga.exe   # Name of player
play_str        :               # Player options
info_str        : --------- Limits on maximum amounts ------------------------
maxplane_lint1  : 32000         # Maximum planes (polygons/faces)
maxobject_lint1 : 32000         # Maximum objects (for convert only)
maxvports_int1  : 500           # Maximum viewports (for shell only)
maxlights_int   : 50            # Maximum light sources
maxbitmaps_int1 : 100           # Maximum texture bitmaps
maxmats_int1    : 250           # Maximum materials
maxdata_int1    : 50            # Maximum data files
info_str        : --------- External programs --------------------------------
hotkey_file     : \rstar2\bin\vga2gif   
				# Name of VGA screen grabber
prog1_str       : MS-DOS        # Name for menu bar 1
prog1_file      : command       # File to execute
prog1_type      : main          # How to call
prog2_str       : empty         # Name for menu bar 2
prog2_file      : empty         # File to execute
prog2_type      : empty         # How to call
prog3_str       : empty         # Name for menu bar 3
prog3_file      : empty         # File to execute
prog3_type      : empty         # How to call
prog4_str       : empty         # Name for menu bar 4
prog4_file      : empty         # File to execute
prog4_type      : empty         # How to call
prog5_str       : empty         # Name for menu bar 5
prog5_file      : empty         # File to execute
prog5_type      : empty         # How to call
prog6_str       : empty         # Name for menu bar 6
prog6_file      : empty         # File to execute
prog6_type      : empty         # How to call
prog7_str       : empty         # Name for menu bar 7
prog7_file      : empty         # File to execute
prog7_type      : empty         # How to call
prog8_str       : empty         # Name for menu bar 8
prog8_file      : empty         # File to execute
prog8_type      : empty         # How to call
info_str        : --------- Pre-set resolutions ------------------------------  
rez1_int2       : 320 200       # Standard VGA and fli resolution
rez2_int2       : 640 480       
rez3_int2       : 739 578       # pal video resolution 
rez4_int2       : 800 600       
rez5_int2       : 1024 683      # 3:2 slide frame aspect ratio rez 1
rez6_int2       : 1024 768      
rez7_int2       : 1280 1024     
rez8_int2       : 2048 1366     # 3:2 slide frame aspect ratio rez 2
rez9_int2       : 4096 2732     # 3:2 slide frame aspect ratio rez 3
info_str        : --------- Default RenderStar parameter ---------------------
rez_int2        : 640 480       # Default resolution
output_dir      : .\            # Dir to put output files in
output_ext      : .gif          # GIF / FLI / TGA
output_type     : 8bit          # 8 bit / 24 bit
output_file     : temp          # Default name of output file
sun_float3      : 1 2 3         # Default sun direction
bgr_mode        : off           # Back gradient on / off
efx_mode        : off           # Effects on / off
mlf_mode        : off           # Multiple lights on / off
mat_mode        : off           # Materials on / off
depshd_mode     : off           # Depth shade on / off
backcl_mode     : off           # Backplane culling on / off
mlfcast_mode    : off           # Shadow casting on / off
aalias_mode     : off           # Anti-alias on / off
smooth_mode     : off           # Smooth shading
smalign_type    : keep          # Keep polygon normal alignment
sdw_type        : no            # Shadow file no / make / use
sdw2_type       : ext           # Shadow usage int / ext
sdw_file        : temp          # Default shadow filename
cmf_file        : standard      # Default col-mat file
pal_file        : standard      # Default palette file
mat_file        : standard      # Default material file
mlf_file        : standard      # Default light file
info_str        : ------- Standard material structure definitions ------------
def_str         : textmap int1 file
def_str         : none int1 float2
def_str         : block int1 float2 int2 float1
def_str         : stone int1 float2 float1
def_str         : tile int1 float2 int2 float2  
def_str         : stripe int1 float2 float2     
def_str         : dens int1 float2 int1 
def_str         : high int1 float2 int1 
def_str         : mandel int1 float5    
def_str         : rand int1 float2 int1 float1  
def_str         : rhigh int1 float2 int1 float1 int1    
def_str         : brick int1 float2 int5 float2 
def_str         : wood int1 float3 int1 float1  
def_str         : gbmt int1 float2 int8 float1 int5 float3      
info_str        : ------- The end --------------------------------------------  
end

Bitmap Texture File Search Strategy

When a textmap_struct is found a search is made for the corresponding bitmap. 
A bitmap may come from any directory. The bitmap can be a gif or tga file. 
The user selects the place and the name in the RenderShell after which the 
following is done:

textmap_struct: name

if no directory in name: 
	> search project directory for name.gif
	> search project directory for name.tga
	> search default directory for name.gif
	> search default directory for name.tga
if no file found report 'Missing file [name.gif/tga]'
if directory in name (example name = '\imagecel\building\brick\brick-1a')
	> search for name.gif
	> search for name.tga
if no file found report "Missing file [name.gif/tga]"

Redefinable Parameters

The viewport stream consists of two parts: the static allocations before 
"Viewports" and the actual stream itself. All memory allocations are fixed 
when "Viewports" is encountered in the rc1 file. This means that all elements 
which need memory space, such as textures and shadow buffers, must be defined 
before "Viewports" in the rc1 file. One can load extra bitmaps during the 
stream (between views) but they may not fit anymore. It is possible, however, 
to reload shadow buffers if buffers have the same or a lower resolution than 
the first buffer loaded.

Smooth shading is static and can't be redefined, or switched on or off. 
The other parameters documented below can be changed, switched or redefined 
during the stream:

Element         Field           Use to
Comments        info_str        Document the rc1 file
		scr_str         Repeat information on the screen
Output file names       
		output_dir      Change output file directory
		output_file     Change output file name
Sun position    sun_float3      Redefine sun location
Background gradient     
		bgr_int1        Change palette entry used for background.
		bgr_mode        Switch background gradient
Mode toggles    efx_mode        Switch effects modes on or off
		mlf_mode        
		mat_mode        
		backcl_mode     
		depshd_mode     
		mlfcast_mode    
Input files     mlf_file        Reload a file
		mat_file        New bitmaps may not fit
		cmf_file        
		pal_file        
		sdw_file        
CMF values      cmf_int3        Add or redefine cmf entries 
		cmfs_int3       
		cmfoff_int1     Switch all off, except for one
PAL values      pal_int3        Add or redefine palette colors
		palx_int10      
MLF values      mlf_float4      Add or redefine light sources
		mlfs_float9     
		mlfl_float8     
		mlfdim_float1   Dim all light sources
MAT values      none_struct     Add or redefine materials 
		block_struct    
		stone_struct    
		tile_struct     
		stripe_struct   
		dens_struct     
		high_struct     
		mandel_struct   
		rand_struct     
		rhigh_struct    
		brick_struct    
		wood_struct     
		gbmt_struct     
		textmap_struct  may not fit
External programs       
		exec_str        Execute a DOS program (only in stream)

Executing a DOS program from RenderStar is only possible when the engine 
is configured to leave a part of DOS memory free. This can be done using 
cfig386.exe. Use the following command:

cfig386 \rstar2\bin\render2.exe -MAXREAL 32000

This leaves as much low memory free as possible. Usually, between 
360 - 400KB memory under 1MB is available to run a DOS program. At the 
same time, the engine and all parameters, will remain in high memory.

cfig386 \rstar2\bin\render2.exe -clear

This command makes the engine use all memory again.

Parameter Files

The RC1 can point to settings in other render files. The color palette 
information, the material information, the light sources, and the color 
material indices can be defined in other render files. The render.rc1 
points alternately to the standard.pal, standard.mat, standard.cmf, and 
the standard.mlf. These values can be overwritten in the project.rc1 by 
pointers to self-defined pal, mat, cmf, and mlf files. When generating 
these files use the file format described above. This section describes 
the fields that can be defined in the different render files, and defines 
the values of the standard files. 

Color Material File: CMF 

The following parameters can be specified in the CMF files: 

Field           Format          Meaning 
cmf_str :       index           description
cmf_int3 :      index color-ref material-ref    
				standard cmf entry
cmfs_int3 :     index color-ref material-ref    
				smooth shaded cmf entry
cmfoff_int1 :   index           set all materials except index to '0' 

	index           Points to the color-, or layer- number of the 
			CAD model
	color-ref       Points to the index from the PAL
	material-ref    Points to the index from the MAT
	cmfoff_int1     Makes a parameter setting for a layer or color 
			index separately, by turning off all other layers 
			or colors. This is done by setting the CMF index 
			to material 0. This can save a lot of time in the 
			phase where a correct material is being defined for 
			a limited set of faces. This parameter can be set 
			in the RC1 as well.

The following CMF files can be found in the directory site-3d.

site-3d.cmf

RenderStar-2
cmf_str : 1 zero
cmf_int3 : 1 0 0
cmf_str : 2 road
cmfs_int3: 2 7 6
cmf_str : 3 retwall
cmf_int3 : 3 7 4
cmf_str : 4 door
cmf_int3 : 4 0 0
cmf_str : 5 wall
cmf_int3 : 5 0 0
cmf_str : 6 barfloor
cmf_int3 : 6 4 1
cmf_str : 7 fireplace
cmf_int3 : 7 1 3
cmf_str : 8 roof
cmf_int3 : 8 2 6
cmf_str : 9 deck
cmf_int3 : 9 4 5
cmf_str : 10 trellis
cmf_int3 : 10 5 1
cmf_str : 11 door
cmf_int3 : 11 1 3
cmf_str : 12 porch
cmf_int3 : 12 5 1
cmf_str : 13 land
cmfs_int3: 13 3 10
cmf_str : 14 walls
cmf_int3 : 14 7 4
end

Palette: PAL 

The following parameters can be defined in the PAL files: 

Field           Format          Meaning 
palshd_int1 :   max_shades      number of shades
palbgr_int2 :   pal index shade for background
pal_int3 :      index hue sat   standard pal entry
palx_int10 :    i H1 L1 S1 H2 L2 S2 H3 L3 S3 
				extended pal entry
	max-shades      Defines the number of steps in which a color 
			transforms from light to dark. Possible values 
			are all values between 1 - 256.
			The number of shades also defines the number of 
			palette colors, as the number of shades times the 
			number of colors always equals 256 or less.
	palindex        Points to the index number of a color in the PAL.
	shade           Points to a shade-value within the range of 
			max_shades.
	index           Sets the index for the defined color values. 
	hue             Sets the Hue (color number that points to a value 
			on the color circle 0-360)
	saturation      Sets the Saturation (0 - 100 %)
	lightness       Sets the Lightness (0-511)
	pal_int3        This standard pal entry generates the lightness values using the defined Hue and Saturation values.
	palx_int10      This extended-pal-entry allows you to define the lightness factors yourself. The three values (H1 t/m H3 etc.) generate a color transformation between three defined colors. In this way a color can transform from apple green, through blue-green, to light blue.

The following PAL file is available in the default directory:

4x64.pal

RenderStar-2
palshd_int1: 64
palbgr_int2: 3 32
pal_int3 : 1 0 50
pal_int3 : 2 120 50
pal_int3 : 3 240 50
pal_int3 : 4 0 0
end

Material File: MAT

A material file defines the parameters for the available materials. Both 
the procedural textures and the bitmap textures can be defined in the 
material file. The available fields are: 

Field           Format          Meaning 
mat_str :       index           description
none_struct :   int1 float2     RenderStar1 textures
block_struct :  int1 float2 int2 float1 
stone_struct :  int1 float2 float1 
tile_struct :   int1 float2 int2 float2 
stripe_struct : int1 float2 float2 
dens_struct :   int1 float2 int1 
high_struct :   int1 float2 int1 
mandel_struct : int1 float5 
rand_struct :   int1 float2 int1 float1 
rhigh_struct :  int1 float2 int1 float1 int1 
brick_struct :  int1 float2 int5 float2         
wood_struct :   int1 float3 int1 float1         
gbmt_struct :   int1 float2 int8 float1 int5 float3     
				RenderStar2 textures
textmap_struct :        
		int1 file       load texture map for index 
	
	none_struct - wood_struct 
			These standard material-structures are defined in the 
			render.rc1 file. 
	
	int1            This first integer in the standard material structures 
			sets the index for the material definitions.
	
	gbmt_struct     These parameters (Generic BitMap Texture) define the 
			values for the bitmap textures. 
	
	int1            The first integer of gbmt_struct sets the index of 
			the bitmap to be used, which is specified in 
			textmap_struct.
	
	textmap_struct
	
	int1            The first parameter of textmap_struct sets the index 
			for the bitmap to be used, and the name of this 
			bitmap must be specified at the file parameter. 
			Reference to these files, in conjunction with specifying 
			a number of gmbt_struct parameters makes it possible to 
			use the bitmap library. The bitmaps to be used have to 
			be specified at the end of the file. RenderStar reads 
			in only those bitmaps which are actually used.

The file newtext.mat in the dcad6\rstar2\default directory contains a 
number of possible bitmap structures and their necessary parameters.

Material Parameters for Bitmaps: GBMT_STRUCT

For bitmap materials 17 parameters, the index, the sunlight factor, and 
the multiple light factor have to be specified as you see below:

i       Material index

sl      Sunlight factor

ml      Multiple-light factor

p1      Points to the index of the under textmap_struct defined bitmaps.

p2      Size of the bitmap pixel in object space. This value needs to be 
	set in CAD units.

p3      Method of use of the bitmap offset matrix
	1:      Modulates the lightness (shade) of the pixels 
	2:      Modulates the palette color of the pixels 
		p6 (choice between single or dual color system) needs to 
		be set to 0 (uses complete color range [0..255] of the 
		bitmap in the single system.) 

p4      Several projection types, that specify how the texture is projected 
	onto the faces, are available: 
	1:      Locked to orientation. The world origin is projected onto 
		the polygon defining the point at which the origin of the 
		texture is projected. From the origin onwards, the texture 
		is 'tiled' over the face. The front and back of a face is 
		defined by the direction of the face normal. The up \ down 
		direction of the texture is defined by the direction of 
		the projection of the Z-axis on the face, unless the face 
		direction is perpendicular to the Z-axis. In that situation, 
		the direction of the projection of the Y-axis on the face 
		is used. This means that faces with an identical normal shows 
		an identical texture. The texture will flow continuously 
		over the different faces with identical orientation. 
		The texture is discontinuous when it is projected onto 
		faces which differ in orientation. This option can be used 
		for most uni-directional textures such as stone and marble 
		on flat surfaces.
	2:      Locked to boundary. The origin of the bitmap (upper left 
		corner) is projected on the upper left corner of each face. 
		The texture will not flow continuously between any touching 
		faces regardless of the orientation of the faces, as the 
		origin of the bitmap is defined for each separately. This 
		projection type is suitable for any object which will repeat 
		in the model such as trees and people, and for wall-window 
		bitmaps. The bitmap is projected in such a way that text 
		is always readable; texts are not mirrored. Textures created 
		with this projection can be used for animation. Choose with 
		this projection type for option [1] (tile) parameter p5 for 
		the best result. 
	3:      Half sphere on XY-plane. The texture is projected onto 
		the faces using a sphere in the XY-direction. The center 
		of the projection sphere can be defined by setting its 
		coordinates in the Origin box in the Edit Material menu. 
		The texture is generated as follows. The bitmap is 
		projected onto a sphere around the texture origin. For 
		a face to be textured with this bitmap, a vector is 
		calculated from every point on the face to the texture 
		origin to determine the intersection point with the 
		projection sphere. Each point on the face will obtain 
		the shade of the point at which it intersects the sphere. 
		Correct placement of the texture origin causes the texture 
		to flow continuously over curved objects. This projection 
		type is suitable for sets of polygons with a predominantly 
		horizontal direction. This projection type is suitable for 
		generating unidirectional materials such as stone, marble 
		and water on large sets of faces. The polygons do not have 
		to be connected, by being part of the same object or 
		polymesh; the polygons only have to share the same layer 
		or color. Check for placing the projection origin the 
		description on parameters p15, p16, and p17.
	4:      Half sphere on YZ-plane. This projection type is similar 
		to type number 4, with the exception that the projection 
		sphere is placed in the YZ-plane. Check for placing the 
		projection origin the description on parameters p15, p16, 
		and p17.
	5:      Half sphere on XZ-plane. This projection type is similar 
		to type number 4 and 5, except that the projection sphere 
		is now placed in the XZ-plane. Check for placing the 
		projection origin the description on parameters p15, p16, 
		and p17.
	6:      Cylinder along X-axis. The texture is projected onto the 
		faces using a cylinder in the X-direction. The center of 
		the projection sphere can be defined by setting its 
		coordinates in the Origin box in the Edit Material menu. 
		The texture is generated as follows. The bitmap is projected 
		onto a cylinder centered around the texture origin and 
		parallel to the X-axis. For a face to be textured with 
		this bitmap, a vector is calculated from every point on 
		the face to the texture origin to determine the intersection 
		point with the projection cylinder. Each point on the face 
		will obtain the shade of the point at which it intersects 
		the cylinder. Check for placing the projection origin the 
		description on parameters p15, p16, and p17.
	7:      Cylinder along Y-axis. This projection type is similar to 
		number 6, except the projection cylinder is now parallel 
		to the Y-axis. Check for placing the projection origin the 
		description on parameters p15, p16, and p17.
	8:      Cylinder along Z-axis. This projection type is similar to 
		number 6 and 7, except the projection cylinder is now 
		parallel to the Z-axis. Check for placing the projection 
		origin the description on parameters p15, p16, and p17.
	9:      From XY-plane. The texture is placed in the X,Y-plane 
		and is projected vertically onto the faces in the model. 
		The bitmap flows continuously over faces with a slightly 
		different orientation. This projection type is not suitable 
		for vertical or almost vertical faces. Check for placing 
		the projection origin the description on parameters p15, 
		p16, and p17.
	10:     Random lock. This projection type is similar to the previous 
		projection type except the origin is not placed in the 
		upper left corner of each face, but is placed in each face 
		at random. In this way repetitive patterns on faces with 
		an identical orientation are avoided. 

p5      Repeat switch
	0:      Does not repeat the texture (the texture is projected onto 
		the face once)
	1:      Repeats the texture on the face, where the starting point 
		of the texture lies on the projected texture origin.

p6      Use of 'color 0 option'
	0:      Uses the complete color scene within the single system. 
		Within the single color system one color from the 
		RenderStar color palette is used for the bitmap, unless 
		color modulation is used. A bitmap is a set of values from 
		0 to 255 for each position in the map. Lower values 
		generate lighter shades in the texture, and higher values 
		generate darker shades. 
	1:      Uses the dual color system. Within the dual color system 
		the color [0] and the colors [1-255] can be accessed 
		separately. The values for these colors are to be set 
		under parameter p7 and p8. Set the next parameters when 
		you work with the dual color system (set p6 to 1):

p7      Specular factor for color [0] of the bitmap.
	0:      No use of specular lights-effect for color [0] of the bitmap.
	1..n:   Use specular lights-effect. The value of this parameter 
		defines the size of the light spot on the texture. Set 
		the value between 0 and 10; the higher the value, the 
		smaller the spot. Values between 3 and 6 give good results.

p8      The palette color for color [0] of the bitmap.
	-1:    Use the CMF color for color [0] of the bitmap.
	0:      Color [0] of the bitmap is rendered transparent.
	1..n:   Use a palette color for the bitmap. The value you give 
		refers to the value in the PAL file. Within the dual color 
		system (p6 = 1) the following parameters refer to the 
		values 1 to 255 of the bitmap, within the single color 
		system the following parameters refer to the colors 0 to 
		255 of the bitmap.

p9      Shade Offset
	The value for shade offset determines the contrast between dark 
	and light in the texture

p10     Specular factor
	0:      No use of specular lights effect.
	1..n:   Use specular lights-effect. The value of this parameter 
		defines the size of the light spot on the texture. Set 
		the value between 0 and 10; the higher the value, the 
		smaller the spot. Values between 3 and 6 give good results.

p11     palette color 
	 -1:    Use the palette color from the CMF.
	0:      Render transparent.
	1..n:   Use a palette color for the bitmap. The value you give 
		refers to the value in the PAL file.

p12     Smooth factor
	This factor smooths a bitmap when it appears in the image at a 
	large scale. This value is usually set to 0. When a bitmap appears 
	in the image at a very large scale, one pixel in the bitmap can 
	cover a large numbers of pixels on the screen, which all have the 
	same shade. By increasing the smooth factor the differences in the 
	bitmap are smoothed when generating the texture. The large set of 
	pixels will now obtain slowly changing shades. 

With the next two parameters (p13 and p14) you can define the part of the 
bitmap that you want to use as a texture. These values will overwrite the 
values in the GIF header.

p13     Texture width in number of pixels.

p14     Texture height in number of pixels.

Parameters p15, p16 and p17 allow to specify an origin for the projection 
types in p4[3..9]. This origin defines the point at which the origin of 
the texture is projected.

p15     origin-x

p16     origin-y

p17     origin-z

Newtext.mat

RenderStar-2

info_str        : A set of examples with the new bitmap textures.
info_str        : --------------- Default material -------------------------
mat_str         : 1 normal
none_struct     : 1 1.0 0.0 0
info_str        : --------------- Bitmap examples --------------------------
mat_str         : 2 wood_horizontal
gbmt_struct     : 2 1.0 0.0 1 2 1 1 1 0 0 0 75 0 -1 0 0 0 0 0 0
mat_str         : 3 wood_vertical
gbmt_struct     : 3 1.0 0.0 2 2 1 1 1 0 0 0 75 0 -1 0 0 0 0 0 0
mat_str         : 4 icel_brick-3d
gbmt_struct     : 4 1.0 0.0 3 1 1 1 1 0 0 0 75 0 -1 0 97 66 0 0 0
mat_str         : 5 icel_paver-3e
gbmt_struct     : 5 2.0 0.0 4 1 1 1 1 0 0 0 150 0 -1 0 80 82 0 0 0
mat_str         : 6 random
gbmt_struct     : 6 1.0 0.0 5 3 1 9 1 0 0 0 75 0 -1 3 0 0 0 0 0
mat_str         : 7 cloud
gbmt_struct     : 7 1.0 0.0 6 20 1 1 1 1 0 0 150 0 -1 4 0 0 0 0 0
mat_str         : 8 example_wall/window
gbmt_struct     : 8 1.0 0.0 7 0.2 1 1 1 1 0 3 0 0 -1 0 200 200 0 0 0
mat_str         : 9 transparent
gbmt_struct     : 9 1.0 0.0 8 0.5 1 1 1 1 0 0 50 0 -1 1 200 200 0 0 0
mat_str         : 10 bumps
gbmt_struct     : 10 1.0 0.0 8 2 1 9 1 1 0 -1 100 0 -1 2 0 0 0 0 0
mat_str         : 11 example_alpha_text
gbmt_struct     : 11 1.0 0.0 9 0.2 1 9 1 0 0 0 50 0 -1 0 0 0 0 0 0
info_str        : --------------- Links to texture maps --------------------
textmap_struct  : 1 wood1
textmap_struct  : 2 wood2
textmap_struct  : 3 brick-3d
textmap_struct  : 4 paver-3e
textmap_struct  : 5 random
textmap_struct  : 6 cloud
textmap_struct  : 7 frame
textmap_struct  : 8 bumps
textmap_struct  : 9 test
end

Multiple Light File: MLF

The MLF stores the coordinates for the light sources. The following 
parameters can be specified:

Field           Format                  Meaning 
mlf_float5 :    index int x y z         Standard light source
mlfs_float9 :   index int px py pz dx dy dz     
					a spot 
					p=pos 
					d=direction 
					a=angle
mlfl_float8 :   index int ax ay az bx by bz     
					linear from a to b
mlfdim_float1 :         dim             multiply all ints by dim
	
	mlf_float5      Defines a standard light source. This is a light source shining in all directions.
	mlfs_float9     Defines a spotlight, this is a light source which only shines in a set direction. The angle defines the size of the light bundle.
	mlfl_float8     Defines a linear light source, which can be compared with a fluorescent light. The X,Y,Z coordinates define the direction of the light source. 
	mlfdim_float1   Increases or decreases the intensity of all light sources.
	index           Indexes all light sources. 
	int             Sets the intensity of the light source. The intensity usually lies between 1,000 and 10,000. The effect of a light source depends on the selected materials and the distance to the light source. 
	dim             A factor by which all intensities are multiplied

The rstar2\default contains a standard.mlf. This file contains one light 
source with an intensity of 1,000 placed on the origin of the CAD model.

Standard MLF

RenderStar-2
mlf_float5 : 1 1000 0 0 0
end

Sample MLF

RenderStar-2
mlf_float5 : 1 70000 -1903 1883 500
mlfl_float8 : 2 50000 1855 2131 400 1855 -1869 0
mlfs_float9 : 3 150000 -1576 -1303 700 -76 -803 50 45
end

The Render Engine

The Render Engine Load and Allocation Sequence

A number of allocations are done in the startup process of RenderStar. 
The scheme below documents when and how much memory is allocated. It also 
shows when the different files are loaded. This information can be useful 
for tuning the memory usage or for a better understanding of segmentation 
of the render process.

Action                          Memory load
386 DOS extender is loaded      140KB in real memory
render engine is setup          250KB in protected memory 

sizing memory 
Started with render2 -h gives amount now available.

allocate file buffer            32KB
Default render.rc1 is parsed

The following buffers are allocated:
materials                       maxmats_int * 90 bytes
bitmaps                         maxbitmaps_int1 * 88 bytes
lights                          maxlights_int1 * 66 bytes
datafiles                       maxdata_int1 * 9 bytes

project.rc1 file is parsed up to "Viewports"

polygon read buffers are allocated      10KB
polygon address buffer is allocated     maxplane_int1 * 4 bytes 
polygon datafiles are loaded            polygons found * 100 bytes
cmf, pal, mlf files are loaded
mat file with bitmaps are loaded        bitmaps found * x * y * 1 byte
If smooth shading, extra information is allocated 
when using smooth data                  smooth polygons * 48 bytes
when generating smooth data             smooth polygons * 110 bytes
If shadow is used, shadow buffer is loaded    
					shadow rez x * y * 4 bytes

Image output buffers are allocated
if gif                          22KB
if fli                          65KB
Z and color buffers are segmented depending on amount of memory free. 
Minimal segment size is three scan lines
	if 8 bit                total x * y * 5 bytes
	if 24 bit               total x * y * 7 bytes
The RC1 file is re-entered and for each viewport an image is generated 
until "end" is encountered

Options

In the basic setup no options are used. But when running the engine from 
the command line they can be useful. The engine reads the render.rc1 so 
all setup information is processed before the project rc1 is read.

General options

-m num          Use num KB for dynamic storage for this rendering. This 
		option can be used to limit the amount of memory claimed 
		in virtual memory configurations. Try to use as less swap 
		memory as possible, it will significantly slow down the 
		rendering.
-s              Instead of hour:minutes:seconds time feedback, a xxxx.xx 
		seconds format is used. This is useful for speed 
		comparisons. The time output by the engine is time spent 
		rendering ("Render....") and writing the gif file ("WriteI.").
-r dir          When running the engine with a different default directory 
		this option can be used. For instance, when there are 
		separate default directories for different series of 
		projects. One can also have a local render.rc1 with much 
		the same effect.
-p num          Set MAXPLANES for this rendering.
-x num          Overrule the setting of the x res in the rc1 files.
-y num          Overrule the setting of the y res in the rc1 files. Useful 
		for rendering from batch files.

Debugging the Rendering

-o file         Redirect all screen output to a file.
-t              Trace the input file processing.

These options can be used by developers to check the processing of the 
different input files. All files read-in are parsed and echoed to the screen.

Errors and Warnings

After an error message the program waits for a key and then exitS. After a 
warning the program will wait for key from the user and then continues. In 
a lot of cases getting more memory is also a option.

<num>           Is a number
<dir>           Is a directory
<ext>           Is a three character extension
<filename>      Is a maximum eight character file name

<ext> is not a valid extension.
	An unknown image file extension is used.

Badly formed directory name [<dir>].
	A directory is passed to RenderStar which contains strange 
	(non-ASCII) or control characters.

Can only handle 256 cmf entries.
	More then 256 cmf entries are found.

Can only handle <num> datafiles.
	More data files are found than defined with maxdata_int1 in 
	render.rc1.

Can only handle <num> light sources.
	More light sources are found than defined with maxlights_int1 
	in render.rc1.

Can only handle <num> materials.
	More materials are found than defined with maxmats_int1 in render.rc1.

Can only handle <num> texture maps.
	More texture maps are found than defined with maxbitmaps_int1 in 
	render.rc1.

Can't allocate memory for 3D texture table.
	Not enough memory free to use 3D noise textures.

Cannot open Output-File [<filename.ext>]
Cannot open temporary file [temp.rc1]
Couldn't open file[<filename.ext>] 
Unable to open[<filename.ext>] 
	Can't open the file or the directory to which it must be written 
	doesn't exist. There can also be a file with the same name which 
	has been set to read-only or on a multi-user configuration you don't 
	have the correct privilege to write this file here.

Can't find corresponding [<filename>.pmk] file in [<dir>] or [<dir>].
	When converting RenderStar1 data the pmk file should have the 
	same name as the pal file for the RenderStar-1 to RenderStar-2 
	format converter to find it.

Could not write color lookup table.
Could not write end-of-GIF.
Could not write GIF header information.
Gif file is incomplete.
	The GIF output image file has not been completely written out, 
	for instance because the disk was full.

Couldn't allocate enough memory for output.
	Not enough memory free to output image files.

Couldn't allocate memory for GIF in.
	Not enough memory free to read in gif texture files.

Couldn't open virtual screen 2.
	Not enough memory free to output fli files

Error writing Z-buffer
	The shadow buffer (z-buffer) has not been written out completely, 
	possibly because the disk was full.

File has an invalid header format.
Invalid GIF87a File Format.
This is not a GIF87a file.
	A wrong or invalid file format was encountered during reading a 
	texture map file.

Flic (.fli) extension only with 320 x 200 resolution.
	Only 320 x 200 FLIs are supported.

Missing data file [<filename>]
	The data file could not be found in the current directory.

Missing file [<filename or dir\filename>.gif/tga].
	The bitmap could not be found in the current or in the default 
	directory or in the directory specified

Missing RC1 file [filename>].
	The rc1 filename.rc1 could not be found in the current directory.

Missing Shadow buffer file [filename>].
	Shadow is in use but filename.sdw can not be found in the current 
	directory.

Missing [<filename.ext>] file in [<dir>] or [<dir>]
	The filename.ext can not be found in the current or in the default 
	directory.

Need to render in single-pass for Shadow generation.
	Image segmentation cannot be used during the generation of the 
	shadow buffer. The buffer must fit into memory. Lower the shadow 
	buffer resolution or get more memory.

No (render.rc1) found in [<dir>] or [<dir>]
	No default render.rc1 file was found in the current or default 
	directory. The engine doesn't need this file and will now proceed 
	without it. If this is what you intended you can circumvent this 
	message by using: render2 -r no_file filename.

No FLI support. Generate GIFs and then use gif2fli.
	Fli generation is not supported on this platform. Generate the 
	animation as single gif files and then use gif2fli to make an fli 
	file from it.

Not all polygons have been processed.
	There was not enough room or maxplanes was not set high enough for 
	all polygons to be stored. The engine will render the ones that 
	were stored. Set planes or maxplane_lint1 to a higher value.

Not enough memory free for Z-buffer.
	After all allocations are done there is not enough memory left to 
	allocate a segment with at least three scan lines. Reduce memory 
	load or lower resolution.

Not enough memory to allocate file buffer.
Not enough memory to allocate output buffers.
Not enough memory to startup.
	Not enough memory free to startup and run RenderStar. If -m is set 
	raise its value. You need at least 1MB free to run the engine.

Not enough memory to allocate buffers.
	Not enough memory free to allocate all the elements (lights, 
	datafiles, materials, bitmaps) set in render.rc1. Set these 
	elements to lower values.

Not enough memory to smooth this many polygons.
	Not enough memory free to store the smooth information for this 
	many polygons. Lower the total memory load or lower the amount of 
	polygons to be smoothed.

Not enough room for all polygons.
	The total amount of polygons is set much too high for the available 
	amount of memory. Lower maxplane_lint1, maxplanes or planes in the 
	shell.

Not enough room for Shadow file. Shadow is off.
	There is not enough memory free to allocate the shadow buffer. 
	The shadow buffer must fit into memory after the polygons have 
	been loaded. Reduce shadow buffer resolution or lower the amount 
	of polygons. The engine continues with shadow off.

Not enough room for Texture Map. Map is skipped.
	No more space free for this texture map to be loaded and / or used. 
	Reduce memory load and size of elements loaded by the engine before 
	this map is encountered. Maps have to be stored in memory.

Option [-m] needs a number of kilobytes as argument.
Option [-o] needs a filename as argument.
Option [-p] needs a positive number as argument.
	Incorrect arguments have been supplied.

Premature end of data in file.
Unexpected EOF reached in file.
	An unexpected end of file was encountered in a texture map. The map 
	file is or invalid.

Ran out of arguments before finding file name.
	The programs needs a filename after the arguments.

Regenerate this shadow buffer.
	This is an RenderStar-1 shadow buffer. The format has changed. 
	Regenerate this buffer with RenderStar-2.

This is not a RenderStar-2 rc1 file.
	This is not a correct file. The file can also be corrupt or in a 
	multi-user configuration where you don't have reading privileges for 
	this file.

Unexpected end of memory.
	Somehow RenderStar is lead to believe there is more memory than 
	there actually exists. Can only occur when setting -m higher than 
	available memory or with serious system errors.

Unknown command line option [-<char>].
	An unknown command line option is passed. 

Writing fli file (<filename.ext>).
	An disk error occurred during the writing of the fli file, for 
	instance the disk is full.

Wrong tga format. 
Wrong tga format, not 16bits.
Wrong tga format, not type 10.
	Tga files used as texture maps directly should be tga format 10 
	16-bit run-length encoded. For other tga formats use tga2gif first 
	and then use the gif file.

RenderStar2 Drivers

RS2???

These drivers can be used to display .gif, .pcx and .tga files. Normally 
after correct installation of the driver, a "Render-Show" or "Show" 
command from RenderStar calls the installed driver and displays the image 
on your screen. The drivers can also be used as "standalone" programs, 
called from the DOS command-line. To use the programs this way use the 
following syntax:

@COMMANDO = RS2??? <image_file>

The gif_file appears on your screen. Once the file appears press [Spacebar] 
to show the next image if there is one. The images appear in ascending 
numerical order.

Wildcards

When the image_file specification contains wildcard characters (* or ?), 
the images appear in alpha-numerical order. If the image_file specification 
contains only the first part of the name, the next image displayed is 
selected according to the Renderstar image counting mechanism.

For example, if your current directory contains the following GIF images:

PLANE__1.gif
PLANE__0.gif
COLOURS.gif
OPENPLA0.gif

The command @COMMANDO = RS2SVGA *.gif shows plane__1.gif, plane__0.gif, 
colours.gif and openpla0.gif on your VGA display.

The command @COMMANDO = RS2SVGA PLANE shows plane__0.gif and plane__1.gif 
on your VGA display.

Options

All RS2??? drivers support the following options:

-w <sec>        Shows the next image after the specified time
-o              Overwrite - don't clear screen between images (faster if 
		images have the same resolution)
-n              Counting stops at older file (if you previously made a 
		series of six images, and then rendered a series of four, 
		all with the same name, the display only shows the four 
		new images)
-c              Force counting in filenames (forces filename counting even 
		if wildcards are used in the gif_name specification)
-h              Print help for this program
-s              Silent-mode, does not display messages.

By default, all rs2?? drivers show TGA 16 and 24 bit files in gray scales.

Some drivers have a "-q" option to display .tga files in color. Use the 
"-h" flag to see if the color option is available.

To display .tga images in color (instead of default gray) use the "-q" 
(quantize) flag. Quantizing fits the possible sixteen million colors of 
a TGA into the 256 available colors. When a TGA file now appears you see 
a screen showing the quantizing process first. 

RS2SVGA

RS2SVGA displays on Super-VGA screens in available modes. It detects any installed VESA driver and uses that rather than the native mode of the card.

Options

-T      Use option "-T" (Test) to show what kind of super-VGA you are 
	using and what display modes are available. Since RS2SVGA defaults 
	to the mode with the highest resolution (with at least 256 available 
	colors) it can be useful to select a lower-resolution mode. 
-M      The "-M" option sets the mode: RS2SVGA -M2 plan 
-V      Option "-V" shows on any VGA in the standard VGA full color mode, 
	0x13 at 320x200 pixels. If the resolution of the image is larger 
	than that of the mode, only the top-left part of the image appears.
-A      Use option "-A" to overrule the adapter type. This can be handy 
	when a VESA driver has been installed, but you want to use the 
	VGA in its native mode. The "-T" option shows what values are 
	available for the "-A" option.
-q      If your super-VGA is based on a TSENG-4000 chip and also has a 
	Sierra DAC installed, it can display 32,000 colors. RS2SVGA will 
	detect the Sierra-DAC when the "-q" flag has been specified. .tga 
	files will then be displayed in 32,000 colors. Since the Sierra-DAC 
	only has 5-bits per primary color, this can lead to color-banding.

Super-VGA cards based on the Trident 8900 chip are only supported through 
VESA.

RS2TIGA

RS2TIGA displays on the second display.

This driver works with the following TIGA-compatible drivers:

Artist          TI10/TI20
ELSA            XHR/Gemini
Number 9        Graphics Xccelerator (#9GX)
Renaissance     Rendition II (256 color boards)
TrueVision      Targa/Vista boards with TIGA drivers
Rasterex

Before you can use the program, you will have to load the TIGA software 
on your graphics board. Normally a program called TIGACD is available for 
this. Install any 8-bit mode before starting RS2TIGA. If your software is 
not installed properly the message: "TIGA mode not supported, install TIGA 
software" appears after using the RS2TIGA sample.

RS2TIGA uses only CORE TIGA calls, and runs on any 8-bit or higher mode 
TIGA implementation without loading additional TIGA software. RS2TIGA can 
display 16/24-bit files if the video adapter has 32 bit modes available. 
If these modes are not available there is a built-in quantizer which 
displays a 24- or 16-bit file in the nearest 256 colors.

Options

-A      Restores the original mode on a single screen system, also resets 
	the palette to the original one.
-L      Shows a list of available TIGA modes.
-P      Sets the mode to be used when displaying 8-bit files or quantized 
	pictures.
-T      Sets the mode to be used when displaying true color files.
-r      Displays in "real" colors (only TGA files).
-q      Displays quantized (only TGA files).
	If -P is not specified RS2TIGA uses the last-used TIGA mode. 
	If -T is not specified, RS2TIGA uses the 32 bit mode with the 
	highest resolution.

The RS2??? Drivers Supplied

RS2_85          Displays on IBM 8514/A and compatible adapters
RS2CAM          Cambridge Accelerator and Marksman boards
RS2DGIS         All boards with a DGIS driver
RS2DRV          VGA screens, using Compu Show drivers
RS2EPS          Convert a GIF image to encapsulated (color) postscript
RS2GTI          Rasterex graphic boards
RS2NEC          A special TIGA driver, circumventing a bug in the NEC software
RS2PCX          Converts images to .pcx files
RS2PGA          All IBM PGA cards and some older Matrox cards
RS2SPEA         All SPEA cards
RS2SVGA         Almost all SVGA cards
RS2TGA          Converts images to (8, 16 or 24) bits TGA files
RS2TIGA         All boards with TIGA compatible driver (except NEC)
RS2XHR          All ELSA boards using the GEOS graphics system

Some drivers are still in GIF2??? format. These drivers support all the 
RS2??? options but cannot read .pcx or .tga files:

GIF2FLI         Converts a series of .gif files into a .fli animation file
GIF2MTRX        Matrox graphics boards
GIF2UGA         Metheus boards
GIF2XJ10        Artist XJ-10 boards

8-bit or 24-bit Graphics Adapter 

The images generated by the eXtension-24 can be displayed with 8-bit or 
24-bit graphics adapters. RenderStar-2 eXtension-24 generates the images 
in 24-bit tga format. The original tga file appears when the image appears 
using a 24-bit graphics adapter. Using an 8-bit graphics adapter (such as 
a SuperVGA, TIGA 8-bit, or 8514/A compatible adapter) the 24-bit images is 
quantized into 8-bit gif images during the last phase of rendering. This 
reduction results in a small quality loss in the image. The loss in quality 
is so small, however, that the difference will not be noticeable in 90% of 
images. The contrast in colors makes the "errors" in the image invisible 
when an image contains many different colors. The errors become visible in 
images that contain highly-saturated colors on evenly-colored surfaces. Here 
the color reduction shows up as color bands of a slightly different color 
that result from rounding off the color values when reducing these from 
24-bit to 8-bit. It is best to make use of 24-bit or 32-bit graphics 
adapters, if you run into this problem regularly. 

When generating gif or fli files, RenderStar is a pure 8-bit rendering 
system. Therefore a maximum of 256 differently-colored pixels can appear 
on the screen simultaneously. This means that RenderStar must create all 
of its coloring effects within just 256 differently colored pixels. To do 
this, RenderStar uses a color palette system in which 256 colors are 
selected from the available 16,777,216 colors. When generating a TGA file, 
RenderStar generates a 24-bit image file.

When generating .gif or .fli files, RenderStar is a pure 8-bit rendering 
system. Therefore a maximum of 256 differently colored pixels can be shown 
on the screen simultaneously. This means that RenderStar must create all of 
its coloring effects within just 256 differently colored pixels. To do this, 
RenderStar uses a color palette system in which 256 colors are selected from 
the available 16,777,216 colors. When generating a TGA file, RenderStar 
generates a 24-bit image file.

