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

Comparing ray/src/cv/mgflib/parser.c (file contents):
Revision 1.10 by greg, Wed Jun 29 16:15:20 1994 UTC vs.
Revision 1.16 by greg, Tue Apr 18 15:53:26 1995 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1994 Regents of the University of California */
1 > /* Copyright (c) 1995 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 59 | Line 59 | static int     e_any_toss(),           /* discard unneeded entity *
59                  e_ies(),                /* IES luminaire file */
60                  e_include(),            /* include file */
61                  e_sph(),                /* sphere */
62 +                e_cct(),                /* color temperature */
63                  e_cmix(),               /* color mixtures */
64                  e_cspec(),              /* color spectra */
65                  e_cyl(),                /* cylinder */
# Line 119 | Line 120 | mg_init()                      /* initialize alternate entity handlers */
120          if (mg_ehand[MG_E_COLOR] != NULL) {
121                  if (mg_ehand[MG_E_CMIX] == NULL) {
122                          mg_ehand[MG_E_CMIX] = e_cmix;
123 <                        ineed |= 1<<MG_E_COLOR|1<<MG_E_CXY|1<<MG_E_CSPEC|1<<MG_E_CMIX;
123 >                        ineed |= 1<<MG_E_COLOR|1<<MG_E_CXY|1<<MG_E_CSPEC|1<<MG_E_CMIX|1<<MG_E_CCT;
124                  }
125                  if (mg_ehand[MG_E_CSPEC] == NULL) {
126                          mg_ehand[MG_E_CSPEC] = e_cspec;
127 <                        ineed |= 1<<MG_E_COLOR|1<<MG_E_CXY|1<<MG_E_CSPEC|1<<MG_E_CMIX;
127 >                        ineed |= 1<<MG_E_COLOR|1<<MG_E_CXY|1<<MG_E_CSPEC|1<<MG_E_CMIX|1<<MG_E_CCT;
128                  }
129 +                if (mg_ehand[MG_E_CCT] == NULL) {
130 +                        mg_ehand[MG_E_CCT] = e_cct;
131 +                        ineed |= 1<<MG_E_COLOR|1<<MG_E_CXY|1<<MG_E_CSPEC|1<<MG_E_CMIX|1<<MG_E_CCT;
132 +                }
133          }
134                                          /* check for consistency */
135          if (mg_ehand[MG_E_FACE] != NULL)
# Line 133 | Line 138 | mg_init()                      /* initialize alternate entity handlers */
138                          mg_ehand[MG_E_CMIX] != NULL)
139                  uneed |= 1<<MG_E_COLOR;
140          if (mg_ehand[MG_E_RD] != NULL || mg_ehand[MG_E_TD] != NULL ||
141 +                        mg_ehand[MG_E_IR] != NULL ||
142                          mg_ehand[MG_E_ED] != NULL ||
143                          mg_ehand[MG_E_RS] != NULL ||
144 <                        mg_ehand[MG_E_TS] != NULL)
144 >                        mg_ehand[MG_E_TS] != NULL ||
145 >                        mg_ehand[MG_E_SIDES] != NULL)
146                  uneed |= 1<<MG_E_MATERIAL;
147          for (i = 0; i < MG_NENTITIES; i++)
148                  if (uneed & 1<<i && mg_ehand[i] == NULL) {
# Line 158 | Line 165 | mg_init()                      /* initialize alternate entity handlers */
165                  e_supp[MG_E_CSPEC] = c_hcolor;
166          if (ineed & 1<<MG_E_CMIX && mg_ehand[MG_E_CMIX] != c_hcolor)
167                  e_supp[MG_E_CMIX] = c_hcolor;
168 +        if (ineed & 1<<MG_E_CCT && mg_ehand[MG_E_CCT] != c_hcolor)
169 +                e_supp[MG_E_CCT] = c_hcolor;
170                                          /* discard remaining entities */
171          for (i = 0; i < MG_NENTITIES; i++)
172                  if (mg_ehand[i] == NULL)
# Line 165 | Line 174 | mg_init()                      /* initialize alternate entity handlers */
174   }
175  
176  
168 –
177   int
178   mg_entity(name)                 /* get entity number from its name */
179   char    *name;
# Line 211 | Line 219 | register MG_FCTXT      *ctx;
219   char    *fn;
220   {
221          static int      nfids;
214 –        int     olen;
222          register char   *cp;
223  
224          ctx->fid = ++nfids;
# Line 224 | Line 231 | char   *fn;
231                  return(MG_OK);
232          }
233                                          /* get name relative to this context */
234 <        if (mg_file != NULL &&
228 <                        (cp = strrchr(mg_file->fname, '/')) != NULL)
229 <                olen = cp - mg_file->fname + 1;
230 <        else
231 <                olen = 0;
232 <        if (olen)
234 >        if (mg_file != NULL && (cp = strrchr(mg_file->fname, '/')) != NULL) {
235                  strcpy(ctx->fname, mg_file->fname);
236 <        strcpy(ctx->fname+olen, fn);
236 >                strcpy(ctx->fname+(cp-mg_file->fname+1), fn);
237 >        } else
238 >                strcpy(ctx->fname, fn);
239          ctx->fp = fopen(ctx->fname, "r");
240          if (ctx->fp == NULL)
241                  return(MG_ENOFILE);
# Line 382 | Line 386 | char   **av;
386   {
387          char    *xfarg[MG_MAXARGC];
388          MG_FCTXT        ictx;
389 +        XF_SPEC *xf_orig = xf_context;
390          int     rv;
391  
392          if (ac < 2)
# Line 398 | Line 403 | char   **av;
403                  if ((rv = mg_handle(MG_E_XF, ac-1, xfarg)) != MG_OK)
404                          return(rv);
405          }
406 <        while (!feof(mg_file->fp)) {
406 >        do {
407                  while (mg_read())
408                          if ((rv = mg_parse()) != MG_OK) {
409                                  fprintf(stderr, "%s: %d: %s:\n%s", ictx.fname,
# Line 410 | Line 415 | char   **av;
415                  if (ac > 2)
416                          if ((rv = mg_handle(MG_E_XF, 1, xfarg)) != MG_OK)
417                                  return(rv);
418 <        }
418 >        } while (xf_context != xf_orig);
419          mg_close();
420          return(MG_OK);
421   }
# Line 865 | Line 870 | int    ac;
870   char    **av;
871   {
872          static char     p[3][24];
873 <        static char     *vent[4] = {mg_ename[MG_E_VERTEX],NULL,"="};
873 >        static char     *vent[5] = {mg_ename[MG_E_VERTEX],NULL,"="};
874          static char     *pent[5] = {mg_ename[MG_E_POINT],p[0],p[1],p[2]};
875 +        static char     *znorm[5] = {mg_ename[MG_E_NORMAL],"0","0","0"};
876          char    *newav[MG_MAXARGC], nvn[MG_MAXARGC-1][8];
877          double  length;
878 +        int     hasnorm;
879          FVECT   v1, v2, v3, norm;
880          register C_VERTEX       *cv;
881          C_VERTEX        *cv0;
882          int     rv;
883          register int    i, j;
884 <
884 >                                                /* check arguments */
885          if (ac < 5)
886                  return(MG_EARGC);
887          if (!isflt(av[ac-1]))
# Line 882 | Line 889 | char   **av;
889          length = atof(av[ac-1]);
890          if (length <= FTINY && length >= -FTINY)
891                  return(MG_EILL);
892 <                                        /* do bottom face */
886 <        newav[0] = mg_ename[MG_E_FACE];
887 <        for (i = 1; i < ac-1; i++)
888 <                newav[i] = av[i];
889 <        newav[i] = NULL;
890 <        if ((rv = mg_handle(MG_E_FACE, i, newav)) != MG_OK)
891 <                return(rv);
892 <                                        /* compute face normal */
892 >                                                /* compute face normal */
893          if ((cv0 = c_getvert(av[1])) == NULL)
894                  return(MG_EUNDEF);
895 +        hasnorm = 0;
896          norm[0] = norm[1] = norm[2] = 0.;
897          v1[0] = v1[1] = v1[2] = 0.;
898          for (i = 2; i < ac-1; i++) {
899                  if ((cv = c_getvert(av[i])) == NULL)
900                          return(MG_EUNDEF);
901 +                hasnorm += !is0vect(cv->n);
902                  v2[0] = cv->p[0] - cv0->p[0];
903                  v2[1] = cv->p[1] - cv0->p[1];
904                  v2[2] = cv->p[2] - cv0->p[2];
# Line 908 | Line 910 | char   **av;
910          }
911          if (normalize(norm) == 0.)
912                  return(MG_EILL);
913 <                                        /* create moved vertices */
913 >                                                /* create moved vertices */
914          for (i = 1; i < ac-1; i++) {
915                  sprintf(nvn[i-1], "_pv%d", i);
916                  vent[1] = nvn[i-1];
917 <                if ((rv = mg_handle(MG_E_VERTEX, 3, vent)) != MG_OK)
917 >                vent[3] = av[i];
918 >                if ((rv = mg_handle(MG_E_VERTEX, 4, vent)) != MG_OK)
919                          return(rv);
920                  cv = c_getvert(av[i]);          /* checked above */
921                  for (j = 0; j < 3; j++)
922                          sprintf(p[j], FLTFMT, cv->p[j] - length*norm[j]);
923                  if ((rv = mg_handle(MG_E_POINT, 4, pent)) != MG_OK)
924                          return(rv);
922 –                newav[ac-1-i] = nvn[i-1];       /* reverse */
925          }
926 <                                                /* do top face */
927 <        if ((rv = mg_handle(MG_E_FACE, ac-1, newav)) != MG_OK)
926 <                return(rv);
926 >                                                /* make faces */
927 >        newav[0] = mg_ename[MG_E_FACE];
928                                                  /* do the side faces */
929          newav[5] = NULL;
930          newav[3] = av[ac-2];
# Line 936 | Line 937 | char   **av;
937                  newav[3] = newav[2];
938                  newav[4] = newav[1];
939          }
940 +                                                /* do top face */
941 +        for (i = 1; i < ac-1; i++) {
942 +                if (hasnorm) {                  /* zero normals */
943 +                        vent[1] = nvn[i-1];
944 +                        if ((rv = mg_handle(MG_E_VERTEX, 2, vent)) != MG_OK)
945 +                                return(rv);
946 +                        if ((rv = mg_handle(MG_E_NORMAL, 4, znorm)) != MG_OK)
947 +                                return(rv);
948 +                }
949 +                newav[ac-1-i] = nvn[i-1];       /* reverse */
950 +        }
951 +        if ((rv = mg_handle(MG_E_FACE, ac-1, newav)) != MG_OK)
952 +                return(rv);
953 +                                                /* do bottom face */
954 +        if (hasnorm)
955 +                for (i = 1; i < ac-1; i++) {
956 +                        vent[1] = nvn[i-1];
957 +                        vent[3] = av[i];
958 +                        if ((rv = mg_handle(MG_E_VERTEX, 4, vent)) != MG_OK)
959 +                                return(rv);
960 +                        if ((rv = mg_handle(MG_E_NORMAL, 4, znorm)) != MG_OK)
961 +                                return(rv);
962 +                        newav[i] = nvn[i-1];
963 +                }
964 +        else
965 +                for (i = 1; i < ac-1; i++)
966 +                        newav[i] = av[i];
967 +        newav[i] = NULL;
968 +        if ((rv = mg_handle(MG_E_FACE, i, newav)) != MG_OK)
969 +                return(rv);
970          return(MG_OK);
971   }
972  
973  
974   static int
975 < e_cspec(ac, av)                 /* handle spectral color */
945 < int     ac;
946 < char    **av;
975 > put_cxy()                       /* put out current xy chromaticities */
976   {
977          static char     xbuf[24], ybuf[24];
978          static char     *ccom[4] = {mg_ename[MG_E_CXY], xbuf, ybuf};
979          int     rv;
980  
981 +        sprintf(xbuf, "%.4f", c_ccolor->cx);
982 +        sprintf(ybuf, "%.4f", c_ccolor->cy);
983 +        if ((rv = mg_handle(MG_E_CXY, 3, ccom)) != MG_OK)
984 +                return(rv);
985 +        return(MG_OK);
986 + }
987 +
988 +
989 + static int
990 + put_cspec()                     /* put out current color spectrum */
991 + {
992 +        char    wl[2][6], vbuf[C_CNSS][24];
993 +        char    *newav[C_CNSS+4];
994 +        double  sf;
995 +        register int    i;
996 +
997 +        if (mg_ehand[MG_E_CSPEC] != c_hcolor) {
998 +                sprintf(wl[0], "%d", C_CMINWL);
999 +                sprintf(wl[1], "%d", C_CMAXWL);
1000 +                newav[0] = mg_ename[MG_E_CSPEC];
1001 +                newav[1] = wl[0];
1002 +                newav[2] = wl[1];
1003 +                sf = (double)C_CNSS / c_ccolor->ssum;
1004 +                for (i = 0; i < C_CNSS; i++) {
1005 +                        sprintf(vbuf[i], "%.4f", sf*c_ccolor->ssamp[i]);
1006 +                        newav[i+3] = vbuf[i];
1007 +                }
1008 +                newav[C_CNSS+3] = NULL;
1009 +                if ((i = mg_handle(MG_E_CSPEC, C_CNSS+3, newav)) != MG_OK)
1010 +                        return(i);
1011 +        }
1012 +        return(MG_OK);
1013 + }
1014 +
1015 +
1016 + static int
1017 + e_cspec(ac, av)                 /* handle spectral color */
1018 + int     ac;
1019 + char    **av;
1020 + {
1021 +                                /* convert to xy chromaticity */
1022          c_ccvt(c_ccolor, C_CSXY);
1023                                  /* if it's really their handler, use it */
1024 <        if (mg_ehand[MG_E_CXY] != c_hcolor) {
1025 <                sprintf(xbuf, "%.4f", c_ccolor->cx);
956 <                sprintf(ybuf, "%.4f", c_ccolor->cy);
957 <                if ((rv = mg_handle(MG_E_CXY, 3, ccom)) != MG_OK)
958 <                        return(rv);
959 <        }
1024 >        if (mg_ehand[MG_E_CXY] != c_hcolor)
1025 >                return(put_cxy());
1026          return(MG_OK);
1027   }
1028  
# Line 966 | Line 1032 | e_cmix(ac, av)                 /* handle mixing of colors */
1032   int     ac;
1033   char    **av;
1034   {
969 –        char    wl[2][6], vbuf[C_CNSS][24];
970 –        char    *newav[C_CNSS+4];
971 –        int     rv;
972 –        register int    i;
1035          /*
1036           * Contorted logic works as follows:
1037           *      1. the colors are already mixed in c_hcolor() support function
# Line 980 | Line 1042 | char   **av;
1042           */
1043          if (mg_ehand[MG_E_CSPEC] == e_cspec)
1044                  c_ccvt(c_ccolor, C_CSXY);
1045 <        else if (c_ccolor->flags & C_CDSPEC) {
1046 <                if (mg_ehand[MG_E_CSPEC] != c_hcolor) {
1047 <                        sprintf(wl[0], "%d", C_CMINWL);
1048 <                        sprintf(wl[1], "%d", C_CMAXWL);
1049 <                        newav[0] = mg_ename[MG_E_CSPEC];
1050 <                        newav[1] = wl[0];
1051 <                        newav[2] = wl[1];
1052 <                        for (i = 0; i < C_CNSS; i++) {
1053 <                                sprintf(vbuf[i], "%.6f",
1054 <                                                (double)c_ccolor->ssamp[i] /
1055 <                                                c_ccolor->ssum);
1056 <                                newav[i+3] = vbuf[i];
1057 <                        }
1058 <                        newav[C_CNSS+3] = NULL;
1059 <                        if ((rv = mg_handle(MG_E_CSPEC, C_CNSS+3, newav)) != MG_OK)
1060 <                                return(rv);
1061 <                }
1062 <                return(MG_OK);
1063 <        }
1064 <        if (mg_ehand[MG_E_CXY] != c_hcolor) {
1065 <                sprintf(vbuf[0], "%.4f", c_ccolor->cx);
1066 <                sprintf(vbuf[1], "%.4f", c_ccolor->cy);
1067 <                newav[0] = mg_ename[MG_E_CXY];
1068 <                newav[1] = vbuf[0];
1007 <                newav[2] = vbuf[1];
1008 <                newav[3] = NULL;
1009 <                if ((rv = mg_handle(MG_E_CXY, 3, newav)) != MG_OK)
1010 <                        return(rv);
1011 <        }
1045 >        else if (c_ccolor->flags & C_CDSPEC)
1046 >                return(put_cspec());
1047 >        if (mg_ehand[MG_E_CXY] != c_hcolor)
1048 >                return(put_cxy());
1049 >        return(MG_OK);
1050 > }
1051 >
1052 >
1053 > static int
1054 > e_cct(ac, av)                   /* handle color temperature */
1055 > int     ac;
1056 > char    **av;
1057 > {
1058 >        /*
1059 >         * Logic is similar to e_cmix here.  Support handler has already
1060 >         * converted temperature to spectral color.  Put it out as such
1061 >         * if they support it, otherwise convert to xy chromaticity and
1062 >         * put it out if they handle it.
1063 >         */
1064 >        if (mg_ehand[MG_E_CSPEC] != e_cspec)
1065 >                return(put_cspec());
1066 >        c_ccvt(c_ccolor, C_CSXY);
1067 >        if (mg_ehand[MG_E_CXY] != c_hcolor)
1068 >                return(put_cxy());
1069          return(MG_OK);
1070   }

Diff Legend

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