| /*************************************************************************/ |
| /* */ |
| /* 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 "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(c) |
| 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(m) |
| 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(M, x, y, z) |
| MATRIX M; |
| REAL x, y, 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(tray) |
| 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(normMat) |
| MATRIX normMat; |
| { |
| POINT tmp; |
| |
| 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(s) |
| 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(EnvFileName) |
| 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 = %d\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; |
| } |
| } |
| |
