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 */
                for (i = 1; i < ac; i++) {
                        if ((cv = c_getvert(av[i])) == NULL)
                                return(MG_EUNDEF);
                        if (is0vect(cv->n))
                                break;
                }
                if (i == ac) {                  /* break into triangles */
                        do_tri(mat, av[1], av[2], av[3]);
                        if (ac == 5)
                                do_tri(mat, av[3], av[4], av[1]);
                        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 = 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, vn1, vn2, vn3)              /* put out smoothed triangle */
char    *mat, *vn1, *vn2, *vn3;
{
        static int      ntris;
        BARYCCM bvecs;
        FLOAT   bcoor[3][3];
        C_VERTEX        *cv1, *cv2, *cv3;
        FVECT   v1, v2, v3;
        FVECT   n1, n2, n3;
        register int    i;
                        /* the following is repeat code, so assume it's OK */
        cv2 = c_getvert(vn2);
        if (invert) {
                cv3 = c_getvert(vn1);
                cv1 = c_getvert(vn3);
        } else {
                cv1 = c_getvert(vn1);
                cv3 = c_getvert(vn3);
        }
        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.21
Committed:	Tue Feb 27 20:11:27 1996 UTC (28 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.20:	+2 -3 lines
Log Message:	made choice of plastic more typical
#	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.1	for (i = 1; i < ac; i++) {
311			if ((cv = c_getvert(av[i])) == NULL)
312			return(MG_EUNDEF);
313			if (is0vect(cv->n))
314			break;
315			}
316			if (i == ac) { /* break into triangles */
317			do_tri(mat, av[1], av[2], av[3]);
318			if (ac == 5)
319			do_tri(mat, av[3], av[4], av[1]);
320			return(MG_OK);
321			}
322			}
323	greg	2.16	/* spit out unsmoothed primitive */
324	greg	2.1	printf("\n%s polygon %sf%d\n", mat, object(), ++nfaces);
325			printf("0\n0\n%d\n", 3*(ac-1));
326	greg	2.16	for (i = 1; i < ac; i++) { /* get, transform, print each vertex */
327	greg	2.9	if ((cv = c_getvert(av[invert ? ac-i : i])) == NULL)
328	greg	2.1	return(MG_EUNDEF);
329			xf_xfmpoint(v, cv->p);
330			putv(v);
331			}
332			return(MG_OK);
333			}
334
335
336	greg	2.15	int
337	greg	2.1	r_ies(ac, av) /* convert an IES luminaire file */
338			int ac;
339			char **av;
340			{
341			int xa0 = 2;
342	greg	2.15	char combuf[128];
343	greg	2.1	char fname[48];
344			char *oname;
345			register char *op;
346			register int i;
347	greg	2.16	/* check argument count */
348	greg	2.1	if (ac < 2)
349			return(MG_EARGC);
350	greg	2.16	/* construct output file name */
351	greg	2.1	if ((op = strrchr(av[1], '/')) == NULL)
352			op = av[1];
353			(void)strcpy(fname, op);
354			if ((op = strrchr(fname, '.')) == NULL)
355			op = fname + strlen(fname);
356			(void)strcpy(op, ".rad");
357	greg	2.16	/* see if we need to run ies2rad */
358	greg	2.17	if (access(fname, 0) == -1) {
359	greg	2.16	(void)strcpy(combuf, "ies2rad");/* build ies2rad command */
360			op = combuf + 7; /* get -m option (first) */
361			if (ac-xa0 >= 2 && !strcmp(av[xa0], "-m")) {
362			if (!isflt(av[xa0+1]))
363			return(MG_ETYPE);
364			op = addarg(addarg(op, "-m"), av[xa0+1]);
365			xa0 += 2;
366			}
367			op++ = ' '; / build IES filename */
368			i = 0;
369			if (mg_file != NULL &&
370			(oname = strrchr(mg_file->fname,'/')) != NULL) {
371			i = oname - mg_file->fname + 1;
372			(void)strcpy(op, mg_file->fname);
373			}
374			(void)strcpy(op+i, av[1]);
375			if (access(op, 0) == -1) /* check for file existence */
376			return(MG_ENOFILE);
377			system(combuf); /* run ies2rad */
378			if (access(fname, 0) == -1) /* check success */
379			return(MG_EINCL);
380			}
381			printf("\n!xform"); /* put out xform command */
382	greg	2.1	oname = object();
383	greg	2.4	if (*oname) {
384			printf(" -n ");
385			for (op = oname; op[1]; op++) /* remove trailing separator */
386			putchar(*op);
387			}
388	greg	2.1	for (i = xa0; i < ac; i++)
389			printf(" %s", av[i]);
390			if (ac > xa0 && xf_argc > 0)
391			printf(" -i 1");
392			for (i = 0; i < xf_argc; i++)
393			printf(" %s", xf_argv[i]);
394			printf(" %s\n", fname);
395			return(MG_OK);
396			}
397
398
399			do_tri(mat, vn1, vn2, vn3) /* put out smoothed triangle */
400			char mat, vn1, vn2, vn3;
401			{
402			static int ntris;
403			BARYCCM bvecs;
404			FLOAT bcoor[3][3];
405			C_VERTEX cv1, cv2, *cv3;
406			FVECT v1, v2, v3;
407			FVECT n1, n2, n3;
408			register int i;
409			/* the following is repeat code, so assume it's OK */
410			cv2 = c_getvert(vn2);
411	greg	2.9	if (invert) {
412			cv3 = c_getvert(vn1);
413			cv1 = c_getvert(vn3);
414			} else {
415			cv1 = c_getvert(vn1);
416			cv3 = c_getvert(vn3);
417			}
418	greg	2.1	xf_xfmpoint(v1, cv1->p);
419			xf_xfmpoint(v2, cv2->p);
420			xf_xfmpoint(v3, cv3->p);
421	greg	2.16	/* compute barycentric coords. */
422	greg	2.2	if (comp_baryc(&bvecs, v1, v2, v3) < 0)
423			return; /* degenerate triangle! */
424	greg	2.16	printf("\n%s texfunc T-nor\n", mat); /* put out texture */
425	greg	2.2	printf("4 dx dy dz %s\n0\n", TCALNAME);
426			xf_rotvect(n1, cv1->n);
427			xf_rotvect(n2, cv2->n);
428			xf_rotvect(n3, cv3->n);
429			for (i = 0; i < 3; i++) {
430			bcoor[i][0] = n1[i];
431			bcoor[i][1] = n2[i];
432			bcoor[i][2] = n3[i];
433	greg	2.1	}
434	greg	2.2	put_baryc(&bvecs, bcoor, 3);
435	greg	2.16	/* put out triangle */
436	greg	2.2	printf("\nT-nor polygon %st%d\n", object(), ++ntris);
437	greg	2.1	printf("0\n0\n9\n");
438			putv(v1);
439			putv(v2);
440			putv(v3);
441			}
442
443
444			char *
445			material() /* get (and print) current material */
446			{
447			char *mname = "mat";
448			COLOR radrgb, c2;
449			double d;
450			register int i;
451
452	greg	2.5	if (c_cmname != NULL)
453			mname = c_cmname;
454	greg	2.1	if (!c_cmaterial->clock)
455			return(mname); /* already current */
456			/* else update output */
457			c_cmaterial->clock = 0;
458			if (c_cmaterial->ed > .1) { /* emitter */
459			cvtcolor(radrgb, &c_cmaterial->ed_c,
460	greg	2.12	emultc_cmaterial->ed/(PIWHTEFFICACY));
461	greg	2.2	if (glowdist < FHUGE) { /* do a glow */
462	greg	2.11	fprintf(matfp, "\nvoid glow %s\n0\n0\n", mname);
463			fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
464	greg	2.1	colval(radrgb,GRN),
465			colval(radrgb,BLU), glowdist);
466			} else {
467	greg	2.11	fprintf(matfp, "\nvoid light %s\n0\n0\n", mname);
468			fprintf(matfp, "3 %f %f %f\n", colval(radrgb,RED),
469	greg	2.1	colval(radrgb,GRN),
470			colval(radrgb,BLU));
471			}
472			return(mname);
473			}
474			d = c_cmaterial->rd + c_cmaterial->td +
475			c_cmaterial->rs + c_cmaterial->ts;
476	greg	2.7	if (d < 0. \| d > 1.)
477	greg	2.1	return(NULL);
478	greg	2.14	/* check for glass/dielectric */
479			if (c_cmaterial->nr > 1.1 &&
480			c_cmaterial->ts > .25 && c_cmaterial->rs <= .125 &&
481			c_cmaterial->td <= .01 && c_cmaterial->rd <= .01 &&
482			c_cmaterial->rs_a <= .01 && c_cmaterial->ts_a <= .01) {
483			cvtcolor(radrgb, &c_cmaterial->ts_c,
484			c_cmaterial->ts + c_cmaterial->rs);
485			if (c_cmaterial->sided) { /* dielectric */
486			colval(radrgb,RED) = pow(colval(radrgb,RED),
487			1./C_1SIDEDTHICK);
488			colval(radrgb,GRN) = pow(colval(radrgb,GRN),
489			1./C_1SIDEDTHICK);
490			colval(radrgb,BLU) = pow(colval(radrgb,BLU),
491			1./C_1SIDEDTHICK);
492			fprintf(matfp, "\nvoid dielectric %s\n0\n0\n", mname);
493			fprintf(matfp, "5 %g %g %g %f 0\n", colval(radrgb,RED),
494			colval(radrgb,GRN), colval(radrgb,BLU),
495			c_cmaterial->nr);
496			return(mname);
497			}
498			/* glass */
499			fprintf(matfp, "\nvoid glass %s\n0\n0\n", mname);
500			fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
501			colval(radrgb,GRN), colval(radrgb,BLU),
502			c_cmaterial->nr);
503			return(mname);
504			}
505	greg	2.3	/* check for trans */
506			if (c_cmaterial->td > .01 \|\| c_cmaterial->ts > .01) {
507	greg	2.1	double ts, a5, a6;
508
509	greg	2.6	if (c_cmaterial->sided) {
510			ts = sqrt(c_cmaterial->ts); /* approximate */
511			a5 = .5;
512	greg	2.7	} else {
513			ts = c_cmaterial->ts;
514	greg	2.6	a5 = 1.;
515	greg	2.7	}
516	greg	2.1	/* average colors */
517			d = c_cmaterial->rd + c_cmaterial->td + ts;
518			cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd/d);
519			cvtcolor(c2, &c_cmaterial->td_c, c_cmaterial->td/d);
520			addcolor(radrgb, c2);
521			cvtcolor(c2, &c_cmaterial->ts_c, ts/d);
522			addcolor(radrgb, c2);
523			if (c_cmaterial->rs + ts > .0001)
524			a5 = (c_cmaterial->rs*c_cmaterial->rs_a +
525	greg	2.6	tsa5c_cmaterial->ts_a) /
526	greg	2.1	(c_cmaterial->rs + ts);
527			a6 = (c_cmaterial->td + ts) /
528			(c_cmaterial->rd + c_cmaterial->td + ts);
529	greg	2.7	if (a6 < .999)
530	greg	2.1	d = c_cmaterial->rd/(1. - c_cmaterial->rs)/(1. - a6);
531	greg	2.7	else
532			d = c_cmaterial->td + ts;
533			scalecolor(radrgb, d);
534	greg	2.11	fprintf(matfp, "\nvoid trans %s\n0\n0\n", mname);
535			fprintf(matfp, "7 %f %f %f\n", colval(radrgb,RED),
536	greg	2.1	colval(radrgb,GRN), colval(radrgb,BLU));
537	greg	2.11	fprintf(matfp, "\t%f %f %f %f\n", c_cmaterial->rs, a5, a6,
538	greg	2.1	ts/(ts + c_cmaterial->td));
539			return(mname);
540			}
541	greg	2.3	/* check for plastic */
542	greg	2.21	if (c_cmaterial->rs < .1) {
543	greg	2.7	cvtcolor(radrgb, &c_cmaterial->rd_c,
544	greg	2.1	c_cmaterial->rd/(1.-c_cmaterial->rs));
545	greg	2.11	fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
546			fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
547	greg	2.1	colval(radrgb,GRN), colval(radrgb,BLU),
548			c_cmaterial->rs, c_cmaterial->rs_a);
549			return(mname);
550			}
551			/* else it's metal */
552	greg	2.7	/* average colors */
553			cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
554			cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
555	greg	2.1	addcolor(radrgb, c2);
556	greg	2.11	fprintf(matfp, "\nvoid metal %s\n0\n0\n", mname);
557			fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
558	greg	2.1	colval(radrgb,GRN), colval(radrgb,BLU),
559	greg	2.7	c_cmaterial->rs/(c_cmaterial->rd + c_cmaterial->rs),
560			c_cmaterial->rs_a);
561	greg	2.1	return(mname);
562			}
563
564
565	greg	2.16	cvtcolor(radrgb, ciec, intensity) /* convert a CIE XYZ color to RGB */
566	greg	2.1	COLOR radrgb;
567			register C_COLOR *ciec;
568			double intensity;
569			{
570			static COLOR ciexyz;
571
572	greg	2.4	c_ccvt(ciec, C_CSXY); /* get xy representation */
573	greg	2.1	ciexyz[1] = intensity;
574			ciexyz[0] = ciec->cx/ciec->cy*ciexyz[1];
575			ciexyz[2] = ciexyz[1]*(1./ciec->cy - 1.) - ciexyz[0];
576			cie_rgb(radrgb, ciexyz);
577			}
578
579
580			char *
581			object() /* return current object name */
582			{
583			static char objbuf[64];
584			register int i;
585			register char *cp;
586			int len;
587	greg	2.16	/* tracked by obj_handler */
588	greg	2.1	i = obj_nnames - sizeof(objbuf)/16;
589			if (i < 0)
590			i = 0;
591			for (cp = objbuf; i < obj_nnames &&
592			cp + (len=strlen(obj_name[i])) < objbuf+sizeof(objbuf)-1;
593			i++, *cp++ = '.') {
594			strcpy(cp, obj_name[i]);
595			cp += len;
596			}
597			*cp = '\0';
598			return(objbuf);
599			}
600
601
602			char *
603			addarg(op, arg) /* add argument and advance pointer */
604			register char op, arg;
605			{
606			*op = ' ';
607			while (++op = arg++)
608			;
609			return(op);
610			}