Sanchayan Maity
0f4b39775c
During the last commit of splash2 benchmark it seems before committing when we ran "make clean", it effectively undid what the patch at below link did http://www.capsl.udel.edu/splash/Download.html Fix this since without this it is not possible to build the arcane splash2 benchmark.
1103 lines
24 KiB
C
1103 lines
24 KiB
C
/*************************************************************************/
|
|
/* */
|
|
/* Copyright (c) 1994 Stanford University */
|
|
/* */
|
|
/* All rights reserved. */
|
|
/* */
|
|
/* Permission is given to use, copy, and modify this software for any */
|
|
/* non-commercial purpose as long as this copyright notice is not */
|
|
/* removed. All other uses, including redistribution in whole or in */
|
|
/* part, are forbidden without prior written permission. */
|
|
/* */
|
|
/* This software is provided with absolutely no warranty and no */
|
|
/* support. */
|
|
/* */
|
|
/*************************************************************************/
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* env.c
|
|
*
|
|
* DESCRIPTION
|
|
* This file contains routines that read environment description files
|
|
* as well as routines to setup and manipulate the viewing transform,
|
|
* routines to manipulate lights, colors, and to print the environment.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include "rt.h"
|
|
|
|
|
|
|
|
/*
|
|
* Define environment specification opcodes.
|
|
*/
|
|
|
|
#define OP_EYE 'a'
|
|
#define OP_COI 'b'
|
|
#define OP_BKGCOL 'c'
|
|
#define OP_VANG 'd'
|
|
#define OP_LIGHT 'e'
|
|
#define OP_RES 'f'
|
|
#define OP_MAXLEVEL 'g'
|
|
#define OP_MINWEIGHT 'h'
|
|
#define OP_PROJECT 'i'
|
|
#define OP_ANTILEVEL 'j'
|
|
#define OP_ANTITOL 'k'
|
|
#define OP_MODELMAT 'l'
|
|
#define OP_SHAD 'm'
|
|
#define OP_SHADING 'n'
|
|
#define OP_DISPLAY_IN 'o'
|
|
#define OP_DISPLAY_OUT 'p'
|
|
#define OP_GEOM_FILE 'q'
|
|
#define OP_TEX_FILE 'r'
|
|
#define OP_RL_FILE 's'
|
|
#define OP_TEXTURE 't'
|
|
#define OP_IMAGE 'u'
|
|
#define OP_FOOTPRINT 'v'
|
|
#define OP_TRAVERSAL 'w'
|
|
#define OP_AMBIENT 'x'
|
|
#define OP_EXCELL_PRIM 'y'
|
|
#define OP_EXCELL_DIR 'z'
|
|
#define OP_EXCELL_SUBDIV '9'
|
|
#define OP_HIER_SUBLEVEL '1'
|
|
#define OP_HIER_PRIMNUM '2'
|
|
#define OP_PREVIEW_BKCULL '3'
|
|
#define OP_PREVIEW_FILL '4'
|
|
#define OP_PREVIEW_SPHTESS '5'
|
|
#define OP_ERROR '0'
|
|
#define OP_NORM_DB '6'
|
|
#define OP_DATA_TYPE '7'
|
|
#define OP_HU_MAX_PRIMS_CELL '8'
|
|
#define OP_HU_GRIDSIZE '@'
|
|
#define OP_HU_NUMBUCKETS '#'
|
|
#define OP_HU_MAX_SUBDIV '$'
|
|
#define OP_HU_LAZY '*'
|
|
#define OP_BUNDLE '+'
|
|
#define OP_BLOCK '%'
|
|
|
|
|
|
|
|
/*
|
|
* Define structure for a command table entry (CTE).
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
CHAR *command; /* Command name. */
|
|
CHAR opcode; /* Command code. */
|
|
}
|
|
CTE;
|
|
|
|
|
|
|
|
/*
|
|
* Allocate and initialize the command table.
|
|
*/
|
|
|
|
CTE cmdtab[] =
|
|
{
|
|
{"eye", OP_EYE },
|
|
{"center", OP_COI },
|
|
{"light", OP_LIGHT },
|
|
{"resolution", OP_RES },
|
|
{"shadows", OP_SHAD },
|
|
{"background", OP_BKGCOL },
|
|
{"viewangle", OP_VANG },
|
|
{"antilevel", OP_ANTILEVEL },
|
|
{"minweight", OP_MINWEIGHT },
|
|
{"project", OP_PROJECT },
|
|
{"antitolerance", OP_ANTITOL },
|
|
{"maxlevel", OP_MAXLEVEL },
|
|
{"modelxform", OP_MODELMAT },
|
|
{"shading", OP_SHADING },
|
|
{"displayin", OP_DISPLAY_IN },
|
|
{"displayout", OP_DISPLAY_OUT },
|
|
{"geometry", OP_GEOM_FILE },
|
|
{"texturetype", OP_TEXTURE },
|
|
{"texturefile", OP_TEX_FILE },
|
|
{"image", OP_IMAGE },
|
|
{"footprint", OP_FOOTPRINT },
|
|
{"traversal", OP_TRAVERSAL },
|
|
{"rlfile", OP_RL_FILE },
|
|
{"ambient", OP_AMBIENT },
|
|
{"excellprim", OP_EXCELL_PRIM },
|
|
{"excelldir", OP_EXCELL_DIR },
|
|
{"excellsubdiv", OP_EXCELL_SUBDIV },
|
|
{"hsublevel", OP_HIER_SUBLEVEL },
|
|
{"hprim", OP_HIER_PRIMNUM },
|
|
{"bfcull", OP_PREVIEW_BKCULL },
|
|
{"fill", OP_PREVIEW_FILL },
|
|
{"spheretess", OP_PREVIEW_SPHTESS },
|
|
{"normdata", OP_NORM_DB },
|
|
{"datatype", OP_DATA_TYPE },
|
|
{"hu_maxprims", OP_HU_MAX_PRIMS_CELL },
|
|
{"hu_gridsize", OP_HU_GRIDSIZE },
|
|
{"hu_numbuckets", OP_HU_NUMBUCKETS },
|
|
{"hu_maxsubdiv", OP_HU_MAX_SUBDIV },
|
|
{"hu_lazy", OP_HU_LAZY },
|
|
{"bundle", OP_BUNDLE },
|
|
{"block", OP_BLOCK },
|
|
{" ", OP_ERROR },
|
|
};
|
|
|
|
|
|
|
|
#define NUM_COMMANDS (sizeof(cmdtab)/sizeof(CTE))
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* PrintEnv - print environment and lights to stdout
|
|
*
|
|
* SYNOPSIS
|
|
* VOID PrintEnv()
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID PrintEnv()
|
|
{
|
|
INT i;
|
|
LIGHT *lp;
|
|
|
|
printf("\nEnvironment:\n");
|
|
printf("\tEye pos: \t %f %f %f\n", View.eye[0], View.eye[1], View.eye[2]);
|
|
printf("\tCenter pos:\t %f %f %f\n", View.coi[0], View.coi[1], View.coi[2]);
|
|
printf("\tBackground:\t %f %f %f\n", View.bkg[0], View.bkg[1], View.bkg[2]);
|
|
printf("\tView Angle:\t %f\n", View.vang);
|
|
printf("\nAmbient Light:\t\t %f %f %f\n", View.ambient[0], View.ambient[1], View.ambient[2]);
|
|
printf("\nLights:\n");
|
|
|
|
lp = lights;
|
|
for (i = 0; i < nlights; i++)
|
|
{
|
|
printf("\t[%ld] Pos:\t %f %f %f\n", i, lp->pos[0], lp->pos[1], lp->pos[2]);
|
|
printf("\t Col:\t %f %f %f\n", lp->col[0], lp->col[1], lp->col[2]);
|
|
printf("\t Shadow:\t %ld\n", lp->shadow);
|
|
|
|
lp = lp->next;
|
|
}
|
|
|
|
printf("\n");
|
|
printf("Options:\n");
|
|
printf("\tTraversal:\t\t\t");
|
|
|
|
switch (TraversalType)
|
|
{
|
|
case TT_LIST:
|
|
printf("list\n");
|
|
break;
|
|
|
|
case TT_HUG:
|
|
printf("uniform grid hierarchy\n");
|
|
printf("\t\t\t\t\t grid size %ld\n", hu_gridsize);
|
|
printf("\t\t\t\t\t max prims %ld\n", hu_max_prims_cell);
|
|
printf("\t\t\t\t\t max sublevel %ld\n", hu_max_subdiv_level);
|
|
printf("\t\t\t\t\t buckets %ld\n", hu_numbuckets);
|
|
printf("\t\t\t\t\t lazy %ld\n", hu_lazy);
|
|
break;
|
|
}
|
|
|
|
printf("\tNormalization DB:\t\t");
|
|
printf(ModelNorm ? "yes\n" : "no\n");
|
|
|
|
printf("\tProjection type:\t\t");
|
|
printf(View.projection == PT_PERSP ? "perspective\n" : "orthographic\n");
|
|
|
|
printf("\tShadows:\t\t\t");
|
|
printf(View.shad ? "on\n" : "off\n");
|
|
|
|
printf("\tShading:\t\t\t");
|
|
printf(View.shading ? "on\n" : "off\n");
|
|
|
|
printf("\tResolution:\t\t\t%ld %ld\n", Display.xres, Display.yres);
|
|
printf("\tMin Ray Weight:\t\t\t%f\n", Display.minweight);
|
|
printf("\tMax Anti Subdivison Level:\t%ld\n", Display.maxAAsubdiv);
|
|
printf("\tAnti tolerance:\t\t\t%f\n", Display.aatolerance);
|
|
|
|
printf("\tBundle: \t\t\t%ld %ld\n", bundlex, bundley);
|
|
printf("\tBlock: \t\t\t%ld %ld\n", blockx, blocky);
|
|
|
|
if (GeoFile)
|
|
printf("\tGeometry file:\t\t\t%s\n", GeoFileName);
|
|
|
|
if (PicFile)
|
|
printf("\tImage file:\t\t\t%s\n", PicFileName);
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* InitEnv - setup the default environment variables
|
|
*
|
|
* SYNOPSIS
|
|
* VOID InitEnv()
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID InitEnv()
|
|
{
|
|
/* Default eye position. */
|
|
View.eye[0] = 0.5;
|
|
View.eye[1] = 0.5;
|
|
View.eye[2] = -1.5;
|
|
|
|
/* Default center position. */
|
|
View.coi[0] = 0.5;
|
|
View.coi[1] = 0.5;
|
|
View.coi[2] = 0.5;
|
|
|
|
/* Default background color. */
|
|
View.bkg[0] = 0.0;
|
|
View.bkg[1] = 0.0;
|
|
View.bkg[2] = 0.8;
|
|
|
|
/* Default viewing angle. */
|
|
View.vang = 60.0;
|
|
|
|
/* Default ambient light. */
|
|
View.ambient[0] = 0.1;
|
|
View.ambient[1] = 0.1;
|
|
View.ambient[2] = 0.1;
|
|
|
|
/* Shadows and shading. */
|
|
View.shad = TRUE;
|
|
View.shading = TRUE;
|
|
|
|
/* Perspective projection. */
|
|
View.projection = PT_PERSP;
|
|
|
|
/* Default resolution is 100 x 100 */
|
|
Display.xres = 100;
|
|
Display.yres = 100;
|
|
Display.numpixels = 100*100;
|
|
|
|
/* Default maximum raytrace level. */
|
|
Display.maxlevel = 5;
|
|
|
|
/* Default anti-aliasing. */
|
|
Display.maxAAsubdiv = 0;
|
|
Display.aatolerance = .020;
|
|
Display.aarow = MAX_AA_ROW - 1;
|
|
Display.aacol = MAX_AA_COL - 1;
|
|
|
|
/* Default ray minimum weight is 0.001. */
|
|
Display.minweight = 0.001;
|
|
|
|
/* Default screen size. */
|
|
Display.scrDist = 164.5;
|
|
Display.scrWidth = 190.0;
|
|
Display.scrHeight = 190.0;
|
|
|
|
Display.scrHalfWidth = Display.scrWidth * 0.5;
|
|
Display.scrHalfHeight = Display.scrHeight* 0.5;
|
|
|
|
Display.vWscale = Display.scrWidth/(REAL)Display.xres;
|
|
Display.vHscale = Display.scrHeight/(REAL)Display.yres;
|
|
|
|
/* Init transformation matrices. */
|
|
MatrixIdentity(View.vtrans);
|
|
MatrixIdentity(View.model);
|
|
|
|
GeoFile = FALSE;
|
|
PicFile = FALSE;
|
|
ModelNorm = TRUE;
|
|
ModelTransform = FALSE;
|
|
DataType = DT_ASCII;
|
|
TraversalType = TT_LIST;
|
|
|
|
/* Init statistics.
|
|
*
|
|
* Stats.total_rays = 0;
|
|
* Stats.prim_rays = 0;
|
|
* Stats.shad_rays = 0;
|
|
* Stats.shad_rays_not_hit = 0;
|
|
* Stats.shad_rays_hit = 0;
|
|
* Stats.shad_coherence_rays = 0;
|
|
* Stats.refl_rays = 0;
|
|
* Stats.trans_rays = 0;
|
|
* Stats.aa_rays = 0;
|
|
* Stats.bound_tests = 0;
|
|
* Stats.bound_hits = 0;
|
|
* Stats.bound_misses = 0;
|
|
* Stats.ray_obj_hit = 0;
|
|
* Stats.ray_obj_miss = 0;
|
|
* Stats.max_tree_depth = 0;
|
|
* Stats.max_objs_ray = 0;
|
|
* Stats.max_rays_pixel = 0;
|
|
* Stats.max_objs_pixel = 0;
|
|
* Stats.total_objs_tested = 0;
|
|
* Stats.coverage = 0;
|
|
*/
|
|
|
|
lights = GlobalMalloc(sizeof(LIGHT), "env.c");
|
|
|
|
bundlex = 25;
|
|
bundley = 25;
|
|
blockx = 2;
|
|
blocky = 2;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* InitLights - setup the default light position and color
|
|
*
|
|
* SYNOPSIS
|
|
* VOID InitLights()
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID InitLights()
|
|
{
|
|
nlights = 1;
|
|
|
|
lights->pos[0] = 0.0;
|
|
lights->pos[1] = 0.0;
|
|
lights->pos[2] = -2000.0;
|
|
lights->pos[3] = 1.0;
|
|
lights->col[0] = 1.0;
|
|
lights->col[1] = 1.0;
|
|
lights->col[2] = 1.0;
|
|
lights->shadow = TRUE;
|
|
lights->next = NULL;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* InitDisplay - setup display parameters
|
|
*
|
|
* SYNOPSIS
|
|
* VOID InitDisplay()
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID InitDisplay()
|
|
{
|
|
REAL aspect; /* Resolution aspect ratio. */
|
|
REAL theta; /* View angle in radians. */
|
|
|
|
aspect = (REAL)Display.xres/(REAL)Display.yres;
|
|
theta = (View.vang*0.5)*0.0175;
|
|
|
|
Display.scrWidth = Display.scrHeight*aspect;
|
|
Display.scrDist = (0.5*Display.scrHeight)/tan(theta);
|
|
Display.scrHalfWidth = Display.scrWidth*0.5;
|
|
Display.scrHalfHeight = Display.scrHeight*0.5;
|
|
Display.vWscale = Display.scrWidth/(REAL)Display.xres;
|
|
Display.vHscale = Display.scrHeight/(REAL)Display.yres;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* VerifyColorRange - verify if a color value lies between 0 and 1
|
|
*
|
|
* SYNOPSIS
|
|
* BOOL VerifyColorRange(c)
|
|
* COLOR c;
|
|
*
|
|
* RETURNS
|
|
* TRUE if color is within range, FALSE otherwise.
|
|
*/
|
|
|
|
BOOL VerifyColorRange(COLOR c)
|
|
{
|
|
if (c[0] < 0.0 || c[0] > 1.0 ||
|
|
c[1] < 0.0 || c[1] > 1.0 ||
|
|
c[2] < 0.0 || c[2] > 1.0)
|
|
{
|
|
printf("Invalid color %f %f %f.\n", c[0], c[1], c[2]);
|
|
return (FALSE);
|
|
}
|
|
else
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* TransformLights - transform lights to a new position given a matrix
|
|
*
|
|
* SYNOPSIS
|
|
* VOID TransformLights(m)
|
|
* MATRIX m; // Transformation matrix.
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID TransformLights(MATRIX m)
|
|
{
|
|
INT i;
|
|
LIGHT *lp;
|
|
|
|
lp = lights;
|
|
for (i = 0; i < nlights; i++)
|
|
{
|
|
VecMatMult(lp->pos, m, lp->pos);
|
|
lp = lp->next;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* ViewRotate - compute transform that aligns direction x,y,z with +z axis
|
|
*
|
|
* SYNOPSIS
|
|
* VOID ViewRotate(M, x, y, z)
|
|
* MATRIX M;
|
|
* REAL x, y, z;
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID ViewRotate(MATRIX M, REAL x, REAL y, REAL z)
|
|
{
|
|
REAL r, rx;
|
|
|
|
rx = sqrt(x*x + z*z);
|
|
|
|
if (ABS(rx) < RAYEPS)
|
|
{
|
|
MatrixIdentity(M);
|
|
Rotate(X_AXIS, M, PI_over_2 * (Sign(y)));
|
|
return;
|
|
}
|
|
|
|
r = sqrt(x*x + y*y + z*z);
|
|
|
|
M[0][0] = z/rx;
|
|
M[0][1] = -x*y/(r*rx);
|
|
M[0][2] = x/r;
|
|
M[0][3] = 0.0;
|
|
|
|
M[1][0] = 0.0;
|
|
M[1][1] = rx/r;
|
|
M[1][2] = y/r;
|
|
M[1][3] = 0.0;
|
|
|
|
M[2][0] = -x/rx;
|
|
M[2][1] = -y*z/(r*rx);
|
|
M[2][2] = z/r;
|
|
M[2][3] = 0.0;
|
|
|
|
M[3][0] = 0.0;
|
|
M[3][1] = 0.0;
|
|
M[3][2] = 0.0;
|
|
M[3][3] = 1.0;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* CreateViewMatrix - compute view transform matrix and put in View.vtrans
|
|
*
|
|
* SYNOPSIS
|
|
* VOID CreateViewMatrix()
|
|
*
|
|
* NOTES
|
|
* Taken from David Kurlander's program.
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID CreateViewMatrix()
|
|
{
|
|
MATRIX T, R; /* Temporary matrices. */
|
|
|
|
/* Put eye at origin. */
|
|
|
|
Translate(T, -View.eye[0], -View.eye[1], -View.eye[2]);
|
|
MatrixMult(View.vtrans, View.vtrans, T);
|
|
|
|
/* Align view direction with Z axis. */
|
|
|
|
ViewRotate(R, View.coi[0] - View.eye[0], View.coi[1] - View.eye[1], View.coi[2] - View.eye[2]);
|
|
MatrixMult(View.vtrans, View.vtrans, R);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* TransformViewRay - put ray back in world coordinate system from view coordinate system
|
|
*
|
|
* SYNOPSIS
|
|
* VOID TransformViewRay(tray)
|
|
* POINT tray; // Ray.
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID TransformViewRay(POINT tray)
|
|
{
|
|
VecMatMult(tray, View.vtransInv, tray);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* NormalizeEnv - normalize eye, center of intersect and light positions
|
|
*
|
|
* SYNOPSIS
|
|
* VOID NormalizeEnv(normMat)
|
|
* MATRIX normMat; // Normalization matrix.
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID NormalizeEnv(MATRIX normMat)
|
|
{
|
|
View.eye[3] = 1.0;
|
|
VecMatMult(View.eye, normMat, View.eye);
|
|
|
|
View.coi[3] = 1.0;
|
|
VecMatMult(View.coi, normMat, View.coi);
|
|
|
|
TransformLights(normMat);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* LookupCommand - find environment command in table and return opcode
|
|
*
|
|
* SYNOPSIS
|
|
* CHAR LookupCommand(s)
|
|
* CHAR *s;
|
|
*
|
|
* RETURNS
|
|
* The corresponding opcode.
|
|
*/
|
|
|
|
CHAR LookupCommand(CHAR *s)
|
|
{
|
|
INT i;
|
|
|
|
for (i = 0; i < NUM_COMMANDS; i++)
|
|
if (strcmp(s, cmdtab[i].command) == 0)
|
|
return (cmdtab[i].opcode);
|
|
|
|
printf("\n\nInvalid command string %s.\n", s);
|
|
return (OP_ERROR);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* ReadEnvFile - read and parse environment file
|
|
*
|
|
* SYNOPSIS
|
|
* VOID ReadEnvFile(EnvFileName)
|
|
* CHAR *EnvFileName; // Environment filename.
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*/
|
|
|
|
VOID ReadEnvFile(CHAR *EnvFileName)
|
|
{
|
|
INT i, j; /* Indices. */
|
|
INT stat; /* Input var status counter. */
|
|
INT dummy;
|
|
CHAR opcode; /* Environment spec opcode. */
|
|
CHAR command[30]; /* Environment spec command. */
|
|
CHAR opparam[30]; /* Command parameter. */
|
|
CHAR dummy_char[60];
|
|
CHAR datafile[10];
|
|
BOOL lights_set; /* Lights set? */
|
|
FILE *pf; /* Input file pointer. */
|
|
LIGHT *lptr, *lastlight; /* Light node pointers. */
|
|
|
|
|
|
/* Open command file. */
|
|
|
|
pf = fopen(EnvFileName, "r");
|
|
if (!pf)
|
|
{
|
|
printf("Unable to open environment file %s.\n", EnvFileName);
|
|
exit(-1);
|
|
}
|
|
|
|
InitEnv(); /* Set defaults. */
|
|
|
|
nlights = 0;
|
|
lights_set = FALSE;
|
|
|
|
|
|
/* Process command file according to opcodes. */
|
|
|
|
while (fscanf(pf, "%s", command) != EOF)
|
|
{
|
|
opcode = LookupCommand(command);
|
|
|
|
switch (opcode)
|
|
{
|
|
/* Eye position. */
|
|
case OP_EYE:
|
|
stat = fscanf(pf, "%lf %lf %lf", &(View.eye[0]), &(View.eye[1]), &(View.eye[2]));
|
|
if (stat != 3)
|
|
{
|
|
printf("error: eye position.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Center of interest position. */
|
|
case OP_COI:
|
|
stat = fscanf(pf, "%lf %lf %lf", &(View.coi[0]), &(View.coi[1]), &(View.coi[2]));
|
|
if (stat != 3)
|
|
{
|
|
printf("error: coi position.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Background color. */
|
|
case OP_BKGCOL:
|
|
stat = fscanf(pf, "%lf %lf %lf", &(View.bkg[0]), &(View.bkg[1]), &(View.bkg[2]));
|
|
if (stat != 3)
|
|
{
|
|
printf("error: background color.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (!VerifyColorRange(View.bkg))
|
|
exit(-1);
|
|
break;
|
|
|
|
/* Viewing angle in degrees. */
|
|
case OP_VANG:
|
|
stat = fscanf(pf, "%lf", &(View.vang));
|
|
if (stat != 1)
|
|
{
|
|
printf("error: viewing angle.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (View.vang < 0.0 || View.vang > 100.0)
|
|
{
|
|
printf("Invalid angle %f.\n", View.vang);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Ambient. */
|
|
case OP_AMBIENT:
|
|
stat = fscanf(pf, "%lf %lf %lf", &(View.ambient[0]), &(View.ambient[1]), &(View.ambient[2]));
|
|
if (stat != 3)
|
|
{
|
|
printf("error: ambient.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (!VerifyColorRange(View.ambient))
|
|
exit(-1);
|
|
break;
|
|
|
|
/* Anti-aliasing level. */
|
|
case OP_ANTILEVEL:
|
|
stat = fscanf(pf, "%ld", &(Display.maxAAsubdiv));
|
|
if (stat != 1)
|
|
{
|
|
printf("View error: antialias level.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (Display.maxAAsubdiv < 0 || Display.maxAAsubdiv > 3)
|
|
{
|
|
printf("error: antialias level %ld.\n", Display.maxAAsubdiv);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Recursion level. */
|
|
case OP_MAXLEVEL:
|
|
stat = fscanf(pf, "%ld", &(Display.maxlevel));
|
|
printf("maxlevel of ray recursion = %ld\n",Display.maxlevel);
|
|
fflush(stdout);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: recursion level.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (Display.maxlevel > 5 || Display.maxlevel < 0)
|
|
{
|
|
printf("error: recursion level %ld.\n", Display.maxlevel);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Mininum ray weight. */
|
|
case OP_MINWEIGHT:
|
|
stat = fscanf(pf, "%lf", &(Display.minweight));
|
|
if (stat != 1)
|
|
{
|
|
printf("error: miniumum ray weight.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (Display.minweight < 0.0 || Display.minweight > 1.0)
|
|
{
|
|
printf("error: invalid ray weight %f.\n", Display.minweight);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Anti tolerance weight. */
|
|
case OP_ANTITOL:
|
|
stat = fscanf(pf, "%lf", &(Display.aatolerance));
|
|
if (stat != 1)
|
|
{
|
|
printf("error: anti tolerance weight.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (Display.aatolerance < 0.0 || Display.aatolerance > 1.0)
|
|
{
|
|
printf("error: invalid anti tolerance weight %f.\n", Display.aatolerance);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Resolution. */
|
|
case OP_RES:
|
|
stat = fscanf(pf, "%ld %ld", &(Display.xres), &(Display.yres));
|
|
if (stat != 2)
|
|
{
|
|
printf("error: resolution.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Light positions and colors. */
|
|
case OP_LIGHT:
|
|
lights_set = TRUE;
|
|
if (nlights > 0)
|
|
lptr = GlobalMalloc(sizeof(LIGHT), "env.c");
|
|
else
|
|
lptr = lights;
|
|
|
|
stat = fscanf(pf, "%lf %lf %lf %lf %lf %lf",
|
|
&(lptr->pos[0]),
|
|
&(lptr->pos[1]),
|
|
&(lptr->pos[2]),
|
|
&(lptr->col[0]),
|
|
&(lptr->col[1]),
|
|
&(lptr->col[2]));
|
|
|
|
if (stat != 6)
|
|
{
|
|
printf("error: Lights.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (!VerifyColorRange(lptr->col))
|
|
exit(-1);
|
|
|
|
lptr->pos[3] = 1.0;
|
|
stat = fscanf(pf, "%ld", &(lptr->shadow));
|
|
if (stat != 1)
|
|
{
|
|
printf("error: Lights shadow indicator.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
lptr->next = NULL;
|
|
if (nlights > 0)
|
|
lastlight->next = lptr;
|
|
|
|
nlights++;
|
|
lastlight = lptr;
|
|
break;
|
|
|
|
/* Model transformation matrix. */
|
|
case OP_MODELMAT:
|
|
for (i = 0; i < 4; i++)
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
stat = fscanf(pf, "%lf", &(View.model[i][j]));
|
|
if (stat != 1)
|
|
{
|
|
printf("Error in matrix.\n");
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
ModelTransform = TRUE;
|
|
break;
|
|
|
|
/* Shadow info. */
|
|
case OP_SHAD:
|
|
stat = fscanf(pf, "%s", opparam);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: shadow.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (strcmp(opparam, "on") == 0)
|
|
View.shad = TRUE;
|
|
else
|
|
View.shad = FALSE;
|
|
break;
|
|
|
|
/* Shading info. */
|
|
case OP_SHADING:
|
|
stat = fscanf(pf, "%s", opparam);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: shading %s.\n", opparam);
|
|
exit(-1);
|
|
}
|
|
|
|
if (strcmp(opparam, "on") == 0)
|
|
View.shading = TRUE;
|
|
else
|
|
View.shading = FALSE;
|
|
break;
|
|
|
|
/* Projection type. */
|
|
case OP_PROJECT:
|
|
stat = fscanf(pf, "%s", opparam);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: projection %s.\n", opparam);
|
|
exit(-1);
|
|
}
|
|
|
|
if (strcmp(opparam, "perspective") == 0)
|
|
View.projection = PT_PERSP;
|
|
else
|
|
if (strcmp(opparam, "orthographic") == 0)
|
|
View.projection = PT_ORTHO;
|
|
else
|
|
{
|
|
printf("Invalid projection %s.\n", opparam);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Database traversal info. */
|
|
case OP_TRAVERSAL:
|
|
stat = fscanf(pf, "%s", opparam);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: traversal %s.\n", opparam);
|
|
exit(-1);
|
|
}
|
|
|
|
if (strcmp(opparam, "list") == 0)
|
|
TraversalType = TT_LIST;
|
|
else
|
|
if (strcmp(opparam, "huniform") == 0)
|
|
TraversalType = TT_HUG;
|
|
else
|
|
{
|
|
printf("Invalid traversal code %s.\n", opparam);
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
/* Geometry file. */
|
|
case OP_GEOM_FILE:
|
|
stat = fscanf(pf, " %s", GeoFileName);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: geometry file.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
GeoFile = TRUE;
|
|
break;
|
|
|
|
/* Runlength file. */
|
|
case OP_RL_FILE:
|
|
stat = fscanf(pf, " %s", PicFileName);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: runlength file.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
PicFile = TRUE;
|
|
break;
|
|
|
|
case OP_PREVIEW_BKCULL:
|
|
stat = fscanf(pf, "%ld", &dummy);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: Preview bkcull.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_PREVIEW_FILL:
|
|
stat = fscanf(pf, "%ld", &dummy);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: Preview fill.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_PREVIEW_SPHTESS:
|
|
stat = fscanf(pf, "%s", dummy_char);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: sphere tess.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_NORM_DB:
|
|
stat = fscanf(pf, "%s", opparam);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: norm database.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (strcmp(opparam, "no") == 0)
|
|
ModelNorm = FALSE;
|
|
|
|
break;
|
|
|
|
case OP_DATA_TYPE:
|
|
stat = fscanf(pf, "%s", datafile);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: datatype.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
if (strcmp(datafile, "binary") == 0)
|
|
DataType = DT_BINARY;
|
|
|
|
break;
|
|
|
|
case OP_HU_MAX_PRIMS_CELL:
|
|
stat = fscanf(pf, "%ld", &hu_max_prims_cell);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: Huniform prims per cell.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_HU_GRIDSIZE:
|
|
stat = fscanf(pf, "%ld", &hu_gridsize);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: Huniform gridsize.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_HU_NUMBUCKETS:
|
|
stat = fscanf(pf, "%ld", &hu_numbuckets);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: Huniform numbuckets.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_HU_MAX_SUBDIV:
|
|
stat = fscanf(pf, "%ld", &hu_max_subdiv_level);
|
|
if (stat != 1 || hu_max_subdiv_level > 3)
|
|
{
|
|
printf("error: Huniform max subdiv level.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_HU_LAZY:
|
|
stat = fscanf(pf, "%ld", &hu_lazy);
|
|
if (stat != 1)
|
|
{
|
|
printf("error: Huniform lazy.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_BUNDLE:
|
|
stat = fscanf(pf, "%ld %ld", &bundlex, &bundley);
|
|
if (stat != 2 )
|
|
{
|
|
printf("error: bundle.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
case OP_BLOCK:
|
|
stat = fscanf(pf, "%ld %ld", &blockx, &blocky);
|
|
if (stat != 2 )
|
|
{
|
|
printf("error: block.\n");
|
|
exit(-1);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
printf("Warning: unrecognized env command: %s.\n", command);
|
|
break;
|
|
}
|
|
}
|
|
|
|
fclose(pf);
|
|
|
|
/* Display parameters reset. */
|
|
Display.numpixels = Display.xres*Display.yres;
|
|
Display.vWscale = Display.scrWidth/Display.xres;
|
|
Display.vHscale = Display.scrHeight/Display.yres;
|
|
|
|
|
|
/* If no light information given, set default. */
|
|
if (!lights_set)
|
|
InitLights();
|
|
|
|
/* Set up screen parameters. */
|
|
InitDisplay();
|
|
|
|
/* Parameter check; think about lifting this restriction. */
|
|
if ((TraversalType != TT_LIST) && ModelNorm == FALSE)
|
|
{
|
|
printf("Data must be normalized with this traversal method!.\n");
|
|
ModelNorm = TRUE;
|
|
}
|
|
}
|
|
|