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.2 by greg, Wed Jun 22 15:33:47 1994 UTC vs.
Revision 1.4 by greg, Fri Jun 24 09:32:51 1994 UTC

# Line 53 | Line 53 | int    mg_nqcdivs = MG_NQCD;   /* number of divisions per q
53  
54   /* temporary settings for testing */
55   #define e_ies e_any_toss
56 + #define e_cmix e_any_toss
57 + #define e_cspec e_any_toss
58                                  /* alternate handler routines */
59  
60   static int      e_any_toss(),           /* discard unneeded entity */
61                  e_ies(),                /* IES luminaire file */
62                  e_include(),            /* include file */
63                  e_sph(),                /* sphere */
64 +                e_cmix(),               /* color mixtures */
65 +                e_cspec();              /* color spectra */
66                  e_cyl(),                /* cylinder */
67                  e_cone(),               /* cone */
68 +                e_prism(),              /* prism */
69                  e_ring(),               /* ring */
70                  e_torus();              /* torus */
71  
# Line 103 | Line 108 | mg_init()                      /* initialize alternate entity handlers */
108                  ineed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX;
109          } else
110                  uneed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX|1<<MG_E_XF;
111 +        if (mg_ehand[MG_E_PRISM] == NULL) {
112 +                mg_ehand[MG_E_PRISM] = e_prism;
113 +                ineed |= 1<<MG_E_POINT|1<<MG_E_VERTEX;
114 +        } else
115 +                uneed |= 1<<MG_E_POINT|1<<MG_E_VERTEX|1<<MG_E_XF;
116          if (mg_ehand[MG_E_TORUS] == NULL) {
117                  mg_ehand[MG_E_TORUS] = e_torus;
118                  ineed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX;
119          } else
120                  uneed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX|1<<MG_E_XF;
121 +        if (mg_ehand[MG_E_COLOR] != NULL) {
122 +                if (mg_ehand[MG_E_CMIX] == NULL)
123 +                        mg_ehand[MG_E_CMIX] = e_cmix;
124 +                if (mg_ehand[MG_E_CSPEC] == NULL)
125 +                        mg_ehand[MG_E_CSPEC] = e_cspec;
126 +        }
127                                          /* check for consistency */
128          if (mg_ehand[MG_E_FACE] != NULL)
129                  uneed |= 1<<MG_E_POINT|1<<MG_E_VERTEX|1<<MG_E_XF;
# Line 517 | Line 533 | char   **av;
533                  return(MG_EARGC);
534          if ((cv = c_getvert(av[1])) == NULL)
535                  return(MG_EUNDEF);
536 <        if (cv->n[0]==0. && cv->n[1]==0. && cv->n[2]==0.)
536 >        if (is0vect(cv->n))
537                  return(MG_EILL);
538          if (!isflt(av[2]) || !isflt(av[3]))
539                  return(MG_ETYPE);
540          minrad = atof(av[2]);
541 +        round0(minrad);
542          maxrad = atof(av[3]);
543                                          /* check orientation */
544          if (minrad > 0.)
# Line 629 | Line 646 | char   **av;
646                  return(MG_EARGC);
647          if ((cv = c_getvert(av[1])) == NULL)
648                  return(MG_EUNDEF);
649 <        if (cv->n[0]==0. && cv->n[1]==0. && cv->n[2]==0.)
649 >        if (is0vect(cv->n))
650                  return(MG_EILL);
651          if (!isflt(av[2]) || !isflt(av[3]))
652                  return(MG_ETYPE);
653          minrad = atof(av[2]);
654 +        round0(minrad);
655          maxrad = atof(av[3]);
656          if (minrad < 0. || maxrad <= minrad)
657                  return(MG_EILL);
# Line 659 | Line 677 | char   **av;
677                                  sprintf(p3[j], FLTFMT, cv->p[j] +
678                                                  maxrad*u[j]*cos(theta) +
679                                                  maxrad*v[j]*sin(theta));
680 <                        if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
680 >                        if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
681                                  return(rv);
682                          if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
683                                  return(rv);
# Line 685 | Line 703 | char   **av;
703                                  sprintf(p3[j], FLTFMT, cv->p[j] + maxrad*d);
704                                  sprintf(p4[j], FLTFMT, cv->p[j] + minrad*d);
705                          }
706 <                        if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
706 >                        if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
707                                  return(rv);
708                          if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
709                                  return(rv);
710 <                        if ((rv = handle_it(MG_E_VERTEX, 3, v4ent)) != MG_OK)
710 >                        if ((rv = handle_it(MG_E_VERTEX, 2, v4ent)) != MG_OK)
711                                  return(rv);
712                          if ((rv = handle_it(MG_E_POINT, 4, p4ent)) != MG_OK)
713                                  return(rv);
# Line 734 | Line 752 | char   **av;
752          if (!isflt(av[2]) || !isflt(av[4]))
753                  return(MG_ETYPE);
754          rad1 = atof(av[2]);
755 +        round0(rad1);
756          rad2 = atof(av[4]);
757 +        round0(rad2);
758          if (rad1 == 0.) {
759                  if (rad2 == 0.)
760                          return(MG_EILL);
# Line 758 | Line 778 | char   **av;
778          if ((d = normalize(w)) == 0.)
779                  return(MG_EILL);
780          n1off = n2off = (rad2 - rad1)/d;
781 <        if (warpconends)                /* hack for e_sph and e_torus */
782 <                n2off = tan(atan(n2off)-(PI/4)/mg_nqcdivs);
783 <        n2off = sgn*n2off;
781 >        if (warpconends) {              /* hack for e_sph and e_torus */
782 >                d = atan(n2off) - (PI/4)/mg_nqcdivs;
783 >                if (d <= -PI/2+FTINY)
784 >                        n2off = -FHUGE;
785 >                else
786 >                        n2off = tan(d);
787 >        }
788          make_axes(u, v, w);
789          for (j = 0; j < 3; j++) {
790                  sprintf(p3[j], FLTFMT, cv2->p[j] + rad2*u[j]);
791 <                sprintf(n3[j], FLTFMT, u[j] + w[j]*n2off);
791 >                if (n2off <= -FHUGE)
792 >                        sprintf(n3[j], FLTFMT, -w[j]);
793 >                else
794 >                        sprintf(n3[j], FLTFMT, u[j] + w[j]*n2off);
795          }
796          if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
797                  return(rv);
# Line 787 | Line 814 | char   **av;
814                          for (j = 0; j < 3; j++) {
815                                  d = u[j]*cos(theta) + v[j]*sin(theta);
816                                  sprintf(p3[j], FLTFMT, cv2->p[j] + rad2*d);
817 <                                sprintf(n3[j], FLTFMT, d + w[j]*n2off);
817 >                                if (n2off > -FHUGE)
818 >                                        sprintf(n3[j], FLTFMT, d + w[j]*n2off);
819                          }
820 <                        if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
820 >                        if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
821                                  return(rv);
822                          if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
823                                  return(rv);
824 <                        if ((rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
824 >                        if (n2off > -FHUGE &&
825 >                        (rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
826                                  return(rv);
827                          if ((rv = handle_it(MG_E_FACE, 4, fent)) != MG_OK)
828                                  return(rv);
829                  }
830          } else {                        /* quads */
831                  v1ent[3] = "_cv4";
832 <                if (warpconends)                /* hack for e_sph and e_torus */
833 <                        n1off = tan(atan(n1off)+(PI/4)/mg_nqcdivs);
834 <                n1off = sgn*n1off;
832 >                if (warpconends) {              /* hack for e_sph and e_torus */
833 >                        d = atan(n1off) + (PI/4)/mg_nqcdivs;
834 >                        if (d >= PI/2-FTINY)
835 >                                n1off = FHUGE;
836 >                        else
837 >                                n1off = tan(atan(n1off)+(PI/4)/mg_nqcdivs);
838 >                }
839                  for (j = 0; j < 3; j++) {
840                          sprintf(p4[j], FLTFMT, cv1->p[j] + rad1*u[j]);
841 <                        sprintf(n4[j], FLTFMT, u[j] + w[j]*n1off);
841 >                        if (n1off >= FHUGE)
842 >                                sprintf(n4[j], FLTFMT, w[j]);
843 >                        else
844 >                                sprintf(n4[j], FLTFMT, u[j] + w[j]*n1off);
845                  }
846                  if ((rv = handle_it(MG_E_VERTEX, 3, v4ent)) != MG_OK)
847                          return(rv);
# Line 822 | Line 858 | char   **av;
858                          for (j = 0; j < 3; j++) {
859                                  d = u[j]*cos(theta) + v[j]*sin(theta);
860                                  sprintf(p3[j], FLTFMT, cv2->p[j] + rad2*d);
861 <                                sprintf(n3[j], FLTFMT, d + w[j]*n2off);
861 >                                if (n2off > -FHUGE)
862 >                                        sprintf(n3[j], FLTFMT, d + w[j]*n2off);
863                                  sprintf(p4[j], FLTFMT, cv1->p[j] + rad1*d);
864 <                                sprintf(n4[j], FLTFMT, d + w[j]*n1off);
864 >                                if (n1off < FHUGE)
865 >                                        sprintf(n4[j], FLTFMT, d + w[j]*n1off);
866                          }
867 <                        if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
867 >                        if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
868                                  return(rv);
869                          if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
870                                  return(rv);
871 <                        if ((rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
871 >                        if (n2off > -FHUGE &&
872 >                        (rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
873                                  return(rv);
874 <                        if ((rv = handle_it(MG_E_VERTEX, 3, v4ent)) != MG_OK)
874 >                        if ((rv = handle_it(MG_E_VERTEX, 2, v4ent)) != MG_OK)
875                                  return(rv);
876                          if ((rv = handle_it(MG_E_POINT, 4, p4ent)) != MG_OK)
877                                  return(rv);
878 <                        if ((rv = handle_it(MG_E_NORMAL, 4, n4ent)) != MG_OK)
878 >                        if (n1off < FHUGE &&
879 >                        (rv = handle_it(MG_E_NORMAL, 4, n4ent)) != MG_OK)
880                                  return(rv);
881                          if ((rv = handle_it(MG_E_FACE, 5, fent)) != MG_OK)
882                                  return(rv);
883                  }
884 +        }
885 +        return(MG_OK);
886 + }
887 +
888 +
889 + static int
890 + e_prism(ac, av)                 /* turn a prism into polygons */
891 + int     ac;
892 + char    **av;
893 + {
894 +        static char     p[3][24];
895 +        static char     *vent[4] = {mg_ename[MG_E_VERTEX],NULL,"="};
896 +        static char     *pent[5] = {mg_ename[MG_E_POINT],p[0],p[1],p[2]};
897 +        char    *newav[MG_MAXARGC], nvn[MG_MAXARGC-1][8];
898 +        double  length;
899 +        FVECT   v1, v2, v3, norm;
900 +        register C_VERTEX       *cv;
901 +        C_VERTEX        *cv0;
902 +        int     rv;
903 +        register int    i, j;
904 +
905 +        if (ac < 5)
906 +                return(MG_EARGC);
907 +        if (!isflt(av[1]))
908 +                return(MG_ETYPE);
909 +        length = atof(av[1]);
910 +        if (length <= FTINY && length >= -FTINY)
911 +                return(MG_EILL);
912 +                                        /* do bottom face */
913 +        newav[0] = mg_ename[MG_E_FACE];
914 +        for (i = 1; i < ac-1; i++)
915 +                newav[i] = av[i+1];
916 +        newav[i] = NULL;
917 +        if ((rv = handle_it(MG_E_FACE, i, newav)) != MG_OK)
918 +                return(rv);
919 +                                        /* compute face normal */
920 +        if ((cv0 = c_getvert(av[2])) == NULL)
921 +                return(MG_EUNDEF);
922 +        norm[0] = norm[1] = norm[2] = 0.;
923 +        v1[0] = v1[1] = v1[2] = 0.;
924 +        for (i = 2; i < ac-1; i++) {
925 +                if ((cv = c_getvert(av[i+1])) == NULL)
926 +                        return(MG_EUNDEF);
927 +                v2[0] = cv->p[0] - cv0->p[0];
928 +                v2[1] = cv->p[1] - cv0->p[1];
929 +                v2[2] = cv->p[2] - cv0->p[2];
930 +                fcross(v3, v1, v2);
931 +                norm[0] += v3[0];
932 +                norm[1] += v3[1];
933 +                norm[2] += v3[2];
934 +                VCOPY(v1, v2);
935 +        }
936 +        if (normalize(norm) == 0.)
937 +                return(MG_EILL);
938 +                                        /* create moved vertices */
939 +        for (i = 1; i < ac-1; i++) {
940 +                sprintf(nvn[i-1], "_pv%d", i);
941 +                vent[1] = nvn[i-1];
942 +                if ((rv = handle_it(MG_E_VERTEX, 3, vent)) != MG_OK)
943 +                        return(rv);
944 +                cv = c_getvert(av[i+1]);        /* checked above */
945 +                for (j = 0; j < 3; j++)
946 +                        sprintf(p[j], FLTFMT, cv->p[j] - length*norm[j]);
947 +                if ((rv = handle_it(MG_E_POINT, 4, pent)) != MG_OK)
948 +                        return(rv);
949 +                newav[ac-1-i] = nvn[i-1];       /* reverse */
950 +        }
951 +                                                /* do top face */
952 +        if ((rv = handle_it(MG_E_FACE, ac-1, newav)) != MG_OK)
953 +                return(rv);
954 +                                                /* do the side faces */
955 +        newav[5] = NULL;
956 +        newav[3] = av[ac-1];
957 +        newav[4] = nvn[ac-3];
958 +        for (i = 1; i < ac-1; i++) {
959 +                newav[1] = nvn[i-1];
960 +                newav[2] = av[i+1];
961 +                if ((rv = handle_it(MG_E_FACE, 5, newav)) != MG_OK)
962 +                        return(rv);
963 +                newav[3] = newav[2];
964 +                newav[4] = newav[1];
965          }
966          return(MG_OK);
967   }

Diff Legend

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