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 |
|
|
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; |
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.) |
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); |
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); |
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); |
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); |
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); |
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); |
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 |
|
} |