src/cv/mgf2rad.c

#ifndef lint
static const char       RCSid[] = "$Id: mgf2rad.c,v 2.27 2003/07/27 22:12:01 schorsch Exp $";
#endif
/*
 * Convert MGF (Materials and Geometry Format) to Radiance
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "platform.h"
#include "mgflib/parser.h"
#include "color.h"
#include "tmesh.h"

#define putv(v)         printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])

#define invert          (xf_context != NULL && xf_context->rev)

double  glowdist = FHUGE;               /* glow test distance */

double  emult = 1.;                     /* emitter multiplier */

FILE    *matfp;                         /* material output file */


int r_comment(int ac, char **av);
int r_cone(int ac, char **av);
int r_cyl(int ac, char **av);
int r_sph(int ac, char **av);
int r_ring(int ac, char **av);
int r_face(int ac, char **av);
int r_ies(int ac, char **av);
char * material(void);
char * object(void);
char * addarg(char *op, char *arg);
void do_tri(char *mat, C_VERTEX *cv1, C_VERTEX *cv2, C_VERTEX *cv3, int iv);
void cvtcolor(COLOR radrgb, register C_COLOR *ciec, double intensity);


int
main(
        int     argc,
        char    *argv[]
)
{
        int     i;

        matfp = stdout;
                                /* print out parser version */
        printf("## Translated from MGF Version %d.%d\n", MG_VMAJOR, MG_VMINOR);
                                /* initialize dispatch table */
        mg_ehand[MG_E_COMMENT] = r_comment;     /* we pass comments */
        mg_ehand[MG_E_COLOR] = c_hcolor;        /* they get color */
        mg_ehand[MG_E_CONE] = r_cone;           /* we do cones */
        mg_ehand[MG_E_CMIX] = c_hcolor;         /* they mix colors */
        mg_ehand[MG_E_CSPEC] = c_hcolor;        /* they get spectra */
        mg_ehand[MG_E_CXY] = c_hcolor;          /* they get chromaticities */
        mg_ehand[MG_E_CCT] = c_hcolor;          /* they get color temp's */
        mg_ehand[MG_E_CYL] = r_cyl;             /* we do cylinders */
        mg_ehand[MG_E_ED] = c_hmaterial;        /* they get emission */
        mg_ehand[MG_E_FACE] = r_face;           /* we do faces */
        mg_ehand[MG_E_IES] = r_ies;             /* we do IES files */
        mg_ehand[MG_E_IR] = c_hmaterial;        /* they get refractive index */
        mg_ehand[MG_E_MATERIAL] = c_hmaterial;  /* they get materials */
        mg_ehand[MG_E_NORMAL] = c_hvertex;      /* they get normals */
        mg_ehand[MG_E_OBJECT] = obj_handler;    /* they track object names */
        mg_ehand[MG_E_POINT] = c_hvertex;       /* they get points */
        mg_ehand[MG_E_RD] = c_hmaterial;        /* they get diffuse refl. */
        mg_ehand[MG_E_RING] = r_ring;           /* we do rings */
        mg_ehand[MG_E_RS] = c_hmaterial;        /* they get specular refl. */
        mg_ehand[MG_E_SIDES] = c_hmaterial;     /* they get # sides */
        mg_ehand[MG_E_SPH] = r_sph;             /* we do spheres */
        mg_ehand[MG_E_TD] = c_hmaterial;        /* they get diffuse trans. */
        mg_ehand[MG_E_TS] = c_hmaterial;        /* they get specular trans. */
        mg_ehand[MG_E_VERTEX] = c_hvertex;      /* they get vertices */
        mg_ehand[MG_E_XF] = xf_handler;         /* they track transforms */
        mg_init();              /* initialize the parser */
                                        /* get our options & print header */
        printf("## %s", argv[0]);
        for (i = 1; i < argc && argv[i][0] == '-'; i++) {
                printf(" %s", argv[i]);
                switch (argv[i][1]) {
                case 'g':                       /* glow distance (meters) */
                        if (argv[i][2] || badarg(argc-i-1, argv+i+1, "f"))
                                goto userr;
                        glowdist = atof(argv[++i]);
                        printf(" %s", argv[i]);
                        break;
                case 'e':                       /* emitter multiplier */
                        if (argv[i][2] || badarg(argc-i-1, argv+i+1, "f"))
                                goto userr;
                        emult = atof(argv[++i]);
                        printf(" %s", argv[i]);
                        break;
                case 'm':                       /* materials file */
                        matfp = fopen(argv[++i], "a");
                        if (matfp == NULL) {
                                fprintf(stderr, "%s: cannot append\n", argv[i]);
                                exit(1);
                        }
                        printf(" %s", argv[i]);
                        break;
                default:
                        goto userr;
                }
        }
        putchar('\n');
        if (i == argc) {                /* convert stdin */
                if (mg_load(NULL) != MG_OK)
                        exit(1);
                if (mg_nunknown)
                        printf("## %s: %u unknown entities\n",
                                        argv[0], mg_nunknown);
        } else                          /* convert each file */
                for ( ; i < argc; i++) {
                        printf("## %s %s ##############################\n",
                                        argv[0], argv[i]);
                        if (mg_load(argv[i]) != MG_OK)
                                exit(1);
                        if (mg_nunknown) {
                                printf("## %s %s: %u unknown entities\n",
                                                argv[0], argv[i], mg_nunknown);
                                mg_nunknown = 0;
                        }
                }
        exit(0);
userr:
        fprintf(stderr, "Usage: %s [-g dist][-e mult][-m matf] [file.mgf] ..\n",
                        argv[0]);
        exit(1);
}


int
r_comment(              /* repeat a comment verbatim */
        register int    ac,
        register char   **av
)
{
        putchar('#');           /* use Radiance comment character */
        while (--ac) {                  /* pass through verbatim */
                putchar(' ');
                fputs(*++av, stdout);
        }
        putchar('\n');
        return(MG_OK);
}


int
r_cone(                 /* put out a cone */
        int     ac,
        char    **av
)
{
        static int      ncones;
        char    *mat;
        double  r1, r2;
        C_VERTEX        *cv1, *cv2;
        FVECT   p1, p2;
        int     inv;
                                        /* check argument count and type */
        if (ac != 5)
                return(MG_EARGC);
        if (!isflt(av[2]) || !isflt(av[4]))
                return(MG_ETYPE);
                                        /* get the endpoint vertices */
        if ((cv1 = c_getvert(av[1])) == NULL ||
                        (cv2 = c_getvert(av[3])) == NULL)
                return(MG_EUNDEF);
        xf_xfmpoint(p1, cv1->p);        /* transform endpoints */
        xf_xfmpoint(p2, cv2->p);
        r1 = xf_scale(atof(av[2]));     /* scale radii */
        r2 = xf_scale(atof(av[4]));
        inv = r1 < 0.;                  /* check for inverted cone */
        if (r1 == 0.) {                 /* check for illegal radii */
                if (r2 == 0.)
                        return(MG_EILL);
                inv = r2 < 0.;
        } else if (r2 != 0. && inv ^ (r2 < 0.))
                return(MG_EILL);
        if (inv) {
                r1 = -r1;
                r2 = -r2;
        }
        if ((mat = material()) == NULL) /* get material */
                return(MG_EBADMAT);
                                        /* spit the sucker out */
        printf("\n%s %s %sc%d\n", mat, inv ? "cup" : "cone",
                        object(), ++ncones);
        printf("0\n0\n8\n");
        putv(p1);
        putv(p2);
        printf("%18.12g %18.12g\n", r1, r2);
        return(MG_OK);
}


int
r_cyl(                  /* put out a cylinder */
        int     ac,
        char    **av
)
{
        static int      ncyls;
        char    *mat;
        double  rad;
        C_VERTEX        *cv1, *cv2;
        FVECT   p1, p2;
        int     inv;
                                        /* check argument count and type */
        if (ac != 4)
                return(MG_EARGC);
        if (!isflt(av[2]))
                return(MG_ETYPE);
                                        /* get the endpoint vertices */
        if ((cv1 = c_getvert(av[1])) == NULL ||
                        (cv2 = c_getvert(av[3])) == NULL)
                return(MG_EUNDEF);
        xf_xfmpoint(p1, cv1->p);        /* transform endpoints */
        xf_xfmpoint(p2, cv2->p);
        rad = xf_scale(atof(av[2]));    /* scale radius */
        if ((inv = rad < 0.))           /* check for inverted cylinder */
                rad = -rad;
        if ((mat = material()) == NULL) /* get material */
                return(MG_EBADMAT);
                                        /* spit out the primitive */
        printf("\n%s %s %scy%d\n", mat, inv ? "tube" : "cylinder",
                        object(), ++ncyls);
        printf("0\n0\n7\n");
        putv(p1);
        putv(p2);
        printf("%18.12g\n", rad);
        return(MG_OK);
}


int
r_sph(                  /* put out a sphere */
        int     ac,
        char    **av
)
{
        static int      nsphs;
        char    *mat;
        double  rad;
        C_VERTEX        *cv;
        FVECT   cent;
        int     inv;
                                        /* check argument count and type */
        if (ac != 3)
                return(MG_EARGC);
        if (!isflt(av[2]))
                return(MG_ETYPE);
        if ((cv = c_getvert(av[1])) == NULL)    /* get center vertex */
                return(MG_EUNDEF);
        xf_xfmpoint(cent, cv->p);               /* transform center */
        rad = xf_scale(atof(av[2]));            /* scale radius */
        if ((inv = rad < 0.))                   /* check for inversion */
                rad = -rad;
        if ((mat = material()) == NULL)         /* get material */
                return(MG_EBADMAT);
                                                /* spit out primitive */
        printf("\n%s %s %ss%d\n", mat, inv ? "bubble" : "sphere",
                        object(), ++nsphs);
        printf("0\n0\n4 %18.12g %18.12g %18.12g %18.12g\n",
                        cent[0], cent[1], cent[2], rad);
        return(MG_OK);
}


int
r_ring(                 /* put out a ring */
        int     ac,
        char    **av
)
{
        static int      nrings;
        char    *mat;
        double  r1, r2;
        C_VERTEX        *cv;
        FVECT   cent, norm;
                                        /* check argument count and type */
        if (ac != 4)
                return(MG_EARGC);
        if (!isflt(av[2]) || !isflt(av[3]))
                return(MG_ETYPE);
        if ((cv = c_getvert(av[1])) == NULL)    /* get center vertex */
                return(MG_EUNDEF);
        if (is0vect(cv->n))                     /* make sure we have normal */
                return(MG_EILL);
        xf_xfmpoint(cent, cv->p);               /* transform center */
        xf_rotvect(norm, cv->n);                /* rotate normal */
        r1 = xf_scale(atof(av[2]));             /* scale radii */
        r2 = xf_scale(atof(av[3]));
        if ((r1 < 0.) | (r2 <= r1))
                return(MG_EILL);
        if ((mat = material()) == NULL)         /* get material */
                return(MG_EBADMAT);
                                                /* spit out primitive */
        printf("\n%s ring %sr%d\n", mat, object(), ++nrings);
        printf("0\n0\n8\n");
        putv(cent);
        putv(norm);
        printf("%18.12g %18.12g\n", r1, r2);
        return(MG_OK);
}


int
r_face(                 /* convert a face */
        int     ac,
        char    **av
)
{
        static int      nfaces;
        int             myi = invert;
        char    *mat;
        register int    i;
        register C_VERTEX       *cv;
        FVECT   v;

                                        /* check argument count and type */
        if (ac < 4)
                return(MG_EARGC);
        if ((mat = material()) == NULL) /* get material */
                return(MG_EBADMAT);
        if (ac <= 5) {                          /* check for smoothing */
                C_VERTEX        *cva[5];
                for (i = 1; i < ac; i++) {
                        if ((cva[i-1] = c_getvert(av[i])) == NULL)
                                return(MG_EUNDEF);
                        if (is0vect(cva[i-1]->n))
                                break;
                }
                if (i < ac)
                        i = ISFLAT;
                else
                        i = flat_tri(cva[0]->p, cva[1]->p, cva[2]->p,
                                        cva[0]->n, cva[1]->n, cva[2]->n);
                if (i == DEGEN)
                        return(MG_OK);          /* degenerate (error?) */
                if (i == RVBENT) {
                        myi = !myi;
                        i = ISBENT;
                } else if (i == RVFLAT) {
                        myi = !myi;
                        i = ISFLAT;
                }
                if (i == ISBENT) {              /* smoothed triangles */
                        do_tri(mat, cva[0], cva[1], cva[2], myi);
                        if (ac == 5)
                                do_tri(mat, cva[2], cva[3], cva[0], myi);
                        return(MG_OK);
                }
        }
                                        /* spit out unsmoothed primitive */
        printf("\n%s polygon %sf%d\n", mat, object(), ++nfaces);
        printf("0\n0\n%d\n", 3*(ac-1));
        for (i = 1; i < ac; i++) {      /* get, transform, print each vertex */
                if ((cv = c_getvert(av[myi ? ac-i : i])) == NULL)
                        return(MG_EUNDEF);
                xf_xfmpoint(v, cv->p);
                putv(v);
        }
        return(MG_OK);
}


int
r_ies(                          /* convert an IES luminaire file */
        int     ac,
        char    **av
)
{
        int     xa0 = 2;
        char    combuf[128];
        char    fname[48];
        char    *oname;
        register char   *op;
        register int    i;
                                        /* check argument count */
        if (ac < 2)
                return(MG_EARGC);
                                        /* construct output file name */
        if ((op = strrchr(av[1], '/')) != NULL)
                op++;
        else
                op = av[1];
        (void)strcpy(fname, op);
        if ((op = strrchr(fname, '.')) == NULL)
                op = fname + strlen(fname);
        (void)strcpy(op, ".rad");
                                        /* see if we need to run ies2rad */
        if (access(fname, 0) == -1) {
                (void)strcpy(combuf, "ies2rad");/* build ies2rad command */
                op = combuf + 7;                /* get -m option (first) */
                if (ac-xa0 >= 2 && !strcmp(av[xa0], "-m")) {
                        if (!isflt(av[xa0+1]))
                                return(MG_ETYPE);
                        op = addarg(addarg(op, "-m"), av[xa0+1]);
                        xa0 += 2;
                }
                *op++ = ' ';                    /* build IES filename */
                i = 0;
                if (mg_file != NULL &&
                                (oname = strrchr(mg_file->fname,'/')) != NULL) {
                        i = oname - mg_file->fname + 1;
                        (void)strcpy(op, mg_file->fname);
                }
                (void)strcpy(op+i, av[1]);
                if (access(op, 0) == -1)        /* check for file existence */
                        return(MG_ENOFILE);
                system(combuf);                 /* run ies2rad */
                if (access(fname, 0) == -1)     /* check success */
                        return(MG_EINCL);
        }
        printf("\n!xform");                     /* put out xform command */
        oname = object();
        if (*oname) {
                printf(" -n ");
                for (op = oname; op[1]; op++)   /* remove trailing separator */
                        putchar(*op);
        }
        for (i = xa0; i < ac; i++)
                printf(" %s", av[i]);
        if (ac > xa0 && xf_argc > 0)
                printf(" -i 1");
        for (i = 0; i < xf_argc; i++)
                printf(" %s", xf_argv[i]);
        printf(" %s\n", fname);
        return(MG_OK);
}


void
do_tri(         /* put out smoothed triangle */
        char    *mat,
        C_VERTEX        *cv1,
        C_VERTEX        *cv2,
        C_VERTEX        *cv3,
        int     iv
)
{
        static int      ntris;
        BARYCCM bvecs;
        RREAL   bcoor[3][3];
        C_VERTEX        *cvt;
        FVECT   v1, v2, v3;
        FVECT   n1, n2, n3;
        register int    i;

        if (iv) {                       /* swap vertex order if inverted */
                cvt = cv1;
                cv1 = cv3;
                cv3 = cvt;
        }
        xf_xfmpoint(v1, cv1->p);
        xf_xfmpoint(v2, cv2->p);
        xf_xfmpoint(v3, cv3->p);
                                        /* compute barycentric coords. */
        if (comp_baryc(&bvecs, v1, v2, v3) < 0)
                return;                         /* degenerate triangle! */
        printf("\n%s texfunc T-nor\n", mat);    /* put out texture */
        printf("4 dx dy dz %s\n0\n", TCALNAME);
        xf_rotvect(n1, cv1->n);
        xf_rotvect(n2, cv2->n);
        xf_rotvect(n3, cv3->n);
        for (i = 0; i < 3; i++) {
                bcoor[i][0] = n1[i];
                bcoor[i][1] = n2[i];
                bcoor[i][2] = n3[i];
        }
        put_baryc(&bvecs, bcoor, 3);
                                                /* put out triangle */
        printf("\nT-nor polygon %st%d\n", object(), ++ntris);
        printf("0\n0\n9\n");
        putv(v1);
        putv(v2);
        putv(v3);
}


char *
material(void)                  /* get (and print) current material */
{
        char    *mname = "mat";
        COLOR   radrgb, c2;
        double  d;

        if (c_cmname != NULL)
                mname = c_cmname;
        if (!c_cmaterial->clock)
                return(mname);          /* already current */
                                /* else update output */
        c_cmaterial->clock = 0;
        if (c_cmaterial->ed > .1) {     /* emitter */
                cvtcolor(radrgb, &c_cmaterial->ed_c,
                                emult*c_cmaterial->ed/(PI*WHTEFFICACY));
                if (glowdist < FHUGE) {         /* do a glow */
                        fprintf(matfp, "\nvoid glow %s\n0\n0\n", mname);
                        fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
                                        colval(radrgb,GRN),
                                        colval(radrgb,BLU), glowdist);
                } else {
                        fprintf(matfp, "\nvoid light %s\n0\n0\n", mname);
                        fprintf(matfp, "3 %f %f %f\n", colval(radrgb,RED),
                                        colval(radrgb,GRN),
                                        colval(radrgb,BLU));
                }
                return(mname);
        }
        d = c_cmaterial->rd + c_cmaterial->td +
                        c_cmaterial->rs + c_cmaterial->ts;
        if ((d < 0.) | (d > 1.))
                return(NULL);
                                        /* check for glass/dielectric */
        if (c_cmaterial->nr > 1.1 &&
                        c_cmaterial->ts > .25 && c_cmaterial->rs <= .125 &&
                        c_cmaterial->td <= .01 && c_cmaterial->rd <= .01 &&
                        c_cmaterial->rs_a <= .01 && c_cmaterial->ts_a <= .01) {
                cvtcolor(radrgb, &c_cmaterial->ts_c,
                                c_cmaterial->ts + c_cmaterial->rs);
                if (c_cmaterial->sided) {               /* dielectric */
                        colval(radrgb,RED) = pow(colval(radrgb,RED),
                                                        1./C_1SIDEDTHICK);
                        colval(radrgb,GRN) = pow(colval(radrgb,GRN),
                                                        1./C_1SIDEDTHICK);
                        colval(radrgb,BLU) = pow(colval(radrgb,BLU),
                                                        1./C_1SIDEDTHICK);
                        fprintf(matfp, "\nvoid dielectric %s\n0\n0\n", mname);
                        fprintf(matfp, "5 %g %g %g %f 0\n", colval(radrgb,RED),
                                        colval(radrgb,GRN), colval(radrgb,BLU),
                                        c_cmaterial->nr);
                        return(mname);
                }
                                                        /* glass */
                fprintf(matfp, "\nvoid glass %s\n0\n0\n", mname);
                fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
                                colval(radrgb,GRN), colval(radrgb,BLU),
                                c_cmaterial->nr);
                return(mname);
                }
                                        /* check for trans */
        if (c_cmaterial->td > .01 || c_cmaterial->ts > .01) {
                double  ts, a5, a6;

                if (c_cmaterial->sided) {
                        ts = sqrt(c_cmaterial->ts);     /* approximate */
                        a5 = .5;
                } else {
                        ts = c_cmaterial->ts;
                        a5 = 1.;
                }
                                                /* average colors */
                d = c_cmaterial->rd + c_cmaterial->td + ts;
                cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd/d);
                cvtcolor(c2, &c_cmaterial->td_c, c_cmaterial->td/d);
                addcolor(radrgb, c2);
                cvtcolor(c2, &c_cmaterial->ts_c, ts/d);
                addcolor(radrgb, c2);
                if (c_cmaterial->rs + ts > .0001)
                        a5 = (c_cmaterial->rs*c_cmaterial->rs_a +
                                        ts*a5*c_cmaterial->ts_a) /
                                        (c_cmaterial->rs + ts);
                a6 = (c_cmaterial->td + ts) /
                                (c_cmaterial->rd + c_cmaterial->td + ts);
                if (a6 < .999)
                        d = c_cmaterial->rd/(1. - c_cmaterial->rs)/(1. - a6);
                else
                        d = c_cmaterial->td + ts;
                scalecolor(radrgb, d);
                fprintf(matfp, "\nvoid trans %s\n0\n0\n", mname);
                fprintf(matfp, "7 %f %f %f\n", colval(radrgb,RED),
                                colval(radrgb,GRN), colval(radrgb,BLU));
                fprintf(matfp, "\t%f %f %f %f\n", c_cmaterial->rs, a5, a6,
                                ts/(ts + c_cmaterial->td));
                return(mname);
        }
                                        /* check for plastic */
        if (c_cmaterial->rs < .1) {
                cvtcolor(radrgb, &c_cmaterial->rd_c,
                                        c_cmaterial->rd/(1.-c_cmaterial->rs));
                fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
                fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
                                colval(radrgb,GRN), colval(radrgb,BLU),
                                c_cmaterial->rs, c_cmaterial->rs_a);
                return(mname);
        }
                                        /* else it's metal */
                                                /* average colors */
        cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
        cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
        addcolor(radrgb, c2);
        fprintf(matfp, "\nvoid metal %s\n0\n0\n", mname);
        fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
                        colval(radrgb,GRN), colval(radrgb,BLU),
                        c_cmaterial->rs/(c_cmaterial->rd + c_cmaterial->rs),
                        c_cmaterial->rs_a);
        return(mname);
}


