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

Comparing ray/src/cv/rad2mgf.c (file contents):
Revision 2.13 by greg, Mon Nov 20 11:06:21 1995 UTC vs.
Revision 2.31 by greg, Wed Apr 23 01:57:04 2025 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1995 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Convert Radiance scene description to MGF
6   */
7  
11 – #include <stdio.h>
12 – #include <math.h>
8   #include <ctype.h>
9 < #include <string.h>
10 < #include "fvect.h"
9 >
10 > #include "platform.h"
11 > #include "rtmath.h"
12 > #include "rtio.h"
13 > #include "rtprocess.h"
14   #include "object.h"
15   #include "color.h"
16   #include "lookup.h"
17  
20 – #define PI      3.14159265358979323846
21 –
18   #define C_1SIDEDTHICK   0.005
19  
24 – int     o_face(), o_cone(), o_sphere(), o_ring(), o_cylinder();
25 – int     o_instance(), o_illum();
26 – int     o_plastic(), o_metal(), o_glass(), o_dielectric(),
27 –        o_mirror(), o_trans(), o_light();
20  
29 – extern void     free();
30 – extern char     *malloc();
31 –
21   LUTAB   rmats = LU_SINIT(free,NULL);            /* defined material table */
22  
23   LUTAB   rdispatch = LU_SINIT(NULL,NULL);        /* function dispatch table */
# Line 60 | Line 49 | struct vert {
49  
50   LUTAB   vertab = LU_SINIT(free,NULL);   /* our vertex lookup table */
51  
52 + typedef int dispatchf(char *mod, char *typ, char *id, FUNARGS *fa);
53  
54 < main(argc, argv)
55 < int     argc;
56 < char    **argv;
54 > void rad2mgf(char *inp);
55 > void cvtprim(char *inp, char *mod, char *typ, char *id, FUNARGS *fa);
56 > void newmat(char *id, char *alias);
57 > void setmat(char *id);
58 > void setobj(char *id);
59 > void init(void);
60 > void uninit(void);
61 > void clrverts(void);
62 > void unspace(char *s);
63 > void add2dispatch(char *name, dispatchf *func);
64 > char *getvertid(char *vname, FVECT vp);
65 >
66 > dispatchf       o_unsupported, o_face, o_cone, o_sphere,
67 >                o_cylinder, o_ring, o_instance, o_illum,
68 >                o_plastic, o_metal, o_glass, o_dielectric,
69 >                o_mirror, o_trans, o_light;
70 >
71 >
72 > int
73 > main(
74 >        int     argc,
75 >        char    **argv
76 > )
77   {
78          int     i;
79  
# Line 104 | Line 114 | unkopt:
114   }
115  
116  
117 < rad2mgf(inp)            /* convert a Radiance file to MGF */
118 < char    *inp;
117 > void
118 > rad2mgf(                /* convert a Radiance file to MGF */
119 >        char    *inp
120 > )
121   {
122 < #define mod     buf
123 < #define typ     (buf+128)
112 < #define id      (buf+256)
113 < #define alias   (buf+384)
114 <        char    buf[512];
122 >        char  buf[512];
123 >        char  mod[128], typ[32], id[128], alias[128];
124          FUNARGS fa;
125 <        register FILE   *fp;
126 <        register int    c;
125 >        FILE    *fp;
126 >        int     c;
127  
128          if (inp == NULL) {
129                  inp = "standard input";
# Line 150 | Line 159 | char   *inp;
159                          break;
160                  default:                /* Radiance primitive */
161                          ungetc(c, fp);
162 <                        if (fscanf(fp, "%s %s %s", mod, typ, id) != 3) {
162 >                        if (fgetword(mod, sizeof(mod), fp) == NULL ||
163 >                                        fgetword(typ, sizeof(typ), fp) == NULL ||
164 >                                        fgetword(id, sizeof(id), fp) == NULL) {
165                                  fputs(inp, stderr);
166                                  fputs(": unexpected EOF\n", stderr);
167                                  exit(1);
168                          }
169 +                        unspace(mod);
170 +                        unspace(id);
171                          if (!strcmp(typ, "alias")) {
172                                  strcpy(alias, "EOF");
173 <                                fscanf(fp, "%s", alias);
173 >                                fgetword(alias, sizeof(alias), fp);
174 >                                unspace(alias);
175                                  newmat(id, alias);
176                          } else {
177                                  if (!readfargs(&fa, fp)) {
# Line 171 | Line 185 | char   *inp;
185                          }
186                          break;
187                  }
188 <        printf("# End conversion from: %s\n", inp);
189 <        if (inp[0] == '!')
190 <                pclose(fp);
191 <        else
188 >        if (inp[0] == '!') {
189 >                if (pclose(fp) != 0)
190 >                        fprintf(stderr, "%s: warning - bad exit status\n", inp);
191 >        } else
192                  fclose(fp);
193 < #undef mod
180 < #undef typ
181 < #undef id
182 < #undef alias
193 >        printf("# End conversion from: %s\n", inp);
194   }
195  
196  
197 < cvtprim(inp, mod, typ, id, fa)  /* process Radiance primitive */
198 < char    *inp, *mod, *typ, *id;
199 < FUNARGS *fa;
197 > void
198 > unspace(        /* replace spaces with underscores in s */
199 >        char *s
200 > )
201   {
202 <        int     (*df)();
202 >        while (*s) {
203 >                if (isspace(*s))
204 >                        *s = '_';
205 >                ++s;
206 >        }
207 > }
208  
209 <        df = (int (*)())lu_find(&rdispatch, typ)->data;
209 >
210 > void
211 > cvtprim(        /* process Radiance primitive */
212 >        char    *inp,
213 >        char    *mod,
214 >        char    *typ,
215 >        char    *id,
216 >        FUNARGS *fa
217 > )
218 > {
219 >        dispatchf       *df;
220 >
221 >        df = (dispatchf *)lu_find(&rdispatch, typ)->data;
222          if (df != NULL) {                               /* convert */
223                  if ((*df)(mod, typ, id, fa) < 0) {
224 <                        fprintf(stderr, "%s: bad %s \"%s\"\n", typ, id);
224 >                        fprintf(stderr, "%s: bad %s \"%s\"\n", "rad2mgf", typ, id);
225                          exit(1);
226                  }
227          } else {                                        /* unsupported */
# Line 203 | Line 232 | FUNARGS        *fa;
232   }
233  
234  
235 < newmat(id, alias)               /* add a modifier to the alias list */
236 < char    *id;
237 < char    *alias;
235 > void
236 > newmat(         /* add a modifier to the alias list */
237 >        char    *id,
238 >        char    *alias
239 > )
240   {
241 <        register LUENT  *lp, *lpa;
241 >        LUENT   *lp, *lpa;
242  
243          if (alias != NULL) {                    /* look up alias */
244                  if ((lpa = lu_find(&rmats, alias)) == NULL)
# Line 239 | Line 270 | memerr:
270   }
271  
272  
273 < setmat(id)                      /* set material to this one */
274 < char    *id;
273 > void
274 > setmat(                 /* set material to this one */
275 >        char    *id
276 > )
277   {
278          if (!strcmp(id, curmat))        /* already set? */
279                  return;
# Line 251 | Line 284 | char   *id;
284   }
285  
286  
287 < setobj(id)                      /* set object name to this one */
288 < char    *id;
287 > void
288 > setobj(                 /* set object name to this one */
289 >        char    *id
290 > )
291   {
292 <        register char   *cp, *cp2;
292 >        char    *cp, *cp2;
293          char    *end = NULL;
294          int     diff = 0;
295                                  /* use all but final suffix */
# Line 270 | Line 305 | char   *id;
305                  *cp2++ = 'O';
306          }
307          for (cp = id; cp < end; *cp2++ = *cp++) {
308 <                if (*cp < '!' | *cp > '~')      /* limit to visible chars */
308 >                if ((*cp < '!') | (*cp > '~'))  /* limit to visible chars */
309                          *cp = '?';
310                  diff += *cp != *cp2;
311          }
# Line 282 | Line 317 | char   *id;
317   }
318  
319  
320 < init()                  /* initialize dispatch table and output */
320 > void
321 > init(void)                      /* initialize dispatch table and output */
322   {
323          lu_init(&vertab, NVERTS);
324          lu_init(&rdispatch, 22);
# Line 295 | Line 331 | init()                 /* initialize dispatch table and output */
331          add2dispatch("tube", o_cylinder);
332          add2dispatch("ring", o_ring);
333          add2dispatch("instance", o_instance);
334 +        add2dispatch("mesh", o_instance);
335          add2dispatch("plastic", o_plastic);
336          add2dispatch("plastic2", o_plastic);
337          add2dispatch("metal", o_metal);
# Line 315 | Line 352 | init()                 /* initialize dispatch table and output */
352   }
353  
354  
355 < uninit()                        /* mark end of MGF file */
355 > void
356 > uninit(void)                    /* mark end of MGF file */
357   {
358          puts("o");
359          if (hasmult)
# Line 327 | Line 365 | uninit()                       /* mark end of MGF file */
365   }
366  
367  
368 < clrverts()                      /* clear vertex table */
368 > void
369 > clrverts(void)                  /* clear vertex table */
370   {
371 <        register int    i;
371 >        int     i;
372  
373          lu_done(&vertab);
374          for (i = 0; i < NVERTS; i++)
# Line 338 | Line 377 | clrverts()                     /* clear vertex table */
377   }
378  
379  
380 < add2dispatch(name, func)        /* add function to dispatch table */
381 < char    *name;
382 < int     (*func)();
380 > void
381 > add2dispatch(   /* add function to dispatch table */
382 >        char    *name,
383 >        int     (*func)()
384 > )
385   {
386 <        register LUENT  *lp;
386 >        LUENT   *lp;
387  
388          lp = lu_find(&rdispatch, name);
389          if (lp->key != NULL) {
# Line 356 | Line 397 | int    (*func)();
397  
398  
399   char *
400 < getvertid(vname, vp)            /* get/set vertex ID for this point */
401 < char    *vname;
402 < FVECT   vp;
400 > getvertid(              /* get/set vertex ID for this point */
401 >        char    *vname,
402 >        FVECT   vp
403 > )
404   {
405          static char     vkey[VKLEN];
406 <        register LUENT  *lp;
407 <        register int    i, vndx;
406 >        LUENT   *lp;
407 >        int     i, vndx;
408  
409          vclock++;                       /* increment counter */
410          mkvkey(vkey, vp);
# Line 400 | Line 442 | memerr:
442  
443  
444   int
445 < o_unsupported(mod, typ, id, fa)         /* mark unsupported primitive */
446 < char    *mod, *typ, *id;
447 < FUNARGS *fa;
445 > o_unsupported(          /* mark unsupported primitive */
446 >        char    *mod,
447 >        char    *typ,
448 >        char    *id,
449 >        FUNARGS *fa
450 > )
451   {
452 <        register int    i;
452 >        int     i;
453  
454          fputs("\n# Unsupported RADIANCE primitive:\n", stdout);
455          printf("# %s %s %s", mod, typ, id);
# Line 427 | Line 472 | FUNARGS        *fa;
472  
473  
474   int
475 < o_face(mod, typ, id, fa)                /* print out a polygon */
476 < char    *mod, *typ, *id;
477 < FUNARGS *fa;
475 > o_face(         /* print out a polygon */
476 >        char    *mod,
477 >        char    *typ,
478 >        char    *id,
479 >        FUNARGS *fa
480 > )
481   {
482 <        char    entbuf[2048];
483 <        register char   *cp;
484 <        register int    i;
482 >        char    entbuf[2048], *linestart;
483 >        char    *cp;
484 >        int     i;
485  
486 <        if (fa->nfargs < 9 | fa->nfargs % 3)
486 >        if ((fa->nfargs < 9) | (fa->nfargs % 3))
487                  return(-1);
488          setmat(mod);
489          setobj(id);
490 <        cp = entbuf;
490 >        cp = linestart = entbuf;
491          *cp++ = 'f';
492          for (i = 0; i < fa->nfargs; i += 3) {
493                  *cp++ = ' ';
494 +                if (cp - linestart > 72) {
495 +                        *cp++ = '\\'; *cp++ = '\n';
496 +                        linestart = cp;
497 +                        *cp++ = ' '; *cp++ = ' ';
498 +                }
499                  getvertid(cp, fa->farg + i);
500                  while (*cp)
501                          cp++;
# Line 453 | Line 506 | FUNARGS        *fa;
506  
507  
508   int
509 < o_cone(mod, typ, id, fa)        /* print out a cone */
510 < char    *mod, *typ, *id;
511 < register FUNARGS        *fa;
509 > o_cone( /* print out a cone */
510 >        char    *mod,
511 >        char    *typ,
512 >        char    *id,
513 >        FUNARGS *fa
514 > )
515   {
516          char    v1[6], v2[6];
517  
# Line 476 | Line 532 | register FUNARGS       *fa;
532  
533  
534   int
535 < o_sphere(mod, typ, id, fa)      /* print out a sphere */
536 < char    *mod, *typ, *id;
537 < register FUNARGS        *fa;
535 > o_sphere(       /* print out a sphere */
536 >        char    *mod,
537 >        char    *typ,
538 >        char    *id,
539 >        FUNARGS *fa
540 > )
541   {
542          char    cent[6];
543  
# Line 493 | Line 552 | register FUNARGS       *fa;
552  
553  
554   int
555 < o_cylinder(mod, typ, id, fa)    /* print out a cylinder */
556 < char    *mod, *typ, *id;
557 < register FUNARGS        *fa;
555 > o_cylinder(     /* print out a cylinder */
556 >        char    *mod,
557 >        char    *typ,
558 >        char    *id,
559 >        FUNARGS *fa
560 > )
561   {
562          char    v1[6], v2[6];
563  
# Line 512 | Line 574 | register FUNARGS       *fa;
574  
575  
576   int
577 < o_ring(mod, typ, id, fa)        /* print out a ring */
578 < char    *mod, *typ, *id;
579 < register FUNARGS        *fa;
577 > o_ring( /* print out a ring */
578 >        char    *mod,
579 >        char    *typ,
580 >        char    *id,
581 >        FUNARGS *fa
582 > )
583   {
584          if (fa->nfargs != 8)
585                  return(-1);
# Line 535 | Line 600 | register FUNARGS       *fa;
600  
601  
602   int
603 < o_instance(mod, typ, id, fa)    /* convert an instance */
604 < char    *mod, *typ, *id;
605 < FUNARGS *fa;
603 > o_instance(     /* convert an instance (or mesh) */
604 >        char    *mod,
605 >        char    *typ,
606 >        char    *id,
607 >        FUNARGS *fa
608 > )
609   {
610 <        register int    i;
611 <        register char   *cp;
610 >        int     i;
611 >        char    *cp;
612          char    *start = NULL, *end = NULL;
613          /*
614           * We don't really know how to do this, so we just create
# Line 576 | Line 644 | FUNARGS        *fa;
644  
645  
646   int
647 < o_illum(mod, typ, id, fa)       /* convert an illum material */
648 < char    *mod, *typ, *id;
649 < FUNARGS *fa;
647 > o_illum(        /* convert an illum material */
648 >        char    *mod,
649 >        char    *typ,
650 >        char    *id,
651 >        FUNARGS *fa
652 > )
653   {
654          if (fa->nsargs == 1 && strcmp(fa->sarg[0], VOIDID)) {
655                  newmat(id, fa->sarg[0]);        /* just create alias */
# Line 592 | Line 663 | FUNARGS        *fa;
663  
664  
665   int
666 < o_plastic(mod, typ, id, fa)     /* convert a plastic material */
667 < char    *mod, *typ, *id;
668 < register FUNARGS        *fa;
666 > o_plastic(      /* convert a plastic material */
667 >        char    *mod,
668 >        char    *typ,
669 >        char    *id,
670 >        FUNARGS *fa
671 > )
672   {
673          COLOR   cxyz, rrgb;
674          double  d;
# Line 607 | Line 681 | register FUNARGS       *fa;
681          puts("\tc");                            /* put diffuse component */
682          d = cxyz[0] + cxyz[1] + cxyz[2];
683          if (d > FTINY)
684 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
685 <        printf("\trd %.4f\n", cxyz[1]*(1. - fa->farg[3]));
684 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
685 >        printf("\trd %.6f\n", cxyz[1]*(1. - fa->farg[3]));
686          if (fa->farg[3] > FTINY) {              /* put specular component */
687                  puts("\tc");
688 <                printf("\trs %.4f %.4f\n", fa->farg[3],
688 >                printf("\trs %.6f %.6f\n", fa->farg[3],
689                                  typ[7]=='2' ? .5*(fa->farg[4] + fa->farg[5]) :
690                                                  fa->farg[4]);
691          }
# Line 620 | Line 694 | register FUNARGS       *fa;
694  
695  
696   int
697 < o_metal(mod, typ, id, fa)       /* convert a metal material */
698 < char    *mod, *typ, *id;
699 < register FUNARGS        *fa;
697 > o_metal(        /* convert a metal material */
698 >        char    *mod,
699 >        char    *typ,
700 >        char    *id,
701 >        FUNARGS *fa
702 > )
703   {
704          COLOR   cxyz, rrgb;
705          double  d;
# Line 635 | Line 712 | register FUNARGS       *fa;
712          puts("\tc");                            /* put diffuse component */
713          d = cxyz[0] + cxyz[1] + cxyz[2];
714          if (d > FTINY)
715 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
716 <        printf("\trd %.4f\n", cxyz[1]*(1. - fa->farg[3]));
715 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
716 >        printf("\trd %.6f\n", cxyz[1]*(1. - fa->farg[3]));
717                                                  /* put specular component */
718 <        printf("\trs %.4f %.4f\n", cxyz[1]*fa->farg[3],
718 >        printf("\trs %.6f %.6f\n", cxyz[1]*fa->farg[3],
719                          typ[5]=='2' ? .5*(fa->farg[4] + fa->farg[5]) :
720                                          fa->farg[4]);
721          return(0);
# Line 646 | Line 723 | register FUNARGS       *fa;
723  
724  
725   int
726 < o_glass(mod, typ, id, fa)       /* convert a glass material */
727 < char    *mod, *typ, *id;
728 < register FUNARGS        *fa;
726 > o_glass(        /* convert a glass material */
727 >        char    *mod,
728 >        char    *typ,
729 >        char    *id,
730 >        FUNARGS *fa
731 > )
732   {
733          COLOR   cxyz, rrgb, trgb;
734          double  nrfr = 1.52, F, d;
735 <        register int    i;
735 >        int     i;
736  
737          if (fa->nfargs != 3 && fa->nfargs != 4)
738                  return(-1);
# Line 672 | Line 752 | register FUNARGS       *fa;
752          puts("\tc");
753          d = cxyz[0] + cxyz[1] + cxyz[2];
754          if (d > FTINY)
755 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
756 <        printf("\trs %.4f 0\n", cxyz[1]);
755 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
756 >        printf("\trs %.6f 0\n", cxyz[1]);
757          rgb_cie(cxyz, trgb);                    /* put transmitted component */
758          puts("\tc");
759          d = cxyz[0] + cxyz[1] + cxyz[2];
760          if (d > FTINY)
761 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
762 <        printf("\tts %.4f 0\n", cxyz[1]);
761 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
762 >        printf("\tts %.6f 0\n", cxyz[1]);
763          return(0);
764   }
765  
766  
767   int
768 < o_dielectric(mod, typ, id, fa)  /* convert a dielectric material */
769 < char    *mod, *typ, *id;
770 < register FUNARGS        *fa;
768 > o_dielectric(   /* convert a dielectric material */
769 >        char    *mod,
770 >        char    *typ,
771 >        char    *id,
772 >        FUNARGS *fa
773 > )
774   {
775          COLOR   cxyz, trgb;
776          double  F, d;
777 <        register int    i;
777 >        int     i;
778  
779          if (fa->nfargs != 5)
780                  return(-1);
# Line 703 | Line 786 | register FUNARGS       *fa;
786          printf("\tir %f 0\n", fa->farg[3]);     /* put index of refraction */
787          printf("\tsides 1\n");
788          puts("\tc");                            /* put reflected component */
789 <        printf("\trs %.4f 0\n", F);
789 >        printf("\trs %.6f 0\n", F);
790          rgb_cie(cxyz, trgb);                    /* put transmitted component */
791          puts("\tc");
792          d = cxyz[0] + cxyz[1] + cxyz[2];
793          if (d > FTINY)
794 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
795 <        printf("\tts %.4f 0\n", cxyz[1]);
794 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
795 >        printf("\tts %.6f 0\n", cxyz[1]);
796          return(0);
797   }
798  
799  
800   int
801 < o_mirror(mod, typ, id, fa)      /* convert a mirror material */
802 < char    *mod, *typ, *id;
803 < register FUNARGS        *fa;
801 > o_mirror(       /* convert a mirror material */
802 >        char    *mod,
803 >        char    *typ,
804 >        char    *id,
805 >        FUNARGS *fa
806 > )
807   {
808          COLOR   cxyz, rrgb;
809          double  d;
# Line 734 | Line 820 | register FUNARGS       *fa;
820          puts("\tc");                            /* put specular component */
821          d = cxyz[0] + cxyz[1] + cxyz[2];
822          if (d > FTINY)
823 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
824 <        printf("\trs %.4f 0\n", cxyz[1]);
823 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
824 >        printf("\trs %.6f 0\n", cxyz[1]);
825          return(0);
826   }
827  
828  
829   int
830 < o_trans(mod, typ, id, fa)       /* convert a trans material */
831 < char    *mod, *typ, *id;
832 < register FUNARGS        *fa;
830 > o_trans(        /* convert a trans material */
831 >        char    *mod,
832 >        char    *typ,
833 >        char    *id,
834 >        FUNARGS *fa
835 > )
836   {
837          COLOR   cxyz, rrgb;
838          double  rough, trans, tspec, d;
839  
840 <        if (typ[4] == '2') {            /* trans2 */
840 >        if (typ[5] == '2') {            /* trans2 */
841                  if (fa->nfargs != 8)
842                          return(-1);
843                  rough = .5*(fa->farg[4] + fa->farg[5]);
# Line 767 | Line 856 | register FUNARGS       *fa;
856          puts("\tc");                            /* put transmitted diffuse */
857          d = cxyz[0] + cxyz[1] + cxyz[2];
858          if (d > FTINY)
859 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
860 <        printf("\ttd %.4f\n", cxyz[1]*trans*(1. - fa->farg[3])*(1. - tspec));
859 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
860 >        printf("\ttd %.6f\n", cxyz[1]*trans*(1. - fa->farg[3])*(1. - tspec));
861                                                  /* put transmitted specular */
862 <        printf("\tts %.4f %.4f\n", cxyz[1]*trans*tspec*(1. - fa->farg[3]), rough);
862 >        printf("\tts %.6f %.6f\n", cxyz[1]*trans*tspec*(1. - fa->farg[3]), rough);
863                                                  /* put reflected diffuse */
864 <        printf("\trd %.4f\n", cxyz[1]*(1. - fa->farg[3])*(1. - trans));
864 >        printf("\trd %.6f\n", cxyz[1]*(1. - fa->farg[3])*(1. - trans));
865          puts("\tc");                            /* put reflected specular */
866 <        printf("\trs %.4f %.4f\n", fa->farg[3], rough);
866 >        printf("\trs %.6f %.6f\n", fa->farg[3], rough);
867          return(0);
868   }
869  
870  
871   int
872 < o_light(mod, typ, id, fa)               /* convert a light type */
873 < char    *mod, *typ, *id;
874 < register FUNARGS        *fa;
872 > o_light(                /* convert a light type */
873 >        char    *mod,
874 >        char    *typ,
875 >        char    *id,
876 >        FUNARGS *fa
877 > )
878   {
879          COLOR   cxyz, rrgb;
880          double  d;
# Line 795 | Line 887 | register FUNARGS       *fa;
887          d = cxyz[0] + cxyz[1] + cxyz[2];
888          puts("\tc");
889          if (d > FTINY)
890 <                printf("\t\tcxy %.4f %.4f\n", cxyz[0]/d, cxyz[1]/d);
890 >                printf("\t\tcxy %.6f %.6f\n", cxyz[0]/d, cxyz[1]/d);
891          printf("\ted %.4g\n", cxyz[1]*(PI*WHTEFFICACY));
892          return(0);
893   }

Diff Legend

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