src/gen/mkillum.c

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

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

/*
 * Make illum sources for optimizing rendering process
 */

#include  "mkillum.h"

#include  <signal.h>

#include  <ctype.h>

                                /* default parameters */
#define  SAMPDENS       128             /* points per projected steradian */
#define  NSAMPS         32              /* samples per point */
#define  DFLMAT         "illum_mat"     /* material name */
                                /* selection options */
#define  S_NONE         0               /* select none */
#define  S_ELEM         1               /* select specified element */
#define  S_COMPL        2               /* select all but element */
#define  S_ALL          3               /* select all */

                                /* rtrace command and defaults */
char  *rtargv[64] = { "rtrace", "-dj", ".25", "-dr", "3", "-di+",
                "-ab", "2", "-ad", "256", "-as", "128", "-aa", ".15", };
int  rtargc = 14;
                                /* overriding rtrace options */
char  *myrtopts[] = { "-I-", "-i-", "-ov", "-h-", "-fff", NULL };

struct rtproc   rt;             /* our rtrace process */

struct illum_args  thisillum = {        /* our illum and default values */
                0,
                DFLMAT,
                DFLMAT,
                0,
                VOIDID,
                SAMPDENS,
                NSAMPS,
        };

char    matcheck[MAXSTR];       /* current material to include or exclude */
int     matselect = S_ALL;      /* selection criterion */

FUN     ofun[NUMOTYPE] = INIT_OTYPE;    /* object types */

int     gargc;                  /* global argc */
char    **gargv;                /* global argv */
#define  progname       gargv[0]

int     doneheader = 0;         /* printed header yet? */
#define  checkhead()    if (!doneheader++) printhead(gargc,gargv)

int     warnings = 1;           /* print warnings? */

extern char     *fgetline(), *fgetword(), *sskip(), 
                *atos(), *iskip(), *fskip();
extern FILE     *popen();


main(argc, argv)                /* compute illum distributions using rtrace */
int     argc;
char    *argv[];
{
        extern char     *getenv(), *getpath();
        char    *rtpath;
        FILE    *fp;
        register int    i;
                                /* set global arguments */
        gargv = argv;
                                /* set up rtrace command */
        for (i = 1; i < argc; i++) {
                if (argv[i][0] == '<' && !argv[i][1])
                        break;
                rtargv[rtargc++] = argv[i];
                if (argv[i][0] == '-' && argv[i][1] == 'w')
                        warnings = !warnings;
        }
        if ((gargc = i) < 2)
                error(USER, "too few arguments");
        rtargc--;
        for (i = 0; myrtopts[i] != NULL; i++)
                rtargv[rtargc++] = myrtopts[i];
        rtargv[rtargc++] = argv[gargc-1];
        rtargv[rtargc] = NULL;
                                /* just asking for defaults? */
        if (!strcmp(argv[gargc-1], "-defaults")) {
                rtpath = getpath(rtargv[0], getenv("PATH"), X_OK);
                if (rtpath == NULL) {
                        eputs(rtargv[0]);
                        eputs(": command not found\n");
                        exit(1);
                }
                execv(rtpath, rtargv);
                perror(rtpath);
                exit(1);
        }
                                /* else initialize and run our calculation */
        init();
        if (gargc+1 < argc)
                for (i = gargc+1; i < argc; i++) {
                        if ((fp = fopen(argv[i], "r")) == NULL {
                                sprintf(errmsg,
                                "cannot open scene file \"%s\"", argv[i]);
                                error(SYSTEM, errmsg);
                        }
                        filter(fp, argv[i]);
                        fclose(fp);
                }
        else
                filter(stdin, "standard input");
        quit(0);
}


quit(status)                    /* exit with status */
int  status;
{
        int     rtstat;

        rtstat = close_process(rt.pd);
        if (status == 0)
                if (rtstat < 0)
                        error(WARNING,
                        "unknown return status from rtrace process");
                else
                        status = rtstat;
        exit(status);
}


init()                          /* start rtrace and set up buffers */
{
        extern int  o_face(), o_sphere(), o_ring();
        int     maxbytes;
                                        /* set up object functions */
        ofun[OBJ_FACE].funp = o_face;
        ofun[OBJ_SPHERE].funp = o_sphere;
        ofun[OBJ_RING].funp = o_ring;
                                        /* set up signal handling */
        signal(SIGPIPE, quit);
                                        /* start rtrace process */
        maxbytes = open_process(rt.pd, rtargv);
        if (maxbytes == 0) {
                eputs(rtargv[0]);
                eputs(": command not found\n");
                exit(1);
        }
        if (maxbytes < 0)
                error(SYSTEM, "cannot start rtrace process");
        rt.bsiz = maxbytes/(6*sizeof(float));
        rt.buf = (float *)malloc(6*sizeof(float)*rt.bsiz--);
        rt.dest = (float **)malloc(sizeof(float *)*rt.bsiz);
        if (rt.buf == NULL || rt.dest == NULL)
                error(SYSTEM, "out of memory in init");
        rt.nrays = 0;
}


eputs(s)                                /* put string to stderr */
register char  *s;
{
        static int  midline = 0;

        if (!*s) return;
        if (!midline) {
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        midline = s[strlen(s)-1] != '\n';
}


wputs(s)                        /* print warning if enabled */
char  *s;
{
        if (warnings)
                eputs(s);
}


filter(infp, name)              /* process stream */
register FILE   *infp;
char    *name;
{
        char    buf[512];
        FILE    *pfp;
        register int    c;

        while ((c = getc(infp)) != EOF) {
                if (isspace(c))
                        continue;
                if (c == '#') {                         /* comment/options */
                        buf[0] = c;
                        fgets(buf+1, sizeof(buf)-1, infp);
                        xoptions(buf, name);
                } else if (c == '!') {                  /* command */
                        buf[0] = c;
                        fgetline(buf+1, sizeof(buf)-1, infp);
                        if ((pfp = popen(buf+1, "r")) == NULL) {
                                sprintf(errmsg, "cannot execute \"%s\"", buf);
                                error(SYSTEM, errmsg);
                        }
                        filter(pfp, buf);
                        pclose(pfp);
                } else {                                /* object */
                        ungetc(c, infp);
                        xobject(infp, name);
                }
        }
}


xoptions(s, nm)                 /* process options in string s */
char    *s;
char    *nm;
{
        extern FILE     *freopen();
        char    buf[64];
        int     nerrs = 0;
        register char   *cp;

        if (strncmp(s, "#@mkillum", 9) || !isspace(s[9])) {
                fputs(s, stdout);               /* not for us */
                return;
        }
        cp = s+10;
        while (*cp) {
                switch (*cp) {
                case ' ':
                case '\t':
                case '\n':
                        cp++;
                        continue;
                case 'm':                       /* material name */
                        if (*++cp != '=')
                                break;
                        if (!*++cp)
                                break;
                        atos(thisillum.matname, MAXSTR, cp);
                        cp = sskip(cp);
                        if (!(thisillum.flags & IL_DATCLB)) {
                                strcpy(thisillum.datafile, thisillum.matname);
                                thisillum.dfnum = 0;
                        }
                        continue;
                case 'f':                       /* data file name */
                        if (*++cp != '=')
                                break;
                        if (!*++cp) {
                                thisillum.flags &= ~IL_DATCLB;
                                continue;
                        }
                        atos(thisillum.datafile, MAXSTR, cp);
                        cp = sskip(cp);
                        thisillum.dfnum = 0;
                        thisillum.flags |= IL_DATCLB;
                        continue;
                case 'i':                       /* include material */
                case 'e':                       /* exclude material */
                        matselect = (*cp == 'i') ? S_ELEM : S_COMPL;
                        if (*++cp != '=')
                                break;
                        atos(matcheck, MAXSTR, ++cp);
                        cp = sskip(cp);
                        continue;
                case 'a':                       /* use everything */
                        cp = sskip(cp);
                        matselect = S_ALL;
                        continue;
                case 'n':                       /* use nothing (passive) */
                        cp = sskip(cp);
                        matselect = S_NONE;
                        continue;
                case 'c':                       /* color calculation */
                        if (*++cp != '=')
                                break;
                        switch (*++cp) {
                        case 'a':                       /* average */
                                thisillum.flags |= IL_COLAVG;
                                thisillum.flags &= ~IL_COLDST;
                                break;
                        case 'd':                       /* distribution */
                                thisillum.flags |= IL_COLDST;
                                thisillum.flags &= ~IL_COLAVG;
                                break;
                        case 'n':                       /* none */
                                thisillum.flags &= ~(IL_COLAVG|IL_COLDST);
                                break;
                        default:
                                goto opterr;
                        }
                        cp = sskip(cp);
                        continue;
                case 'd':                       /* point sample density */
                        if (*++cp != '=')
                                break;
                        if (!isintd(++cp, " \t\n"))
                                break;
                        thisillum.sampdens = atoi(cp);
                        cp = sskip(cp);
                        continue;
                case 's':                       /* point super-samples */
                        if (*++cp != '=')
                                break;
                        if (!isintd(++cp, " \t\n"))
                                break;
                        thisillum.nsamps = atoi(cp);
                        cp = sskip(cp);
                        continue;
                case 'l':                       /* light sources */
                        cp++;
                        if (*cp == '+')
                                thisillum.flags |= IL_LIGHT;
                        else if (*cp == '-')
                                thisillum.flags &= ~IL_LIGHT;
                        else
                                break;
                        cp++;
                        continue;
                case 'o':                       /* output file */
                        if (*++cp != '=')
                                break;
                        if (!*++cp)
                                break;
                        atos(buf, sizeof(buf), cp);
                        cp = sskip(cp);
                        if (freopen(buf, "w", stdout) == NULL) {
                                sprintf(errmsg,
                                "cannot open output file \"%s\"", buf);
                                error(SYSTEM, errmsg);
                        }
                        doneheader = 0;
                        continue;
                }
        opterr:                                 /* skip faulty option */
                cp = sskip(cp);
                nerrs++;
        }
                                                /* print header? */
        checkhead();
                                                /* issue warnings? */
        if (nerrs) {
                sprintf(errmsg, "(%s): %d error(s) in option line:",
                                nm, nerrs);
                error(WARNING, errmsg);
                wputs(s);
                printf("# %s: the following option line has %d error(s):\n",
                                progname, nerrs);
        }
                                                /* print pure comment */
        printf("# %s", s+2);
}


printhead(ac, av)                       /* print out header */
register int  ac;
register char  **av;
{
        putchar('#');
        while (ac-- > 0) {
                putchar(' ');
                fputs(*av++, stdout);
        }
        putchar('\n');
}


xobject(fp, nm)                         /* translate an object from fp */
FILE  *fp;
char  *nm;
{
        OBJREC  thisobj;
        char  str[MAXSTR];
        int  doit;
                                        /* read the object */
        if (fgetword(thisillum.altmat, MAXSTR, fp) == NULL)
                goto readerr;
        if (fgetword(str, MAXSTR, fp) == NULL)
                goto readerr;
                                        /* is it an alias? */
        if (!strcmp(str, ALIASID)) {
                if (fgetword(str, MAXSTR, fp) == NULL)
                        goto readerr;
                printf("\n%s %s %s", thisillum.altmat, ALIASID, str);
                if (fgetword(str, MAXSTR, fp) == NULL)
                        goto readerr;
                printf("\t%s\n", str);
                return;
        }
        thisobj.omod = OVOID;           /* unused field */
        if ((thisobj.otype = otype(str)) < 0) {
                sprintf(errmsg, "(%s): unknown type \"%s\"", nm, str);
                error(USER, errmsg);
        }
        if (fgetword(str, MAXSTR, fp) == NULL)
                goto readerr;
        thisobj.oname = str;
        if (readfargs(&thisobj.oargs, fp) != 1)
                goto readerr;
        thisobj.os = NULL;
                                        /* check for translation */
        switch (matselect) {
        case S_NONE:
                doit = 0;
                break;
        case S_ALL:
                doit = 1;
                break;
        case S_ELEM:
                doit = !strcmp(thisillum.altmat, matcheck);
                break;
        case S_COMPL:
                doit = strcmp(thisillum.altmat, matcheck);
                break;
        }
        doit = doit && issurface(thisobj.otype);
                                                /* print header? */
        checkhead();
                                                /* process object */
        if (doit)
                (*ofun[thisobj.otype].funp)(&thisobj, &thisillum, &rt, nm);
        else
                printobj(thisillum.altmat, &thisobj);
                                                /* free arguments */
        freefargs(&thisobj.oargs);
        return;
readerr:
        sprintf(errmsg, "(%s): error reading scene", nm);
        error(USER, errmsg);
}
Revision:	1.4
Committed:	Wed Jul 24 12:22:03 1991 UTC (32 years, 9 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+21 -40 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1991 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Make illum sources for optimizing rendering process
9			*/
10
11	greg	1.2	#include "mkillum.h"
12	greg	1.1
13	greg	1.3	#include <signal.h>
14
15	greg	1.2	#include <ctype.h>
16	greg	1.1
17			/* default parameters */
18			#define SAMPDENS 128 /* points per projected steradian */
19			#define NSAMPS 32 /* samples per point */
20			#define DFLMAT "illum_mat" /* material name */
21			/* selection options */
22			#define S_NONE 0 /* select none */
23			#define S_ELEM 1 /* select specified element */
24			#define S_COMPL 2 /* select all but element */
25			#define S_ALL 3 /* select all */
26
27			/* rtrace command and defaults */
28	greg	1.4	char *rtargv[64] = { "rtrace", "-dj", ".25", "-dr", "3", "-di+",
29			"-ab", "2", "-ad", "256", "-as", "128", "-aa", ".15", };
30			int rtargc = 14;
31	greg	1.1	/* overriding rtrace options */
32	greg	1.4	char *myrtopts[] = { "-I-", "-i-", "-ov", "-h-", "-fff", NULL };
33	greg	1.1
34	greg	1.2	struct rtproc rt; /* our rtrace process */
35	greg	1.1
36	greg	1.2	struct illum_args thisillum = { /* our illum and default values */
37			0,
38			DFLMAT,
39			DFLMAT,
40			0,
41			VOIDID,
42	greg	1.3	SAMPDENS,
43	greg	1.2	NSAMPS,
44			};
45	greg	1.1
46			char matcheck[MAXSTR]; /* current material to include or exclude */
47			int matselect = S_ALL; /* selection criterion */
48
49	greg	1.2	FUN ofun[NUMOTYPE] = INIT_OTYPE; /* object types */
50	greg	1.1
51			int gargc; /* global argc */
52			char *gargv; / global argv */
53			#define progname gargv[0]
54
55			int doneheader = 0; /* printed header yet? */
56	greg	1.2	#define checkhead() if (!doneheader++) printhead(gargc,gargv)
57	greg	1.1
58	greg	1.2	int warnings = 1; /* print warnings? */
59
60	greg	1.1	extern char fgetline(), fgetword(), *sskip(),
61			atos(), iskip(), *fskip();
62			extern FILE *popen();
63
64
65			main(argc, argv) /* compute illum distributions using rtrace */
66			int argc;
67			char *argv[];
68			{
69			extern char getenv(), getpath();
70			char *rtpath;
71	greg	1.3	FILE *fp;
72	greg	1.1	register int i;
73			/* set global arguments */
74	greg	1.3	gargv = argv;
75	greg	1.1	/* set up rtrace command */
76	greg	1.3	for (i = 1; i < argc; i++) {
77			if (argv[i][0] == '<' && !argv[i][1])
78			break;
79	greg	1.1	rtargv[rtargc++] = argv[i];
80	greg	1.2	if (argv[i][0] == '-' && argv[i][1] == 'w')
81			warnings = !warnings;
82			}
83	greg	1.3	if ((gargc = i) < 2)
84			error(USER, "too few arguments");
85			rtargc--;
86	greg	1.1	for (i = 0; myrtopts[i] != NULL; i++)
87			rtargv[rtargc++] = myrtopts[i];
88	greg	1.3	rtargv[rtargc++] = argv[gargc-1];
89	greg	1.1	rtargv[rtargc] = NULL;
90			/* just asking for defaults? */
91	greg	1.3	if (!strcmp(argv[gargc-1], "-defaults")) {
92	greg	1.1	rtpath = getpath(rtargv[0], getenv("PATH"), X_OK);
93			if (rtpath == NULL) {
94			eputs(rtargv[0]);
95			eputs(": command not found\n");
96			exit(1);
97			}
98			execv(rtpath, rtargv);
99			perror(rtpath);
100			exit(1);
101			}
102			/* else initialize and run our calculation */
103			init();
104	greg	1.3	if (gargc+1 < argc)
105			for (i = gargc+1; i < argc; i++) {
106			if ((fp = fopen(argv[i], "r")) == NULL {
107			sprintf(errmsg,
108			"cannot open scene file \"%s\"", argv[i]);
109			error(SYSTEM, errmsg);
110			}
111			filter(fp, argv[i]);
112			fclose(fp);
113			}
114			else
115			filter(stdin, "standard input");
116	greg	1.2	quit(0);
117	greg	1.1	}
118
119
120	greg	1.3	quit(status) /* exit with status */
121			int status;
122			{
123			int rtstat;
124
125			rtstat = close_process(rt.pd);
126			if (status == 0)
127			if (rtstat < 0)
128			error(WARNING,
129			"unknown return status from rtrace process");
130			else
131			status = rtstat;
132			exit(status);
133			}
134
135
136	greg	1.1	init() /* start rtrace and set up buffers */
137			{
138	greg	1.4	extern int o_face(), o_sphere(), o_ring();
139	greg	1.1	int maxbytes;
140	greg	1.3	/* set up object functions */
141			ofun[OBJ_FACE].funp = o_face;
142	greg	1.4	ofun[OBJ_SPHERE].funp = o_sphere;
143	greg	1.3	ofun[OBJ_RING].funp = o_ring;
144			/* set up signal handling */
145			signal(SIGPIPE, quit);
146			/* start rtrace process */
147	greg	1.2	maxbytes = open_process(rt.pd, rtargv);
148	greg	1.1	if (maxbytes == 0) {
149			eputs(rtargv[0]);
150			eputs(": command not found\n");
151			exit(1);
152			}
153			if (maxbytes < 0)
154			error(SYSTEM, "cannot start rtrace process");
155	greg	1.2	rt.bsiz = maxbytes/(6*sizeof(float));
156	greg	1.4	rt.buf = (float )malloc(6sizeof(float)*rt.bsiz--);
157			rt.dest = (float *)malloc(sizeof(float )*rt.bsiz);
158			if (rt.buf == NULL \|\| rt.dest == NULL)
159	greg	1.1	error(SYSTEM, "out of memory in init");
160	greg	1.2	rt.nrays = 0;
161	greg	1.1	}
162
163
164			eputs(s) /* put string to stderr */
165			register char *s;
166			{
167			static int midline = 0;
168
169			if (!*s) return;
170			if (!midline) {
171			fputs(progname, stderr);
172			fputs(": ", stderr);
173			}
174			fputs(s, stderr);
175			midline = s[strlen(s)-1] != '\n';
176			}
177
178
179	greg	1.2	wputs(s) /* print warning if enabled */
180			char *s;
181			{
182			if (warnings)
183			eputs(s);
184			}
185
186
187			filter(infp, name) /* process stream */
188	greg	1.1	register FILE *infp;
189			char *name;
190			{
191			char buf[512];
192			FILE *pfp;
193			register int c;
194
195			while ((c = getc(infp)) != EOF) {
196			if (isspace(c))
197			continue;
198			if (c == '#') { /* comment/options */
199			buf[0] = c;
200			fgets(buf+1, sizeof(buf)-1, infp);
201	greg	1.2	xoptions(buf, name);
202	greg	1.1	} else if (c == '!') { /* command */
203			buf[0] = c;
204			fgetline(buf+1, sizeof(buf)-1, infp);
205			if ((pfp = popen(buf+1, "r")) == NULL) {
206			sprintf(errmsg, "cannot execute \"%s\"", buf);
207			error(SYSTEM, errmsg);
208			}
209	greg	1.2	filter(pfp, buf);
210	greg	1.1	pclose(pfp);
211			} else { /* object */
212			ungetc(c, infp);
213			xobject(infp, name);
214			}
215			}
216			}
217
218
219	greg	1.2	xoptions(s, nm) /* process options in string s */
220	greg	1.1	char *s;
221			char *nm;
222			{
223			extern FILE *freopen();
224			char buf[64];
225			int nerrs = 0;
226			register char *cp;
227
228	greg	1.2	if (strncmp(s, "#@mkillum", 9) \|\| !isspace(s[9])) {
229			fputs(s, stdout); /* not for us */
230	greg	1.1	return;
231	greg	1.2	}
232	greg	1.1	cp = s+10;
233			while (*cp) {
234			switch (*cp) {
235			case ' ':
236			case '\t':
237			case '\n':
238			cp++;
239			continue;
240			case 'm': /* material name */
241	greg	1.2	if (*++cp != '=')
242	greg	1.1	break;
243	greg	1.2	if (!*++cp)
244			break;
245	greg	1.1	atos(thisillum.matname, MAXSTR, cp);
246			cp = sskip(cp);
247			if (!(thisillum.flags & IL_DATCLB)) {
248			strcpy(thisillum.datafile, thisillum.matname);
249			thisillum.dfnum = 0;
250			}
251			continue;
252			case 'f': /* data file name */
253	greg	1.2	if (*++cp != '=')
254	greg	1.1	break;
255	greg	1.2	if (!*++cp) {
256	greg	1.1	thisillum.flags &= ~IL_DATCLB;
257			continue;
258			}
259			atos(thisillum.datafile, MAXSTR, cp);
260			cp = sskip(cp);
261			thisillum.dfnum = 0;
262			thisillum.flags \|= IL_DATCLB;
263			continue;
264			case 'i': /* include material */
265			case 'e': /* exclude material */
266	greg	1.2	matselect = (*cp == 'i') ? S_ELEM : S_COMPL;
267			if (*++cp != '=')
268	greg	1.1	break;
269	greg	1.2	atos(matcheck, MAXSTR, ++cp);
270	greg	1.1	cp = sskip(cp);
271			continue;
272			case 'a': /* use everything */
273			cp = sskip(cp);
274			matselect = S_ALL;
275			continue;
276			case 'n': /* use nothing (passive) */
277			cp = sskip(cp);
278			matselect = S_NONE;
279			continue;
280			case 'c': /* color calculation */
281	greg	1.2	if (*++cp != '=')
282	greg	1.1	break;
283	greg	1.2	switch (*++cp) {
284	greg	1.1	case 'a': /* average */
285			thisillum.flags \|= IL_COLAVG;
286			thisillum.flags &= ~IL_COLDST;
287			break;
288			case 'd': /* distribution */
289			thisillum.flags \|= IL_COLDST;
290			thisillum.flags &= ~IL_COLAVG;
291			break;
292			case 'n': /* none */
293			thisillum.flags &= ~(IL_COLAVG\|IL_COLDST);
294			break;
295			default:
296			goto opterr;
297			}
298			cp = sskip(cp);
299			continue;
300			case 'd': /* point sample density */
301	greg	1.2	if (*++cp != '=')
302	greg	1.1	break;
303	greg	1.2	if (!isintd(++cp, " \t\n"))
304	greg	1.1	break;
305	greg	1.3	thisillum.sampdens = atoi(cp);
306	greg	1.1	cp = sskip(cp);
307			continue;
308			case 's': /* point super-samples */
309	greg	1.2	if (*++cp != '=')
310	greg	1.1	break;
311	greg	1.2	if (!isintd(++cp, " \t\n"))
312	greg	1.1	break;
313			thisillum.nsamps = atoi(cp);
314			cp = sskip(cp);
315			continue;
316	greg	1.3	case 'l': /* light sources */
317	greg	1.4	cp++;
318			if (*cp == '+')
319	greg	1.3	thisillum.flags \|= IL_LIGHT;
320	greg	1.4	else if (*cp == '-')
321			thisillum.flags &= ~IL_LIGHT;
322	greg	1.3	else
323	greg	1.4	break;
324			cp++;
325	greg	1.3	continue;
326	greg	1.1	case 'o': /* output file */
327	greg	1.2	if (*++cp != '=')
328	greg	1.1	break;
329	greg	1.2	if (!*++cp)
330			break;
331	greg	1.1	atos(buf, sizeof(buf), cp);
332			cp = sskip(cp);
333			if (freopen(buf, "w", stdout) == NULL) {
334			sprintf(errmsg,
335			"cannot open output file \"%s\"", buf);
336			error(SYSTEM, errmsg);
337			}
338			doneheader = 0;
339			continue;
340			}
341			opterr: /* skip faulty option */
342			cp = sskip(cp);
343			nerrs++;
344			}
345	greg	1.2	/* print header? */
346			checkhead();
347			/* issue warnings? */
348	greg	1.1	if (nerrs) {
349			sprintf(errmsg, "(%s): %d error(s) in option line:",
350			nm, nerrs);
351			error(WARNING, errmsg);
352	greg	1.2	wputs(s);
353			printf("# %s: the following option line has %d error(s):\n",
354			progname, nerrs);
355	greg	1.1	}
356	greg	1.2	/* print pure comment */
357	greg	1.4	printf("# %s", s+2);
358	greg	1.1	}
359	greg	1.2
360
361			printhead(ac, av) /* print out header */
362			register int ac;
363			register char **av;
364			{
365			putchar('#');
366			while (ac-- > 0) {
367			putchar(' ');
368			fputs(*av++, stdout);
369			}
370			putchar('\n');
371			}
372
373
374			xobject(fp, nm) /* translate an object from fp */
375			FILE *fp;
376			char *nm;
377			{
378			OBJREC thisobj;
379			char str[MAXSTR];
380			int doit;
381			/* read the object */
382			if (fgetword(thisillum.altmat, MAXSTR, fp) == NULL)
383			goto readerr;
384			if (fgetword(str, MAXSTR, fp) == NULL)
385			goto readerr;
386			/* is it an alias? */
387			if (!strcmp(str, ALIASID)) {
388			if (fgetword(str, MAXSTR, fp) == NULL)
389			goto readerr;
390			printf("\n%s %s %s", thisillum.altmat, ALIASID, str);
391			if (fgetword(str, MAXSTR, fp) == NULL)
392			goto readerr;
393	greg	1.4	printf("\t%s\n", str);
394	greg	1.2	return;
395			}
396	greg	1.4	thisobj.omod = OVOID; /* unused field */
397	greg	1.2	if ((thisobj.otype = otype(str)) < 0) {
398			sprintf(errmsg, "(%s): unknown type \"%s\"", nm, str);
399			error(USER, errmsg);
400			}
401			if (fgetword(str, MAXSTR, fp) == NULL)
402			goto readerr;
403			thisobj.oname = str;
404			if (readfargs(&thisobj.oargs, fp) != 1)
405			goto readerr;
406			thisobj.os = NULL;
407			/* check for translation */
408			switch (matselect) {
409			case S_NONE:
410			doit = 0;
411			break;
412			case S_ALL:
413	greg	1.4	doit = 1;
414	greg	1.2	break;
415			case S_ELEM:
416			doit = !strcmp(thisillum.altmat, matcheck);
417			break;
418			case S_COMPL:
419			doit = strcmp(thisillum.altmat, matcheck);
420			break;
421			}
422	greg	1.4	doit = doit && issurface(thisobj.otype);
423	greg	1.2	/* print header? */
424			checkhead();
425			/* process object */
426			if (doit)
427	greg	1.4	(*ofun[thisobj.otype].funp)(&thisobj, &thisillum, &rt, nm);
428	greg	1.2	else
429			printobj(thisillum.altmat, &thisobj);
430			/* free arguments */
431			freefargs(&thisobj.oargs);
432			return;
433			readerr:
434			sprintf(errmsg, "(%s): error reading scene", nm);
435			error(USER, errmsg);
436			}