ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rad.c
(Generate patch)

Comparing ray/src/util/rad.c (file contents):
Revision 2.20 by greg, Tue Aug 24 21:44:55 1993 UTC vs.
Revision 2.25 by greg, Wed Sep 15 15:11:47 1993 UTC

# Line 110 | Line 110 | long   matdate;                /* date of latest material file */
110   int     explicate = 0;          /* explicate variables */
111   int     silent = 0;             /* do work silently */
112   int     noaction = 0;           /* don't do anything */
113 < int     vwonly = 0;             /* print view only */
113 > int     sayview = 0;            /* print view out */
114   char    *rvdevice = NULL;       /* rview output device */
115   char    *viewselect = NULL;     /* specific view only */
116  
117   int     overture = 0;           /* overture calculation needed */
118  
119   char    *progname;              /* global argv[0] */
120 + char    *rifname;               /* global rad input file name */
121  
122   char    radname[MAXPATH];       /* root Radiance file name */
123  
# Line 145 | Line 146 | char   *argv[];
146                          rvdevice = argv[++i];
147                          break;
148                  case 'V':
149 <                        vwonly++;
150 <                /* fall through */
149 >                        sayview++;
150 >                        break;
151                  case 'v':
152                          viewselect = argv[++i];
153                          break;
# Line 155 | Line 156 | char   *argv[];
156                  }
157          if (i >= argc)
158                  goto userr;
159 +        rifname = argv[i];
160                                  /* assign Radiance root file name */
161 <        rootname(radname, argv[i]);
161 >        rootname(radname, rifname);
162                                  /* load variable values */
163 <        load(argv[i]);
163 >        load(rifname);
164                                  /* get any additional assignments */
165          for (i++; i < argc; i++)
166                  setvariable(argv[i]);
# Line 171 | Line 173 | char   *argv[];
173                                  /* print all values if requested */
174          if (explicate)
175                  printvals();
174 –                                /* print view and exit? */
175 –        if (vwonly)
176 –                exit(printview()==0 ? 0 : 1);
176                                  /* build octree */
177          oconv();
178                                  /* check date on ambient file */
# Line 209 | Line 208 | register char  *rn, *fn;
208   }
209  
210  
211 + #define NOCHAR  127             /* constant for character to delete */
212 +
213 +
214   load(rfname)                    /* load Radiance simulation file */
215   char    *rfname;
216   {
# Line 224 | Line 226 | char   *rfname;
226                  for (cp = buf; *cp; cp++) {
227                          switch (*cp) {
228                          case '\\':
229 <                        case '\n':
228 <                                *cp = ' ';
229 >                                *cp++ = NOCHAR;
230                                  continue;
231                          case '#':
232                                  *cp = '\0';
# Line 245 | Line 246 | setvariable(ass)               /* assign variable according to stri
246   register char   *ass;
247   {
248          char    varname[32];
249 +        char    varval[512];
250 +        int     n;
251          register char   *cp;
252          register VARIABLE       *vp;
253          register int    i;
251 –        int     n;
254  
255          while (isspace(*ass))           /* skip leading space */
256                  ass++;
# Line 262 | Line 264 | register char  *ass;
264                                          /* trim value */
265          while (isspace(*ass) || *ass == '=')
266                  ass++;
267 <        cp = ass + strlen(ass);
268 <        do
269 <                *cp-- = '\0';
268 <        while (cp >= ass && isspace(*cp));
269 <        n = cp - ass + 1;
267 >        for (n = strlen(ass); n > 0; n--)
268 >                if (!isspace(ass[n-1]))
269 >                        break;
270          if (!n) {
271                  fprintf(stderr, "%s: warning - missing value for variable '%s'\n",
272                                  progname, varname);
# Line 291 | Line 291 | register char  *ass;
291                  vp->value = malloc(n+1);
292          if (vp->value == NULL)
293                  syserr(progname);
294 <        strcpy(vp->value+i, ass);
294 >        cp = vp->value+i;               /* copy value, squeezing spaces */
295 >        *cp = *ass;
296 >        for (i = 1; i <= n; i++) {
297 >                if (ass[i] == NOCHAR)
298 >                        continue;
299 >                if (isspace(*cp))
300 >                        while (isspace(ass[i]))
301 >                                i++;
302 >                *++cp = ass[i];
303 >        }
304 >        *++cp = '\0';
305          vp->nass++;
306   }
307  
# Line 613 | Line 623 | register char  *op;
623          d *= 3./(siz[0]+siz[1]+siz[2]);
624          switch (vscale(DETAIL)) {
625          case LOW:
626 <                op = addarg(op, "-ps 16 -dp 16");
626 >                op = addarg(op, "-ps 16 -dp 64");
627                  sprintf(op, " -ar %d", (int)(4*d));
628                  op += strlen(op);
629                  break;
630          case MEDIUM:
631 <                op = addarg(op, "-ps 8 -dp 32");
631 >                op = addarg(op, "-ps 8 -dp 128");
632                  sprintf(op, " -ar %d", (int)(8*d));
633                  op += strlen(op);
634                  break;
635          case HIGH:
636 <                op = addarg(op, "-ps 4 -dp 64");
636 >                op = addarg(op, "-ps 4 -dp 256");
637                  sprintf(op, " -ar %d", (int)(16*d));
638                  op += strlen(op);
639                  break;
# Line 675 | Line 685 | register char  *op;
685          switch (vscale(DETAIL)) {
686          case LOW:
687                  op = addarg(op, vbool(PENUMBRAS) ? "-ps 4" : "-ps 8");
688 <                op = addarg(op, "-dp 64");
688 >                op = addarg(op, "-dp 256");
689                  sprintf(op, " -ar %d", (int)(8*d));
690                  op += strlen(op);
691                  break;
692          case MEDIUM:
693                  op = addarg(op, vbool(PENUMBRAS) ? "-ps 3" : "-ps 6");
694 <                op = addarg(op, "-dp 128");
694 >                op = addarg(op, "-dp 512");
695                  sprintf(op, " -ar %d", (int)(16*d));
696                  op += strlen(op);
697                  break;
698          case HIGH:
699                  op = addarg(op, vbool(PENUMBRAS) ? "-ps 2" : "-ps 4");
700 <                op = addarg(op, "-dp 256");
700 >                op = addarg(op, "-dp 1024");
701                  sprintf(op, " -ar %d", (int)(32*d));
702                  op += strlen(op);
703                  break;
# Line 742 | Line 752 | register char  *op;
752          switch (vscale(DETAIL)) {
753          case LOW:
754                  op = addarg(op, vbool(PENUMBRAS) ? "-ps 1" : "-ps 8");
755 <                op = addarg(op, "-dp 256");
755 >                op = addarg(op, "-dp 1024");
756                  sprintf(op, " -ar %d", (int)(16*d));
757                  op += strlen(op);
758                  break;
759          case MEDIUM:
760                  op = addarg(op, vbool(PENUMBRAS) ? "-ps 1" : "-ps 5");
761 <                op = addarg(op, "-dp 512");
761 >                op = addarg(op, "-dp 2048");
762                  sprintf(op, " -ar %d", (int)(32*d));
763                  op += strlen(op);
764                  break;
765          case HIGH:
766                  op = addarg(op, vbool(PENUMBRAS) ? "-ps 1" : "-ps 3");
767 <                op = addarg(op, "-dp 1024");
767 >                op = addarg(op, "-dp 4096");
768                  sprintf(op, " -ar %d", (int)(64*d));
769                  op += strlen(op);
770                  break;
# Line 1013 | Line 1023 | char   *vn;            /* returned view name */
1023   }
1024  
1025  
1026 < printview()                     /* print out selected view */
1026 > printview(vopts)                        /* print out selected view */
1027 > register char   *vopts;
1028   {
1029 <        extern char     *atos();
1029 >        extern char     *atos(), *getenv();
1030          char    buf[256];
1031          FILE    *fp;
1032 <        register char   *vopts, *cp;
1032 >        register char   *cp;
1033  
1023 –        vopts = getview(0, NULL);
1034          if (vopts == NULL)
1035                  return(-1);
1036          fputs("VIEW=", stdout);
# Line 1051 | Line 1061 | printview()                    /* print out selected view */
1061                          while (isspace(*vopts))
1062                                  vopts++;
1063                          putchar(' ');
1064 <                        while (*vopts && !isspace(*vopts))
1065 <                                putchar(*vopts++);
1064 > #ifdef MSDOS
1065 >                        if (*vopts == '$') {            /* expand env. var. */
1066 >                                if (!*atos(buf, sizeof(buf), vopts+1))
1067 >                                        return(-1);
1068 >                                if ((cp = getenv(buf)) == NULL)
1069 >                                        return(-1);
1070 >                                fputs(cp, stdout);
1071 >                                vopts = sskip(vopts);
1072 >                        } else
1073 > #endif
1074 >                                while (*vopts && !isspace(*vopts))
1075 >                                        putchar(*vopts++);
1076                  }
1077          } while (*vopts++);
1078          putchar('\n');
# Line 1063 | Line 1083 | printview()                    /* print out selected view */
1083   rview(opts)                             /* run rview with first view */
1084   char    *opts;
1085   {
1086 +        char    *vw;
1087          char    combuf[512];
1088                                          /* build command */
1089 <        sprintf(combuf, "rview %s%s ", getview(0, NULL), opts);
1089 >        if ((vw = getview(0, NULL)) == NULL)
1090 >                return;
1091 >        if (sayview)
1092 >                printview(vw);
1093 >        sprintf(combuf, "rview %s%s -R %s ", vw, opts, rifname);
1094          if (rvdevice != NULL)
1095                  sprintf(combuf+strlen(combuf), "-o %s ", rvdevice);
1096          strcat(combuf, vval(OCTREE));
# Line 1120 | Line 1145 | char   *opts;
1145                                          /* do each view */
1146          vn = 0;
1147          while ((vw = getview(vn++, vs)) != NULL) {
1148 +                if (sayview)
1149 +                        printview(vw);
1150                  if (!vs[0])
1151                          sprintf(vs, "%d", vn);
1152                  sprintf(picfile, "%s_%s.pic", vval(PICTURE), vs);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines