src/cv/mgf2rad.c

/* Copyright (c) 1996 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 * Convert MGF (Materials and Geometry Format) to Radiance
 */

#include <stdio.h>
#include <math.h>
#include <string.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 = stdout;                /* material output file */

int     r_comment(), r_cone(), r_cyl(), r_face(), r_ies(), r_ring(), r_sph();
char    *material(), *object(), *addarg();


main(argc, argv)                /* convert files to stdout */
int     argc;
char    *argv[];
{
        int     i;
                                /* 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(ac, av)               /* 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(ac, av)                  /* 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(ac, av)                   /* 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(ac, av)                   /* 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(ac, av)                  /* 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(ac, av)                  /* convert a face */
int     ac;
char    **av;
{
        static int      nfaces;
        char    *mat;
        register int    i;
        register C_VERTEX       *cv;
        FVECT   v;
        int     rv;
                                        /* 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 = flat_tri(cva[0]->p, cva[1]->p, cva[2]->p,
                                        cva[0]->n, cva[1]->n, cva[2]->n);
                        if (i < 0)
                                return(MG_OK);  /* degenerate (error?) */
                }
                if (!i) {                       /* smoothed triangles */
                        do_tri(mat, cva[0], cva[1], cva[2]);
                        if (ac == 5)
                                do_tri(mat, cva[2], cva[3], cva[0]);
                        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[invert ? ac-i : i])) == NULL)
                        return(MG_EUNDEF);
                xf_xfmpoint(v, cv->p);
                putv(v);
        }
        return(MG_OK);
}


int
r_ies(ac, av)                           /* 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);
}


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

        if (invert) {                   /* 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()                      /* get (and print) current material */
{
        char    *mname = "mat";
        COLOR   radrgb, c2;
        double  d;
        register int    i;

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


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