void
cvtcolor(       /* convert a CIE XYZ color to RGB */
        COLOR   radrgb,
        register C_COLOR        *ciec,
        double  intensity
)
{
        static COLOR    ciexyz;

        c_ccvt(ciec, C_CSXY);           /* get xy representation */
        ciexyz[1] = intensity;
        ciexyz[0] = ciec->cx/ciec->cy*ciexyz[1];
        ciexyz[2] = ciexyz[1]*(1./ciec->cy - 1.) - ciexyz[0];
        cie_rgb(radrgb, ciexyz);
}


char *
object(void)                    /* return current object name */
{
        static char     objbuf[64];
        register int    i;
        register char   *cp;
        int     len;
                                                /* tracked by obj_handler */
        i = obj_nnames - sizeof(objbuf)/16;
        if (i < 0)
                i = 0;
        for (cp = objbuf; i < obj_nnames &&
                cp + (len=strlen(obj_name[i])) < objbuf+sizeof(objbuf)-1;
                        i++, *cp++ = '.') {
                strcpy(cp, obj_name[i]);
                cp += len;
        }
        *cp = '\0';
        return(objbuf);
}


char *
addarg(                         /* add argument and advance pointer */
        register char *op,
        register char *arg
)
{
        *op = ' ';
        while ( (*++op = *arg++) )
                ;
        return(op);
}
Revision:	2.28
Committed:	Sat Nov 15 17:54:06 2003 UTC (20 years, 5 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R7P2, rad3R7P1, rad4R0, rad3R6, rad3R6P1, rad3R8, rad3R9
Changes since 2.27:	+70 -41 lines
Log Message:	Continued ANSIfication and reduced compile warnings.
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	schorsch	2.28	static const char RCSid[] = "$Id: mgf2rad.c,v 2.27 2003/07/27 22:12:01 schorsch Exp $";
3	greg	2.1	#endif
4			/*
5			* Convert MGF (Materials and Geometry Format) to Radiance
6			*/
7
8			#include <stdio.h>
9	greg	2.25	#include <stdlib.h>
10	greg	2.1	#include <math.h>
11			#include <string.h>
12	schorsch	2.28
13			#include "platform.h"
14	greg	2.1	#include "mgflib/parser.h"
15			#include "color.h"
16			#include "tmesh.h"
17
18			#define putv(v) printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])
19
20	greg	2.9	#define invert (xf_context != NULL && xf_context->rev)
21
22	greg	2.2	double glowdist = FHUGE; /* glow test distance */
23	greg	2.1
24	greg	2.8	double emult = 1.; /* emitter multiplier */
25	greg	2.1
26	gwlarson	2.24	FILE matfp; / material output file */
27	greg	2.11
28	schorsch	2.28
29			int r_comment(int ac, char **av);
30			int r_cone(int ac, char **av);
31			int r_cyl(int ac, char **av);
32			int r_sph(int ac, char **av);
33			int r_ring(int ac, char **av);
34			int r_face(int ac, char **av);
35			int r_ies(int ac, char **av);
36			char * material(void);
37			char * object(void);
38			char * addarg(char op, char arg);
39			void do_tri(char mat, C_VERTEX cv1, C_VERTEX cv2, C_VERTEX cv3, int iv);
40			void cvtcolor(COLOR radrgb, register C_COLOR *ciec, double intensity);
41	greg	2.1
42
43	schorsch	2.28	int
44			main(
45			int argc,
46			char *argv[]
47			)
48	greg	2.1	{
49	greg	2.20	int i;
50	gwlarson	2.24
51			matfp = stdout;
52	greg	2.19	/* print out parser version */
53			printf("## Translated from MGF Version %d.%d\n", MG_VMAJOR, MG_VMINOR);
54	greg	2.1	/* initialize dispatch table */
55	greg	2.16	mg_ehand[MG_E_COMMENT] = r_comment; /* we pass comments */
56			mg_ehand[MG_E_COLOR] = c_hcolor; /* they get color */
57			mg_ehand[MG_E_CONE] = r_cone; /* we do cones */
58			mg_ehand[MG_E_CMIX] = c_hcolor; /* they mix colors */
59			mg_ehand[MG_E_CSPEC] = c_hcolor; /* they get spectra */
60			mg_ehand[MG_E_CXY] = c_hcolor; /* they get chromaticities */
61			mg_ehand[MG_E_CCT] = c_hcolor; /* they get color temp's */
62			mg_ehand[MG_E_CYL] = r_cyl; /* we do cylinders */
63			mg_ehand[MG_E_ED] = c_hmaterial; /* they get emission */
64			mg_ehand[MG_E_FACE] = r_face; /* we do faces */
65			mg_ehand[MG_E_IES] = r_ies; /* we do IES files */
66			mg_ehand[MG_E_IR] = c_hmaterial; /* they get refractive index */
67			mg_ehand[MG_E_MATERIAL] = c_hmaterial; /* they get materials */
68			mg_ehand[MG_E_NORMAL] = c_hvertex; /* they get normals */
69			mg_ehand[MG_E_OBJECT] = obj_handler; /* they track object names */
70			mg_ehand[MG_E_POINT] = c_hvertex; /* they get points */
71			mg_ehand[MG_E_RD] = c_hmaterial; /* they get diffuse refl. */
72			mg_ehand[MG_E_RING] = r_ring; /* we do rings */
73			mg_ehand[MG_E_RS] = c_hmaterial; /* they get specular refl. */
74			mg_ehand[MG_E_SIDES] = c_hmaterial; /* they get # sides */
75			mg_ehand[MG_E_SPH] = r_sph; /* we do spheres */
76			mg_ehand[MG_E_TD] = c_hmaterial; /* they get diffuse trans. */
77			mg_ehand[MG_E_TS] = c_hmaterial; /* they get specular trans. */
78			mg_ehand[MG_E_VERTEX] = c_hvertex; /* they get vertices */
79			mg_ehand[MG_E_XF] = xf_handler; /* they track transforms */
80	greg	2.1	mg_init(); /* initialize the parser */
81	greg	2.16	/* get our options & print header */
82	greg	2.1	printf("## %s", argv[0]);
83			for (i = 1; i < argc && argv[i][0] == '-'; i++) {
84			printf(" %s", argv[i]);
85			switch (argv[i][1]) {
86			case 'g': /* glow distance (meters) */
87	greg	2.10	if (argv[i][2] \|\| badarg(argc-i-1, argv+i+1, "f"))
88	greg	2.1	goto userr;
89			glowdist = atof(argv[++i]);
90			printf(" %s", argv[i]);
91			break;
92			case 'e': /* emitter multiplier */
93	greg	2.10	if (argv[i][2] \|\| badarg(argc-i-1, argv+i+1, "f"))
94	greg	2.1	goto userr;
95			emult = atof(argv[++i]);
96			printf(" %s", argv[i]);
97			break;
98	greg	2.11	case 'm': /* materials file */
99			matfp = fopen(argv[++i], "a");
100			if (matfp == NULL) {
101			fprintf(stderr, "%s: cannot append\n", argv[i]);
102			exit(1);
103			}
104			printf(" %s", argv[i]);
105			break;
106	greg	2.1	default:
107			goto userr;
108			}
109			}
110			putchar('\n');
111			if (i == argc) { /* convert stdin */
112	greg	2.20	if (mg_load(NULL) != MG_OK)
113	greg	2.1	exit(1);
114	greg	2.18	if (mg_nunknown)
115			printf("## %s: %u unknown entities\n",
116			argv[0], mg_nunknown);
117	greg	2.1	} else /* convert each file */
118			for ( ; i < argc; i++) {
119			printf("## %s %s ##############################\n",
120			argv[0], argv[i]);
121	greg	2.20	if (mg_load(argv[i]) != MG_OK)
122	greg	2.1	exit(1);
123	greg	2.18	if (mg_nunknown) {
124			printf("## %s %s: %u unknown entities\n",
125			argv[0], argv[i], mg_nunknown);
126			mg_nunknown = 0;
127			}
128	greg	2.1	}
129			exit(0);
130			userr:
131	greg	2.11	fprintf(stderr, "Usage: %s [-g dist][-e mult][-m matf] [file.mgf] ..\n",
132	greg	2.1	argv[0]);
133			exit(1);
134			}
135
136
137			int
138	schorsch	2.28	r_comment( /* repeat a comment verbatim */
139			register int ac,
140			register char **av
141			)
142	greg	2.1	{
143	greg	2.7	putchar('#'); /* use Radiance comment character */
144	greg	2.16	while (--ac) { /* pass through verbatim */
145	greg	2.1	putchar(' ');
146			fputs(*++av, stdout);
147			}
148			putchar('\n');
149			return(MG_OK);
150			}
151
152
153			int
154	schorsch	2.28	r_cone( /* put out a cone */
155			int ac,
156			char **av
157			)
158	greg	2.1	{
159			static int ncones;
160			char *mat;
161			double r1, r2;
162			C_VERTEX cv1, cv2;
163			FVECT p1, p2;
164			int inv;
165	greg	2.16	/* check argument count and type */
166	greg	2.1	if (ac != 5)
167			return(MG_EARGC);
168			if (!isflt(av[2]) \|\| !isflt(av[4]))
169			return(MG_ETYPE);
170	greg	2.16	/* get the endpoint vertices */
171	greg	2.1	if ((cv1 = c_getvert(av[1])) == NULL \|\|
172			(cv2 = c_getvert(av[3])) == NULL)
173			return(MG_EUNDEF);
174	greg	2.16	xf_xfmpoint(p1, cv1->p); /* transform endpoints */
175	greg	2.1	xf_xfmpoint(p2, cv2->p);
176	greg	2.16	r1 = xf_scale(atof(av[2])); /* scale radii */
177	greg	2.1	r2 = xf_scale(atof(av[4]));
178	greg	2.16	inv = r1 < 0.; /* check for inverted cone */
179			if (r1 == 0.) { /* check for illegal radii */
180	greg	2.1	if (r2 == 0.)
181			return(MG_EILL);
182			inv = r2 < 0.;
183	schorsch	2.27	} else if (r2 != 0. && inv ^ (r2 < 0.))
184	greg	2.1	return(MG_EILL);
185			if (inv) {
186			r1 = -r1;
187			r2 = -r2;
188			}
189	greg	2.16	if ((mat = material()) == NULL) /* get material */
190	greg	2.1	return(MG_EBADMAT);
191	greg	2.16	/* spit the sucker out */
192	greg	2.1	printf("\n%s %s %sc%d\n", mat, inv ? "cup" : "cone",
193			object(), ++ncones);
194			printf("0\n0\n8\n");
195			putv(p1);
196			putv(p2);
197			printf("%18.12g %18.12g\n", r1, r2);
198			return(MG_OK);
199			}
200
201
202			int
203	schorsch	2.28	r_cyl( /* put out a cylinder */
204			int ac,
205			char **av
206			)
207	greg	2.1	{
208			static int ncyls;
209			char *mat;
210			double rad;
211			C_VERTEX cv1, cv2;
212			FVECT p1, p2;
213			int inv;
214	greg	2.16	/* check argument count and type */
215	greg	2.1	if (ac != 4)
216			return(MG_EARGC);
217			if (!isflt(av[2]))
218			return(MG_ETYPE);
219	greg	2.16	/* get the endpoint vertices */
220	greg	2.1	if ((cv1 = c_getvert(av[1])) == NULL \|\|
221			(cv2 = c_getvert(av[3])) == NULL)
222			return(MG_EUNDEF);
223	greg	2.16	xf_xfmpoint(p1, cv1->p); /* transform endpoints */
224	greg	2.1	xf_xfmpoint(p2, cv2->p);
225	greg	2.16	rad = xf_scale(atof(av[2])); /* scale radius */
226			if ((inv = rad < 0.)) /* check for inverted cylinder */
227	greg	2.1	rad = -rad;
228	greg	2.16	if ((mat = material()) == NULL) /* get material */
229	greg	2.1	return(MG_EBADMAT);
230	greg	2.16	/* spit out the primitive */
231	greg	2.1	printf("\n%s %s %scy%d\n", mat, inv ? "tube" : "cylinder",
232			object(), ++ncyls);
233			printf("0\n0\n7\n");
234			putv(p1);
235			putv(p2);
236			printf("%18.12g\n", rad);
237			return(MG_OK);
238			}
239
240
241			int
242	schorsch	2.28	r_sph( /* put out a sphere */
243			int ac,
244			char **av
245			)
246	greg	2.1	{
247			static int nsphs;
248			char *mat;
249			double rad;
250			C_VERTEX *cv;
251			FVECT cent;
252			int inv;
253	greg	2.16	/* check argument count and type */
254	greg	2.1	if (ac != 3)
255			return(MG_EARGC);
256			if (!isflt(av[2]))
257			return(MG_ETYPE);
258	greg	2.16	if ((cv = c_getvert(av[1])) == NULL) /* get center vertex */
259	greg	2.1	return(MG_EUNDEF);
260	greg	2.16	xf_xfmpoint(cent, cv->p); /* transform center */
261			rad = xf_scale(atof(av[2])); /* scale radius */
262			if ((inv = rad < 0.)) /* check for inversion */
263	greg	2.1	rad = -rad;
264	greg	2.16	if ((mat = material()) == NULL) /* get material */
265	greg	2.1	return(MG_EBADMAT);
266	greg	2.16	/* spit out primitive */
267	greg	2.1	printf("\n%s %s %ss%d\n", mat, inv ? "bubble" : "sphere",
268			object(), ++nsphs);
269			printf("0\n0\n4 %18.12g %18.12g %18.12g %18.12g\n",
270			cent[0], cent[1], cent[2], rad);
271			return(MG_OK);
272			}
273
274
275			int
276	schorsch	2.28	r_ring( /* put out a ring */
277			int ac,
278			char **av
279			)
280	greg	2.1	{
281			static int nrings;
282			char *mat;
283			double r1, r2;
284			C_VERTEX *cv;
285			FVECT cent, norm;
286	greg	2.16	/* check argument count and type */
287	greg	2.1	if (ac != 4)
288			return(MG_EARGC);
289			if (!isflt(av[2]) \|\| !isflt(av[3]))
290			return(MG_ETYPE);
291	greg	2.16	if ((cv = c_getvert(av[1])) == NULL) /* get center vertex */
292	greg	2.1	return(MG_EUNDEF);
293	greg	2.16	if (is0vect(cv->n)) /* make sure we have normal */
294	greg	2.1	return(MG_EILL);
295	greg	2.16	xf_xfmpoint(cent, cv->p); /* transform center */
296			xf_rotvect(norm, cv->n); /* rotate normal */
297			r1 = xf_scale(atof(av[2])); /* scale radii */
298	greg	2.1	r2 = xf_scale(atof(av[3]));
299	schorsch	2.27	if ((r1 < 0.) \| (r2 <= r1))
300	greg	2.1	return(MG_EILL);
301	greg	2.16	if ((mat = material()) == NULL) /* get material */
302	greg	2.1	return(MG_EBADMAT);
303	greg	2.16	/* spit out primitive */
304	greg	2.1	printf("\n%s ring %sr%d\n", mat, object(), ++nrings);
305			printf("0\n0\n8\n");
306			putv(cent);
307			putv(norm);
308			printf("%18.12g %18.12g\n", r1, r2);
309			return(MG_OK);
310			}
311
312
313			int
314	schorsch	2.28	r_face( /* convert a face */
315			int ac,
316			char **av
317			)
318	greg	2.1	{
319			static int nfaces;
320	greg	2.25	int myi = invert;
321	greg	2.1	char *mat;
322			register int i;
323			register C_VERTEX *cv;
324			FVECT v;
325	schorsch	2.28
326	greg	2.16	/* check argument count and type */
327	greg	2.1	if (ac < 4)
328			return(MG_EARGC);
329	greg	2.16	if ((mat = material()) == NULL) /* get material */
330	greg	2.1	return(MG_EBADMAT);
331	greg	2.16	if (ac <= 5) { /* check for smoothing */
332	greg	2.23	C_VERTEX *cva[5];
333	greg	2.1	for (i = 1; i < ac; i++) {
334	greg	2.23	if ((cva[i-1] = c_getvert(av[i])) == NULL)
335	greg	2.1	return(MG_EUNDEF);
336	greg	2.23	if (is0vect(cva[i-1]->n))
337	greg	2.1	break;
338			}
339	greg	2.25	if (i < ac)
340			i = ISFLAT;
341			else
342	greg	2.23	i = flat_tri(cva[0]->p, cva[1]->p, cva[2]->p,
343			cva[0]->n, cva[1]->n, cva[2]->n);
344	greg	2.25	if (i == DEGEN)
345			return(MG_OK); /* degenerate (error?) */
346			if (i == RVBENT) {
347			myi = !myi;
348			i = ISBENT;
349			} else if (i == RVFLAT) {
350			myi = !myi;
351			i = ISFLAT;
352	greg	2.23	}
353	greg	2.25	if (i == ISBENT) { /* smoothed triangles */
354			do_tri(mat, cva[0], cva[1], cva[2], myi);
355	greg	2.1	if (ac == 5)
356	greg	2.25	do_tri(mat, cva[2], cva[3], cva[0], myi);
357	greg	2.1	return(MG_OK);
358			}
359			}
360	greg	2.16	/* spit out unsmoothed primitive */
361	greg	2.1	printf("\n%s polygon %sf%d\n", mat, object(), ++nfaces);
362			printf("0\n0\n%d\n", 3*(ac-1));
363	greg	2.16	for (i = 1; i < ac; i++) { /* get, transform, print each vertex */
364	greg	2.25	if ((cv = c_getvert(av[myi ? ac-i : i])) == NULL)
365	greg	2.1	return(MG_EUNDEF);
366			xf_xfmpoint(v, cv->p);
367			putv(v);
368			}
369			return(MG_OK);
370			}
371
372
373	greg	2.15	int
374	schorsch	2.28	r_ies( /* convert an IES luminaire file */
375			int ac,
376			char **av
377			)
378	greg	2.1	{
379			int xa0 = 2;
380	greg	2.15	char combuf[128];
381	greg	2.1	char fname[48];
382			char *oname;
383			register char *op;
384			register int i;
385	greg	2.16	/* check argument count */
386	greg	2.1	if (ac < 2)
387			return(MG_EARGC);
388	greg	2.16	/* construct output file name */
389	greg	2.22	if ((op = strrchr(av[1], '/')) != NULL)
390			op++;
391			else
392	greg	2.1	op = av[1];
393			(void)strcpy(fname, op);
394			if ((op = strrchr(fname, '.')) == NULL)
395			op = fname + strlen(fname);
396			(void)strcpy(op, ".rad");
397	greg	2.16	/* see if we need to run ies2rad */
398	greg	2.17	if (access(fname, 0) == -1) {
399	greg	2.16	(void)strcpy(combuf, "ies2rad");/* build ies2rad command */
400			op = combuf + 7; /* get -m option (first) */
401			if (ac-xa0 >= 2 && !strcmp(av[xa0], "-m")) {
402			if (!isflt(av[xa0+1]))
403			return(MG_ETYPE);
404			op = addarg(addarg(op, "-m"), av[xa0+1]);
405			xa0 += 2;
406			}
407			op++ = ' '; / build IES filename */
408			i = 0;
409			if (mg_file != NULL &&
410			(oname = strrchr(mg_file->fname,'/')) != NULL) {
411			i = oname - mg_file->fname + 1;
412			(void)strcpy(op, mg_file->fname);
413			}
414			(void)strcpy(op+i, av[1]);
415			if (access(op, 0) == -1) /* check for file existence */
416			return(MG_ENOFILE);
417			system(combuf); /* run ies2rad */
418			if (access(fname, 0) == -1) /* check success */
419			return(MG_EINCL);
420			}
421			printf("\n!xform"); /* put out xform command */
422	greg	2.1	oname = object();
423	greg	2.4	if (*oname) {
424			printf(" -n ");
425			for (op = oname; op[1]; op++) /* remove trailing separator */
426			putchar(*op);
427			}
428	greg	2.1	for (i = xa0; i < ac; i++)
429			printf(" %s", av[i]);
430			if (ac > xa0 && xf_argc > 0)
431			printf(" -i 1");
432			for (i = 0; i < xf_argc; i++)
433			printf(" %s", xf_argv[i]);
434			printf(" %s\n", fname);
435			return(MG_OK);
436			}
437
438
439	schorsch	2.28	void
440			do_tri( /* put out smoothed triangle */
441			char *mat,
442			C_VERTEX *cv1,
443			C_VERTEX *cv2,
444			C_VERTEX *cv3,
445			int iv
446			)
447	greg	2.1	{
448			static int ntris;
449			BARYCCM bvecs;
450	schorsch	2.26	RREAL bcoor[3][3];
451	greg	2.23	C_VERTEX *cvt;
452	greg	2.1	FVECT v1, v2, v3;
453			FVECT n1, n2, n3;
454			register int i;
455	greg	2.23
456	greg	2.25	if (iv) { /* swap vertex order if inverted */
457	greg	2.23	cvt = cv1;
458			cv1 = cv3;
459			cv3 = cvt;
460	greg	2.9	}
461	greg	2.1	xf_xfmpoint(v1, cv1->p);
462			xf_xfmpoint(v2, cv2->p);
463			xf_xfmpoint(v3, cv3->p);
464	greg	2.16	/* compute barycentric coords. */
465	greg	2.2	if (comp_baryc(&bvecs, v1, v2, v3) < 0)
466			return; /* degenerate triangle! */
467	greg	2.16	printf("\n%s texfunc T-nor\n", mat); /* put out texture */
468	greg	2.2	printf("4 dx dy dz %s\n0\n", TCALNAME);
469			xf_rotvect(n1, cv1->n);
470			xf_rotvect(n2, cv2->n);
471			xf_rotvect(n3, cv3->n);
472			for (i = 0; i < 3; i++) {
473			bcoor[i][0] = n1[i];
474			bcoor[i][1] = n2[i];
475			bcoor[i][2] = n3[i];
476	greg	2.1	}
477	greg	2.2	put_baryc(&bvecs, bcoor, 3);
478	greg	2.16	/* put out triangle */
479	greg	2.2	printf("\nT-nor polygon %st%d\n", object(), ++ntris);
480	greg	2.1	printf("0\n0\n9\n");
481			putv(v1);
482			putv(v2);
483			putv(v3);
484			}
485
486
487			char *
488	schorsch	2.28	material(void) /* get (and print) current material */
489	greg	2.1	{
490			char *mname = "mat";
491			COLOR radrgb, c2;
492			double d;
493
494	greg	2.5	if (c_cmname != NULL)
495			mname = c_cmname;
496	greg	2.1	if (!c_cmaterial->clock)
497			return(mname); /* already current */
498			/* else update output */
499			c_cmaterial->clock = 0;
500			if (c_cmaterial->ed > .1) { /* emitter */
501			cvtcolor(radrgb, &c_cmaterial->ed_c,
502	greg	2.12	emultc_cmaterial->ed/(PIWHTEFFICACY));
503	greg	2.2	if (glowdist < FHUGE) { /* do a glow */
504	greg	2.11	fprintf(matfp, "\nvoid glow %s\n0\n0\n", mname);
505			fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
506	greg	2.1	colval(radrgb,GRN),
507			colval(radrgb,BLU), glowdist);
508			} else {
509	greg	2.11	fprintf(matfp, "\nvoid light %s\n0\n0\n", mname);
510			fprintf(matfp, "3 %f %f %f\n", colval(radrgb,RED),
511	greg	2.1	colval(radrgb,GRN),
512			colval(radrgb,BLU));
513			}
514			return(mname);
515			}
516			d = c_cmaterial->rd + c_cmaterial->td +
517			c_cmaterial->rs + c_cmaterial->ts;
518	schorsch	2.27	if ((d < 0.) \| (d > 1.))
519	greg	2.1	return(NULL);
520	greg	2.14	/* check for glass/dielectric */
521			if (c_cmaterial->nr > 1.1 &&
522			c_cmaterial->ts > .25 && c_cmaterial->rs <= .125 &&
523			c_cmaterial->td <= .01 && c_cmaterial->rd <= .01 &&
524			c_cmaterial->rs_a <= .01 && c_cmaterial->ts_a <= .01) {
525			cvtcolor(radrgb, &c_cmaterial->ts_c,
526			c_cmaterial->ts + c_cmaterial->rs);
527			if (c_cmaterial->sided) { /* dielectric */
528			colval(radrgb,RED) = pow(colval(radrgb,RED),
529			1./C_1SIDEDTHICK);
530			colval(radrgb,GRN) = pow(colval(radrgb,GRN),
531			1./C_1SIDEDTHICK);
532			colval(radrgb,BLU) = pow(colval(radrgb,BLU),
533			1./C_1SIDEDTHICK);
534			fprintf(matfp, "\nvoid dielectric %s\n0\n0\n", mname);
535			fprintf(matfp, "5 %g %g %g %f 0\n", colval(radrgb,RED),
536			colval(radrgb,GRN), colval(radrgb,BLU),
537			c_cmaterial->nr);
538			return(mname);
539			}
540			/* glass */
541			fprintf(matfp, "\nvoid glass %s\n0\n0\n", mname);
542			fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
543			colval(radrgb,GRN), colval(radrgb,BLU),
544			c_cmaterial->nr);
545			return(mname);
546			}
547	greg	2.3	/* check for trans */
548			if (c_cmaterial->td > .01 \|\| c_cmaterial->ts > .01) {
549	greg	2.1	double ts, a5, a6;
550
551	greg	2.6	if (c_cmaterial->sided) {
552			ts = sqrt(c_cmaterial->ts); /* approximate */
553			a5 = .5;
554	greg	2.7	} else {
555			ts = c_cmaterial->ts;
556	greg	2.6	a5 = 1.;
557	greg	2.7	}
558	greg	2.1	/* average colors */
559			d = c_cmaterial->rd + c_cmaterial->td + ts;
560			cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd/d);
561			cvtcolor(c2, &c_cmaterial->td_c, c_cmaterial->td/d);
562			addcolor(radrgb, c2);
563			cvtcolor(c2, &c_cmaterial->ts_c, ts/d);
564			addcolor(radrgb, c2);
565			if (c_cmaterial->rs + ts > .0001)
566			a5 = (c_cmaterial->rs*c_cmaterial->rs_a +
567	greg	2.6	tsa5c_cmaterial->ts_a) /
568	greg	2.1	(c_cmaterial->rs + ts);
569			a6 = (c_cmaterial->td + ts) /
570			(c_cmaterial->rd + c_cmaterial->td + ts);
571	greg	2.7	if (a6 < .999)
572	greg	2.1	d = c_cmaterial->rd/(1. - c_cmaterial->rs)/(1. - a6);
573	greg	2.7	else
574			d = c_cmaterial->td + ts;
575			scalecolor(radrgb, d);
576	greg	2.11	fprintf(matfp, "\nvoid trans %s\n0\n0\n", mname);
577			fprintf(matfp, "7 %f %f %f\n", colval(radrgb,RED),
578	greg	2.1	colval(radrgb,GRN), colval(radrgb,BLU));
579	greg	2.11	fprintf(matfp, "\t%f %f %f %f\n", c_cmaterial->rs, a5, a6,
580	greg	2.1	ts/(ts + c_cmaterial->td));
581			return(mname);
582			}
583	greg	2.3	/* check for plastic */
584	greg	2.21	if (c_cmaterial->rs < .1) {
585	greg	2.7	cvtcolor(radrgb, &c_cmaterial->rd_c,
586	greg	2.1	c_cmaterial->rd/(1.-c_cmaterial->rs));
587	greg	2.11	fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
588			fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
589	greg	2.1	colval(radrgb,GRN), colval(radrgb,BLU),
590			c_cmaterial->rs, c_cmaterial->rs_a);
591			return(mname);
592			}
593			/* else it's metal */
594	greg	2.7	/* average colors */
595			cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
596			cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
597	greg	2.1	addcolor(radrgb, c2);
598	greg	2.11	fprintf(matfp, "\nvoid metal %s\n0\n0\n", mname);
599			fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
600	greg	2.1	colval(radrgb,GRN), colval(radrgb,BLU),
601	greg	2.7	c_cmaterial->rs/(c_cmaterial->rd + c_cmaterial->rs),
602			c_cmaterial->rs_a);
603	greg	2.1	return(mname);
604			}
605
606
607	schorsch	2.28	void
608			cvtcolor( /* convert a CIE XYZ color to RGB */
609			COLOR radrgb,
610			register C_COLOR *ciec,
611			double intensity
612			)
613	greg	2.1	{
614			static COLOR ciexyz;
615
616	greg	2.4	c_ccvt(ciec, C_CSXY); /* get xy representation */
617	greg	2.1	ciexyz[1] = intensity;
618			ciexyz[0] = ciec->cx/ciec->cy*ciexyz[1];
619			ciexyz[2] = ciexyz[1]*(1./ciec->cy - 1.) - ciexyz[0];
620			cie_rgb(radrgb, ciexyz);
621			}
622
623
624			char *
625	schorsch	2.28	object(void) /* return current object name */
626	greg	2.1	{
627			static char objbuf[64];
628			register int i;
629			register char *cp;
630			int len;
631	greg	2.16	/* tracked by obj_handler */
632	greg	2.1	i = obj_nnames - sizeof(objbuf)/16;
633			if (i < 0)
634			i = 0;
635			for (cp = objbuf; i < obj_nnames &&
636			cp + (len=strlen(obj_name[i])) < objbuf+sizeof(objbuf)-1;
637			i++, *cp++ = '.') {
638			strcpy(cp, obj_name[i]);
639			cp += len;
640			}
641			*cp = '\0';
642			return(objbuf);
643			}
644
645
646			char *
647	schorsch	2.28	addarg( /* add argument and advance pointer */
648			register char *op,
649			register char *arg
650			)
651	greg	2.1	{
652			*op = ' ';
653	schorsch	2.27	while ( (++op = arg++) )
654	greg	2.1	;
655			return(op);
656			}