src/gen/mkillum.c

#ifndef lint
static const char RCSid[] = "$Id: mkillum.c,v 2.18 2003/10/22 02:06:34 greg Exp $";
#endif
/*
 * Make illum sources for optimizing rendering process
 */

#include  <signal.h>
#include  <ctype.h>

#include  "platform.h"
#include  "mkillum.h"
#include  "random.h"

                                /* default parameters */
#define  SAMPDENS       48              /* points per projected steradian */
#define  NSAMPS         32              /* samples per point */
#define  DFLMAT         "illum_mat"     /* material name */
#define  DFLDAT         "illum"         /* data file 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", "-dv-",
                "-ab", "2", "-ad", "1024", "-as", "512", "-aa", ".1", };
int  rtargc = 14;
                                /* overriding rtrace options */
char  *myrtopts[] = { "-I-", "-i-", "-ld-", "-ov", "-h-",
                        "-fff", "-y", "0", NULL };

struct rtproc   rt;             /* our rtrace process */

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

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? */

void init(void);
void filter(register FILE       *infp, char     *name);
void xoptions(char      *s, char        *nm);
void printopts(void);
void printhead(register int  ac, register char  **av);
void xobject(FILE  *fp, char  *nm);


int
main(           /* compute illum distributions using rtrace */
        int     argc,
        char    *argv[]
)
{
        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] == '\0')
                        break;
                rtargv[rtargc++] = argv[i];
                if (argv[i][0] == '-' && argv[i][1] == 'w')
                        switch (argv[i][2]) {
                        case '\0':
                                warnings = !warnings;
                                break;
                        case '+':
                        case 'T': case 't':
                        case 'Y': case 'y':
                        case '1':
                                warnings = 1;
                                break;
                        case '-':
                        case 'F': case 'f':
                        case 'N': case 'n':
                        case '0':
                                warnings = 0;
                                break;
                        }
        }
        gargc = i;
        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")) {
                printopts(); fflush(stdout);
                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);
        }
        if (gargc < 2 || argv[gargc-1][0] == '-')
                error(USER, "missing octree argument");
                                /* 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");
        return 0;
}


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

void
init(void)                              /* 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 */
#ifdef SIGPIPE /* not present on Windows */
        signal(SIGPIPE, quit);
#endif
                                        /* start rtrace process */
        errno = 0;
        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;
                                        /* set up urand */
        initurand(16384);
}


void
eputs(                          /* 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';
}


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


void
filter(         /* 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);
                }
        }
}


void
xoptions(                       /* 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':
                case '\r':
                case '\f':
                        cp++;
                        continue;
                case 'm':                       /* material name */
                        if (*++cp != '=')
                                break;
                        if (!*++cp || isspace(*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 || isspace(*cp)) {
                                strcpy(thisillum.datafile,thisillum.matname);
                                thisillum.dfnum = 0;
                                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 */
                        if (cp[1] != '=')
                                break;
                        matselect = (*cp == 'i') ? S_ELEM : S_COMPL;
                        cp += 2;
                        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 = (thisillum.flags|IL_COLAVG)
                                                        & ~IL_COLDST;
                                break;
                        case 'd':                       /* distribution */
                                thisillum.flags |= (IL_COLDST|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\r"))
                                break;
                        thisillum.sampdens = atoi(cp);
                        cp = sskip(cp);
                        continue;
                case 's':                       /* point super-samples */
                        if (*++cp != '=')
                                break;
                        if (!isintd(++cp, " \t\n\r"))
                                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 'b':                       /* brightness */
                        if (*++cp != '=')
                                break;
                        if (!isfltd(++cp, " \t\n\r"))
                                break;
                        thisillum.minbrt = atof(cp);
                        if (thisillum.minbrt < 0.)
                                thisillum.minbrt = 0.;
                        cp = sskip(cp);
                        continue;
                case 'o':                       /* output file */
                        if (*++cp != '=')
                                break;
                        if (!*++cp || isspace(*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;
                case '!':                       /* processed file! */
                        sprintf(errmsg, "(%s): already processed!", nm);
                        error(WARNING, errmsg);
                        matselect = S_NONE;
                        return;
                }
        opterr:                                 /* skip faulty option */
                while (*cp && !isspace(*cp))
                        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);
}

void
printopts(void)                 /* print out option default values */
{
        printf("m=%-15s\t\t# material name\n", thisillum.matname);
        printf("f=%-15s\t\t# data file name\n", thisillum.datafile);
        if (thisillum.flags & IL_COLAVG)
                if (thisillum.flags & IL_COLDST)
                        printf("c=d\t\t\t\t# color distribution\n");
                else
                        printf("c=a\t\t\t\t# color average\n");
        else
                printf("c=n\t\t\t\t# color none\n");
        if (thisillum.flags & IL_LIGHT)
                printf("l+\t\t\t\t# light type on\n");
        else
                printf("l-\t\t\t\t# light type off\n");
        printf("d=%d\t\t\t\t# density of points\n", thisillum.sampdens);
        printf("s=%d\t\t\t\t# samples per point\n", thisillum.nsamps);
        printf("b=%f\t\t\t# minimum average brightness\n", thisillum.minbrt);
}


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


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