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

Comparing src/gen/mkillum.c (file contents):
Revision 2.38 by greg, Wed Oct 5 17:20:55 2011 UTC vs.
Revision 2.47 by greg, Wed Apr 23 02:35:26 2025 UTC

# Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8   #include  <signal.h>
9   #include  <ctype.h>
10  
11 < #include  "rtprocess.h" /* win_popen() */
11 > #include  "paths.h"             /* win_popen() */
12   #include  "mkillum.h"
13 + #include  "func.h"
14  
15                                  /* default parameters */
16   #define  SAMPDENS       48              /* points per projected steradian */
# Line 24 | Line 25 | static const char RCSid[] = "$Id$";
25  
26   struct illum_args  thisillum = {        /* our illum and default values */
27                  0,
27 –                UDzpos,
28 –                0.,
28                  DFLMAT,
29                  DFLDAT,
30                  0,
31                  VOIDID,
32                  SAMPDENS,
33                  NSAMPS,
35 –                NULL,
34                  0.,
35          };
36  
# Line 48 | Line 46 | int    doneheader = 0;         /* printed header yet? */
46   int     warnings = 1;           /* print warnings? */
47  
48   void init(char *octnm, int np);
49 < void filter(register FILE       *infp, char     *name);
49 > void filter(FILE        *infp, char     *name);
50   void xoptions(char      *s, char        *nm);
51   void printopts(void);
52 < void printhead(register int  ac, register char  **av);
52 > void printhead(int  ac, char  **av);
53   void xobject(FILE  *fp, char  *nm);
54  
55  
# Line 64 | Line 62 | main(          /* compute illum distributions using rtrace */
62          int     nprocs = 1;
63          FILE    *fp;
64          int     rval;
65 <        register int    i;
65 >        int     i;
66                                  /* set global arguments */
67          gargv = argv;
68          progname = gargv[0];
# Line 72 | Line 70 | main(          /* compute illum distributions using rtrace */
70          dstrsrc = 0.5;
71          directrelay = 3;
72          ambounce = 2;
73 +                                /* initialize calcomp routines */
74 +        initfunc();
75                                  /* get options from command line */
76          for (i = 1; i < argc; i++) {
77                  while ((rval = expandarg(&argc, &argv, i)) > 0)
# Line 151 | Line 151 | init(char *octnm, int np)              /* start rendering process(
151  
152   void
153   eputs(                          /* put string to stderr */
154 <        register char  *s
154 >        const char  *s
155   )
156   {
157          static int  midline = 0;
# Line 167 | Line 167 | eputs(                         /* put string to stderr */
167  
168  
169   void
170 < wputs(s)                        /* print warning if enabled */
171 < char  *s;
170 > wputs(const char *s)                    /* print warning if enabled */
171   {
172          if (warnings)
173                  eputs(s);
# Line 176 | Line 175 | char  *s;
175  
176  
177   void
178 < quit(ec)                        /* make sure exit is called */
180 < int     ec;
178 > quit(int ec)                    /* make sure exit is called */
179   {
180          if (ray_pnprocs > 0)    /* close children if any */
181 <                ray_pclose(0);          
181 >                ray_pclose(0);
182 >        else if (ray_pnprocs < 0)
183 >                _exit(ec);      /* avoid flush() in child */
184          exit(ec);
185   }
186  
187  
188   void
189   filter(         /* process stream */
190 <        register FILE   *infp,
190 >        FILE    *infp,
191          char    *name
192   )
193   {
194          char    buf[512];
195          FILE    *pfp;
196 <        register int    c;
196 >        int     c;
197  
198          while ((c = getc(infp)) != EOF) {
199                  if (isspace(c))
# Line 210 | Line 210 | filter(                /* process stream */
210                                  error(SYSTEM, errmsg);
211                          }
212                          filter(pfp, buf);
213 <                        pclose(pfp);
213 >                        if (pclose(pfp) != 0) {
214 >                                sprintf(errmsg, "bad status from \"%s\"", buf);
215 >                                error(WARNING, errmsg);
216 >                        }
217                  } else {                                /* object */
218                          ungetc(c, infp);
219                          xobject(infp, name);
# Line 225 | Line 228 | xoptions(                      /* process options in string s */
228          char    *nm
229   )
230   {
228 –        extern FILE     *freopen();
231          char    buf[64];
232          int     negax;
233          int     nerrs = 0;
234 <        register char   *cp;
234 >        char    *cp;
235  
236          if (strncmp(s, "#@mkillum", 9) || !isspace(s[9])) {
237                  fputs(s, stdout);               /* not for us */
# Line 307 | Line 309 | xoptions(                      /* process options in string s */
309                          }
310                          cp = sskip(cp);
311                          continue;
312 <                case 'd':                       /* sample density / BSDF data */
312 >                case 'd':                       /* sample density */
313                          if (*++cp != '=')
314                                  break;
313 –                        if (thisillum.sd != NULL) {
314 –                                free_BSDF(thisillum.sd);
315 –                                thisillum.sd = NULL;
316 –                        }
315                          if (!*++cp || isspace(*cp))
316                                  continue;
317                          if (isintd(cp, " \t\n\r")) {
318                                  thisillum.sampdens = atoi(cp);
319                          } else {
320 <                                atos(buf, sizeof(buf), cp);
321 <                                thisillum.sd = load_BSDF(buf);
324 <                                if (thisillum.sd == NULL)
325 <                                        break;
320 >                                error(WARNING, "direct BSDF input unsupported");
321 >                                goto opterr;
322                          }
323                          cp = sskip(cp);
324                          continue;
# Line 368 | Line 364 | xoptions(                      /* process options in string s */
364                          }
365                          doneheader = 0;
366                          continue;
371 –                case 'u':                       /* up direction */
372 –                        if (*++cp != '=')
373 –                                break;
374 –                        if (!*++cp || isspace(*cp)) {
375 –                                thisillum.udir = UDunknown;
376 –                                continue;
377 –                        }
378 –                        negax = 0;
379 –                        if (*cp == '+')
380 –                                cp++;
381 –                        else if (*cp == '-') {
382 –                                negax++;
383 –                                cp++;
384 –                        }
385 –                        switch (*cp++) {
386 –                        case 'x':
387 –                        case 'X':
388 –                                thisillum.udir = negax ? UDxneg : UDxpos;
389 –                                break;
390 –                        case 'y':
391 –                        case 'Y':
392 –                                thisillum.udir = negax ? UDyneg : UDypos;
393 –                                break;
394 –                        case 'z':
395 –                        case 'Z':
396 –                                thisillum.udir = negax ? UDzneg : UDzpos;
397 –                                break;
398 –                        default:
399 –                                thisillum.udir = UDunknown;
400 –                                break;
401 –                        }
402 –                        if (thisillum.udir == UDunknown || !isspace(*cp))
403 –                                break;
404 –                        continue;
405 –                case 't':                       /* object thickness */
406 –                        if (*++cp != '=')
407 –                                break;
408 –                        if (!isfltd(++cp, " \t\n\r"))
409 –                                break;
410 –                        thisillum.thick = atof(cp);
411 –                        if (thisillum.thick < .0)
412 –                                thisillum.thick = .0;
413 –                        cp = sskip(cp);
414 –                        continue;
367                  case '!':                       /* processed file! */
368                          sprintf(errmsg, "(%s): already processed!", nm);
369                          error(WARNING, errmsg);
# Line 457 | Line 409 | printopts(void)                        /* print out option default values *
409          printf("d=%d\t\t\t\t# density of directions\n", thisillum.sampdens);
410          printf("s=%d\t\t\t\t# samples per direction\n", thisillum.nsamps);
411          printf("b=%f\t\t\t# minimum average brightness\n", thisillum.minbrt);
460 –        switch (thisillum.udir) {
461 –        case UDzneg:
462 –                fputs("u=-Z\t\t\t\t# up is negative Z\n", stdout);
463 –                break;
464 –        case UDyneg:
465 –                fputs("u=-Y\t\t\t\t# up is negative Y\n", stdout);
466 –                break;
467 –        case UDxneg:
468 –                fputs("u=-X\t\t\t\t# up is negative X\n", stdout);
469 –                break;
470 –        case UDxpos:
471 –                fputs("u=+X\t\t\t\t# up is positive X\n", stdout);
472 –                break;
473 –        case UDypos:
474 –                fputs("u=+Y\t\t\t\t# up is positive Y\n", stdout);
475 –                break;
476 –        case UDzpos:
477 –                fputs("u=+Z\t\t\t\t# up is positive Z\n", stdout);
478 –                break;
479 –        case UDunknown:
480 –                break;
481 –        }
482 –        printf("t=%f\t\t\t# object thickness\n", thisillum.thick);
412   }
413  
414  
415   void
416   printhead(                      /* print out header */
417 <        register int  ac,
418 <        register char  **av
417 >        int  ac,
418 >        char  **av
419   )
420   {
421          putchar('#');

Diff Legend

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