ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/rv2.c

Comparing ray/src/rt/rv2.c (file contents):
Revision 1.4 by greg, Tue May 30 09:57:13 1989 UTC vs.
Revision 2.52 by greg, Thu Jun 16 01:55:44 2005 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1987 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  rv2.c - command routines used in tracing a view.
6		*
7	<	*     3/24/87
7	>	*  External symbols declared in rpaint.h
8		*/
9
10	<	#include  "ray.h"
10	>	#include "copyright.h"
11
12	<	#include  "octree.h"
12	>	#include  <ctype.h>
13	>	#include  <string.h>
14
15	+	#include  "platform.h"
16	+	#include  "ray.h"
17	+	#include  "source.h"
18	+	#include  "ambient.h"
19		#include  "otypes.h"
18	–
20		#include  "rpaint.h"
21
22	<	#include  <ctype.h>
22	>	extern int  psample;                    /* pixel sample size */
23	>	extern double  maxdiff;                 /* max. sample difference */
24
25	<	#define  CTRL(c)        ('c'-'@')
25	>	#define  CTRL(c)        ((c)-'@')
26
27	+	#ifdef  SMLFLT
28	+	#define  sscanvec(s,v)  (sscanf(s,"%f %f %f",v,v+1,v+2)==3)
29	+	#else
30	+	#define  sscanvec(s,v)  (sscanf(s,"%lf %lf %lf",v,v+1,v+2)==3)
31	+	#endif
32	+
33	+	extern char  rifname[128];              /* rad input file name */
34	+
35		extern char  *progname;
36	+	extern char  *octname;
37
38
39	<	getframe(s)                             /* get a new frame */
40	<	char  *s;
39	>	extern void
40	>	getframe(                               /* get a new frame */
41	>	char  *s
42	>	)
43		{
44	<	int  x0, y0, x1, y1;
32	<
33	<	if (!strcmp("all", s)) {
34	<	pframe.l = pframe.d = 0;
35	<	pframe.r = ourview.hresolu;
36	<	pframe.u = ourview.vresolu;
37	<	pdepth = 0;
44	>	if (getrect(s, &pframe) < 0)
45		return;
39	–	}
40	–	if (sscanf(s, "%d %d %d %d", &x0, &y0, &x1, &y1) != 4) {
41	–	if (dev->getcur == NULL)
42	–	return;
43	–	(*dev->comout)("Pick first corner\n");
44	–	if ((*dev->getcur)(&x0, &y0) == ABORT)
45	–	return;
46	–	(*dev->comout)("Pick second corner\n");
47	–	if ((*dev->getcur)(&x1, &y1) == ABORT)
48	–	return;
49	–	}
50	–	if (x0 < x1) {
51	–	pframe.l = x0;
52	–	pframe.r = x1;
53	–	} else {
54	–	pframe.l = x1;
55	–	pframe.r = x0;
56	–	}
57	–	if (y0 < y1) {
58	–	pframe.d = y0;
59	–	pframe.u = y1;
60	–	} else {
61	–	pframe.d = y1;
62	–	pframe.u = y0;
63	–	}
64	–	if (pframe.l < 0) pframe.l = 0;
65	–	if (pframe.d < 0) pframe.d = 0;
66	–	if (pframe.r > ourview.hresolu) pframe.r = ourview.hresolu;
67	–	if (pframe.u > ourview.vresolu) pframe.u = ourview.vresolu;
46		pdepth = 0;
47		}
48
49
50	<	getview(s)                              /* get/show view parameters */
51	<	char  *s;
50	>	extern void
51	>	getrepaint(                             /* get area and repaint */
52	>	char  *s
53	>	)
54		{
55	+	RECT  box;
56	+
57	+	if (getrect(s, &box) < 0)
58	+	return;
59	+	paintrect(&ptrunk, 0, 0, hresolu, vresolu, &box);
60	+	}
61	+
62	+
63	+	extern void
64	+	getview(                                /* get/show view parameters */
65	+	char  *s
66	+	)
67	+	{
68		FILE  *fp;
69		char  buf[128];
70	<	char  *fname, *getpath();
70	>	char  *fname;
71		int  change = 0;
72	<	VIEW  nv;
72	>	VIEW  nv = ourview;
73
74	+	while (isspace(*s))
75	+	s++;
76	+	if (*s == '-') {                        /* command line parameters */
77	+	if (sscanview(&nv, s))
78	+	newview(&nv);
79	+	else
80	+	error(COMMAND, "bad view option(s)");
81	+	return;
82	+	}
83		if (sscanf(s, "%s", buf) == 1) {        /* write parameters to a file */
84	<	if ((fname = getpath(buf, NULL)) == NULL ||
84	>	if ((fname = getpath(buf, NULL, 0)) == NULL ||
85		(fp = fopen(fname, "a")) == NULL) {
86		sprintf(errmsg, "cannot open \"%s\"", buf);
87		error(COMMAND, errmsg);
#	Line 87 | Line 89 | char  *s;
89		}
90		fputs(progname, fp);
91		fprintview(&ourview, fp);
92	<	fputs("\n", fp);
92	>	fputs(sskip(s), fp);
93	>	putc('\n', fp);
94		fclose(fp);
95		return;
96		}
97		sprintf(buf, "view type (%c): ", ourview.type);
98		(*dev->comout)(buf);
99	<	(*dev->comin)(buf);
100	<	if (buf[0] == CTRL(C)) return;
99	>	(*dev->comin)(buf, NULL);
100	>	if (buf[0] == CTRL('C')) return;
101		if (buf[0] && buf[0] != ourview.type) {
102		nv.type = buf[0];
103		change++;
104	<	} else
102	<	nv.type = ourview.type;
104	>	}
105		sprintf(buf, "view point (%.6g %.6g %.6g): ",
106		ourview.vp[0], ourview.vp[1], ourview.vp[2]);
107		(*dev->comout)(buf);
108	<	(*dev->comin)(buf);
109	<	if (buf[0] == CTRL(C)) return;
110	<	if (sscanf(buf, "%lf %lf %lf", &nv.vp[0], &nv.vp[1], &nv.vp[2]) == 3)
108	>	(*dev->comin)(buf, NULL);
109	>	if (buf[0] == CTRL('C')) return;
110	>	if (sscanvec(buf, nv.vp))
111		change++;
110	–	else
111	–	VCOPY(nv.vp, ourview.vp);
112		sprintf(buf, "view direction (%.6g %.6g %.6g): ",
113	<	ourview.vdir[0], ourview.vdir[1], ourview.vdir[2]);
113	>	ourview.vdir[0]*ourview.vdist,
114	>	ourview.vdir[1]*ourview.vdist,
115	>	ourview.vdir[2]*ourview.vdist);
116		(*dev->comout)(buf);
117	<	(*dev->comin)(buf);
118	<	if (buf[0] == CTRL(C)) return;
119	<	if (sscanf(buf,"%lf %lf %lf",&nv.vdir[0],&nv.vdir[1],&nv.vdir[2]) == 3)
117	>	(*dev->comin)(buf, NULL);
118	>	if (buf[0] == CTRL('C')) return;
119	>	if (sscanvec(buf, nv.vdir)) {
120	>	nv.vdist = 1.;
121		change++;
122	<	else
120	<	VCOPY(nv.vdir, ourview.vdir);
122	>	}
123		sprintf(buf, "view up (%.6g %.6g %.6g): ",
124		ourview.vup[0], ourview.vup[1], ourview.vup[2]);
125		(*dev->comout)(buf);
126	<	(*dev->comin)(buf);
127	<	if (buf[0] == CTRL(C)) return;
128	<	if (sscanf(buf,"%lf %lf %lf",&nv.vup[0],&nv.vup[1],&nv.vup[2]) == 3)
126	>	(*dev->comin)(buf, NULL);
127	>	if (buf[0] == CTRL('C')) return;
128	>	if (sscanvec(buf, nv.vup))
129		change++;
128	–	else
129	–	VCOPY(nv.vup, ourview.vup);
130		sprintf(buf, "view horiz and vert size (%.6g %.6g): ",
131		ourview.horiz, ourview.vert);
132		(*dev->comout)(buf);
133	<	(*dev->comin)(buf);
134	<	if (buf[0] == CTRL(C)) return;
133	>	(*dev->comin)(buf, NULL);
134	>	if (buf[0] == CTRL('C')) return;
135		if (sscanf(buf, "%lf %lf", &nv.horiz, &nv.vert) == 2)
136		change++;
137	<	else {
138	<	nv.horiz = ourview.horiz; nv.vert = ourview.vert;
139	<	}
140	<	sprintf(buf, "x and y resolution (%d %d): ",
141	<	ourview.hresolu, ourview.vresolu);
137	>	sprintf(buf, "fore and aft clipping plane (%.6g %.6g): ",
138	>	ourview.vfore, ourview.vaft);
139		(*dev->comout)(buf);
140	<	(*dev->comin)(buf);
141	<	if (buf[0] == CTRL(C)) return;
142	<	if (sscanf(buf, "%d %d", &nv.hresolu, &nv.vresolu) == 2)
140	>	(*dev->comin)(buf, NULL);
141	>	if (buf[0] == CTRL('C')) return;
142	>	if (sscanf(buf, "%lf %lf", &nv.vfore, &nv.vaft) == 2)
143		change++;
144	<	else {
145	<	nv.hresolu = ourview.hresolu; nv.vresolu = ourview.vresolu;
146	<	}
144	>	sprintf(buf, "view shift and lift (%.6g %.6g): ",
145	>	ourview.hoff, ourview.voff);
146	>	(*dev->comout)(buf);
147	>	(*dev->comin)(buf, NULL);
148	>	if (buf[0] == CTRL('C')) return;
149	>	if (sscanf(buf, "%lf %lf", &nv.hoff, &nv.voff) == 2)
150	>	change++;
151		if (change)
152		newview(&nv);
153		}
154
155
156	<	lastview(s)                             /* return to a previous view */
157	<	char  *s;
156	>	extern void
157	>	lastview(                               /* return to a previous view */
158	>	char  *s
159	>	)
160		{
161		char  buf[128];
162	<	char  *fname, *getpath();
162	>	char  *fname;
163		int  success;
164		VIEW  nv;
165
166		if (sscanf(s, "%s", buf) == 1) {        /* get parameters from a file */
167	<	bcopy(&stdview, &nv, sizeof(VIEW));
168	<	if ((fname = getpath(buf, NULL)) == NULL ||
169	<	(success = viewfile(fname, &nv)) == -1) {
167	>	nv = stdview;
168	>	if ((fname = getpath(buf, "", R_OK)) == NULL ||
169	>	(success = viewfile(fname, &nv, NULL)) == -1) {
170		sprintf(errmsg, "cannot open \"%s\"", buf);
171		error(COMMAND, errmsg);
172		return;
#	Line 174 | Line 177 | char  *s;
177		newview(&nv);
178		return;
179		}
180	<	if (oldview.hresolu == 0) {     /* no old view! */
180	>	if (oldview.type == 0) {        /* no old view! */
181		error(COMMAND, "no previous view");
182		return;
183		}
184	<	bcopy(&ourview, &nv, sizeof(VIEW));
185	<	bcopy(&oldview, &ourview, sizeof(VIEW));
186	<	bcopy(&nv, &oldview, sizeof(VIEW));
184	>	nv = ourview;
185	>	ourview = oldview;
186	>	oldview = nv;
187		newimage();
188		}
189
190
191	<	getinterest(s, direc, vec, mp)          /* get area of interest */
192	<	char  *s;
193	<	int  direc;
194	<	FVECT  vec;
192	<	double  *mp;
191	>	extern void
192	>	saveview(                               /* save view to rad file */
193	>	char  *s
194	>	)
195		{
196	<	int  x, y;
197	<	RAY  thisray;
198	<	register int  i;
196	>	char  view[64];
197	>	char  *fname;
198	>	FILE  *fp;
199
200	<	if (sscanf(s, "%lf", mp) != 1)
201	<	*mp = 1.0;
202	<	else if (*mp < -FTINY)          /* negative zoom is reduction */
203	<	*mp = -1.0 / *mp;
202	<	else if (*mp <= FTINY) {        /* too small */
203	<	error(COMMAND, "illegal magnification");
204	<	return(-1);
205	<	}
206	<	if (sscanf(s, "%*lf %lf %lf %lf", &vec[0], &vec[1], &vec[2]) != 3) {
207	<	if (dev->getcur == NULL)
208	<	return(-1);
209	<	(*dev->comout)("Pick view center\n");
210	<	if ((*dev->getcur)(&x, &y) == ABORT)
211	<	return(-1);
212	<	rayview(thisray.rorg, thisray.rdir, &ourview, x+.5, y+.5);
213	<	if (!direc || ourview.type == VT_PAR) {
214	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
215	<	if (!localhit(&thisray, &thescene)) {
216	<	error(COMMAND, "not a local object");
217	<	return(-1);
218	<	}
200	>	if (*atos(view, sizeof(view), s)) {
201	>	if (isint(view)) {
202	>	error(COMMAND, "cannot write view by number");
203	>	return;
204		}
205	<	if (direc)
206	<	if (ourview.type == VT_PAR)
207	<	for (i = 0; i < 3; i++)
208	<	vec[i] = thisray.rop[i] - ourview.vp[i];
209	<	else
210	<	VCOPY(vec, thisray.rdir);
211	<	else
212	<	VCOPY(vec, thisray.rop);
213	<	} else if (direc)
214	<	for (i = 0; i < 3; i++)
215	<	vec[i] -= ourview.vp[i];
216	<	return(0);
205	>	s = sskip(s);
206	>	}
207	>	while (isspace(*s))
208	>	s++;
209	>	if (*s)
210	>	atos(rifname, sizeof(rifname), s);
211	>	else if (rifname[0] == '\0') {
212	>	error(COMMAND, "no previous rad file");
213	>	return;
214	>	}
215	>	if ((fname = getpath(rifname, NULL, 0)) == NULL ||
216	>	(fp = fopen(fname, "a")) == NULL) {
217	>	sprintf(errmsg, "cannot open \"%s\"", rifname);
218	>	error(COMMAND, errmsg);
219	>	return;
220	>	}
221	>	fputs("view= ", fp);
222	>	fputs(view, fp);
223	>	fprintview(&ourview, fp);
224	>	putc('\n', fp);
225	>	fclose(fp);
226		}
227
228
229	<	getaim(s)                               /* aim camera */
230	<	char  *s;
229	>	extern void
230	>	loadview(                               /* load view from rad file */
231	>	char  *s
232	>	)
233		{
234	<	extern double  tan(), atan();
235	<	double  zfact;
234	>	char  buf[512];
235	>	char  *fname;
236	>	FILE  *fp;
237		VIEW  nv;
238
239	<	if (getinterest(s, 1, nv.vdir, &zfact) < 0)
239	>	strcpy(buf, "rad -n -s -V -v ");
240	>	if (sscanf(s, "%s", buf+strlen(buf)) == 1)
241	>	s = sskip(s);
242	>	else
243	>	strcat(buf, "1");
244	>	if (*s)
245	>	atos(rifname, sizeof(rifname), s);
246	>	else if (rifname[0] == '\0') {
247	>	error(COMMAND, "no previous rad file");
248		return;
244	–	VCOPY(nv.vp, ourview.vp);
245	–	VCOPY(nv.vup, ourview.vup);
246	–	nv.hresolu = ourview.hresolu; nv.vresolu = ourview.vresolu;
247	–	if ((nv.type = ourview.type) == VT_PAR) {
248	–	nv.horiz = ourview.horiz / zfact;
249	–	nv.vert = ourview.vert / zfact;
250	–	} else {
251	–	nv.horiz = atan(tan(ourview.horiz*(PI/180./2.))/zfact) /
252	–	(PI/180./2.);
253	–	nv.vert = atan(tan(ourview.vert*(PI/180./2.))/zfact) /
254	–	(PI/180./2.);
249		}
250	+	if ((fname = getpath(rifname, "", R_OK)) == NULL) {
251	+	sprintf(errmsg, "cannot access \"%s\"", rifname);
252	+	error(COMMAND, errmsg);
253	+	return;
254	+	}
255	+	sprintf(buf+strlen(buf), " %s", fname);
256	+	if ((fp = popen(buf, "r")) == NULL) {
257	+	error(COMMAND, "cannot run rad");
258	+	return;
259	+	}
260	+	buf[0] = '\0';
261	+	fgets(buf, sizeof(buf), fp);
262	+	pclose(fp);
263	+	nv = stdview;
264	+	if (!sscanview(&nv, buf)) {
265	+	error(COMMAND, "rad error -- no such view?");
266	+	return;
267	+	}
268		newview(&nv);
269		}
270
271
272	<	getmove(s)                              /* move camera */
273	<	char  *s;
272	>	extern void
273	>	getaim(                         /* aim camera */
274	>	char  *s
275	>	)
276		{
277	+	VIEW  nv = ourview;
278	+	double  zfact;
279	+
280	+	if (getinterest(s, 1, nv.vdir, &zfact) < 0)
281	+	return;
282	+	zoomview(&nv, zfact);
283	+	newview(&nv);
284	+	}
285	+
286	+
287	+	extern void
288	+	getfocus(                               /* set focus distance */
289	+	char *s
290	+	)
291	+	{
292		FVECT  vc;
293	+	double  dist;
294	+
295	+	if (sscanf(s, "%lf", &dist) < 1) {
296	+	int     x, y;
297	+	RAY     thisray;
298	+	if (dev->getcur == NULL)
299	+	return;
300	+	(*dev->comout)("Pick focus point\n");
301	+	if ((*dev->getcur)(&x, &y) == ABORT)
302	+	return;
303	+	if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
304	+	&ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
305	+	error(COMMAND, "not on image");
306	+	return;
307	+	}
308	+	rayorigin(&thisray, PRIMARY, NULL, NULL);
309	+	if (!localhit(&thisray, &thescene)) {
310	+	error(COMMAND, "not a local object");
311	+	return;
312	+	}
313	+	dist = thisray.rot;
314	+	} else if (dist <= .0) {
315	+	error(COMMAND, "focus distance must be positive");
316	+	return;
317	+	}
318	+	ourview.vdist = dist;
319	+	}
320	+
321	+
322	+	extern void
323	+	getmove(                                /* move camera */
324	+	char  *s
325	+	)
326	+	{
327	+	FVECT  vc;
328		double  mag;
329
330		if (getinterest(s, 0, vc, &mag) < 0)
#	Line 269 | Line 333 | char  *s;
333		}
334
335
336	<	getrotate(s)                            /* rotate camera */
337	<	char  *s;
336	>	extern void
337	>	getrotate(                              /* rotate camera */
338	>	char  *s
339	>	)
340		{
341	<	extern double  normalize(), tan(), atan();
276	<	VIEW  nv;
341	>	VIEW  nv = ourview;
342		FVECT  v1;
343		double  angle, elev, zfact;
344
#	Line 282 | Line 347 | char  *s;
347		error(COMMAND, "missing angle");
348		return;
349		}
285	–	VCOPY(nv.vp, ourview.vp);
286	–	VCOPY(nv.vup, ourview.vup);
287	–	nv.hresolu = ourview.hresolu; nv.vresolu = ourview.vresolu;
350		spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
351		if (elev != 0.0) {
352		fcross(v1, nv.vdir, ourview.vup);
353		normalize(v1);
354		spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
355		}
356	<	if ((nv.type = ourview.type) == VT_PAR) {
295	<	nv.horiz = ourview.horiz / zfact;
296	<	nv.vert = ourview.vert / zfact;
297	<	} else {
298	<	nv.horiz = atan(tan(ourview.horiz*(PI/180./2.))/zfact) /
299	<	(PI/180./2.);
300	<	nv.vert = atan(tan(ourview.vert*(PI/180./2.))/zfact) /
301	<	(PI/180./2.);
302	<	}
356	>	zoomview(&nv, zfact);
357		newview(&nv);
358		}
359
360
361	<	getpivot(s)                             /* pivot viewpoint */
362	<	register char  *s;
361	>	extern void
362	>	getpivot(                               /* pivot viewpoint */
363	>	register char  *s
364	>	)
365		{
366		FVECT  vc;
367		double  angle, elev, mag;
#	Line 315 | Line 371 | register char  *s;
371		error(COMMAND, "missing angle");
372		return;
373		}
374	<	if (getinterest(sskip(sskip(s)), 0, vc, &mag) < 0)
374	>	if (getinterest(sskip2(s,2), 0, vc, &mag) < 0)
375		return;
376		moveview(angle, elev, mag, vc);
377		}
378
379
380	<	getexposure(s)                          /* get new exposure */
381	<	char  *s;
380	>	extern void
381	>	getexposure(                            /* get new exposure */
382	>	char  *s
383	>	)
384		{
327	–	double  atof(), pow(), fabs();
385		char  buf[128];
386		register char  *cp;
330	–	register PNODE  *p;
387		RECT  r;
388		int  x, y;
389	<	double  e;
389	>	register PNODE  *p = &ptrunk;
390	>	int  adapt = 0;
391	>	double  e = 1.0;
392
393		for (cp = s; isspace(*cp); cp++)
394		;
395	+	if (*cp == '@') {
396	+	adapt++;
397	+	while (isspace(*++cp))
398	+	;
399	+	}
400		if (*cp == '\0') {              /* normalize to point */
401		if (dev->getcur == NULL)
402		return;
#	Line 341 | Line 404 | char  *s;
404		if ((*dev->getcur)(&x, &y) == ABORT)
405		return;
406		r.l = r.d = 0;
407	<	r.r = ourview.hresolu; r.u = ourview.vresolu;
407	>	r.r = hresolu; r.u = vresolu;
408		p = findrect(x, y, &ptrunk, &r, -1);
346	–	e = 1.0;
409		} else {
410		if (*cp == '=') {       /* absolute setting */
411		p = NULL;
#	Line 351 | Line 413 | char  *s;
413		for (cp++; isspace(*cp); cp++)
414		;
415		if (*cp == '\0') {      /* interactive */
416	<	sprintf(buf, "exposure (%lf): ", exposure);
416	>	sprintf(buf, "exposure (%f): ", exposure);
417		(*dev->comout)(buf);
418	<	(*dev->comin)(buf);
418	>	(*dev->comin)(buf, NULL);
419		for (cp = buf; isspace(*cp); cp++)
420		;
421		if (*cp == '\0')
422		return;
423		}
362	–	} else {                /* normalize to average */
363	–	p = &ptrunk;
364	–	e = 1.0;
424		}
425		if (*cp == '+' || *cp == '-')   /* f-stops */
426		e *= pow(2.0, atof(cp));
#	Line 369 | Line 428 | char  *s;
428		e *= atof(cp);
429		}
430		if (p != NULL) {                /* relative setting */
431	<	if (intens(p->v) <= FTINY) {
431	>	if (bright(p->v) < 1e-15) {
432		error(COMMAND, "cannot normalize to zero");
433		return;
434		}
435	<	e *= 0.5 / intens(p->v);
435	>	if (adapt)
436	>	e *= 106./pow(1.219+pow(luminance(p->v)/exposure,.4),2.5)/exposure;
437	>	else
438	>	e *= 0.5 / bright(p->v);
439		}
440		if (e <= FTINY || fabs(1.0 - e) <= FTINY)
441		return;
#	Line 382 | Line 444 | char  *s;
444		redraw();
445		}
446
447	+	typedef union {int i; double d; COLOR C;}       *MyUptr;
448
449	<	setparam(s)                             /* get/set program parameter */
450	<	register char  *s;
449	>	extern int
450	>	getparam(               /* get variable from user */
451	>	char  *str,
452	>	char  *dsc,
453	>	int  typ,
454	>	void  *p
455	>	)
456		{
457	<	extern int  psample;
390	<	extern double  maxdiff;
391	<	extern double  minweight;
392	<	extern int  maxdepth;
393	<	extern double  dstrsrc;
394	<	extern COLOR  ambval;
395	<	extern double  ambacc;
396	<	extern double  minarad;
397	<	extern int  ambres;
398	<	extern int  ambdiv;
399	<	extern int  ambssamp;
400	<	extern int  ambounce;
457	>	register MyUptr  ptr = (MyUptr)p;
458		int  i0;
459		double  d0, d1, d2;
460	+	char  buf[48];
461	+
462	+	switch (typ) {
463	+	case 'i':                       /* integer */
464	+	if (sscanf(str, "%d", &i0) != 1) {
465	+	(*dev->comout)(dsc);
466	+	sprintf(buf, " (%d): ", ptr->i);
467	+	(*dev->comout)(buf);
468	+	(*dev->comin)(buf, NULL);
469	+	if (sscanf(buf, "%d", &i0) != 1)
470	+	return(0);
471	+	}
472	+	ptr->i = i0;
473	+	return(1);
474	+	case 'r':                       /* real */
475	+	if (sscanf(str, "%lf", &d0) != 1) {
476	+	(*dev->comout)(dsc);
477	+	sprintf(buf, " (%.6g): ", ptr->d);
478	+	(*dev->comout)(buf);
479	+	(*dev->comin)(buf, NULL);
480	+	if (sscanf(buf, "%lf", &d0) != 1)
481	+	return(0);
482	+	}
483	+	ptr->d = d0;
484	+	return(1);
485	+	case 'b':                       /* boolean */
486	+	if (sscanf(str, "%1s", buf) != 1) {
487	+	(*dev->comout)(dsc);
488	+	sprintf(buf, "? (%c): ", ptr->i ? 'y' : 'n');
489	+	(*dev->comout)(buf);
490	+	(*dev->comin)(buf, NULL);
491	+	if (buf[0] == '\0' ||
492	+	strchr("yY+1tTnN-0fF", buf[0]) == NULL)
493	+	return(0);
494	+	}
495	+	ptr->i = strchr("yY+1tT", buf[0]) != NULL;
496	+	return(1);
497	+	case 'C':                       /* color */
498	+	if (sscanf(str, "%lf %lf %lf", &d0, &d1, &d2) != 3) {
499	+	(*dev->comout)(dsc);
500	+	sprintf(buf, " (%.6g %.6g %.6g): ",
501	+	colval(ptr->C,RED),
502	+	colval(ptr->C,GRN),
503	+	colval(ptr->C,BLU));
504	+	(*dev->comout)(buf);
505	+	(*dev->comin)(buf, NULL);
506	+	if (sscanf(buf, "%lf %lf %lf", &d0, &d1, &d2) != 3)
507	+	return(0);
508	+	}
509	+	setcolor(ptr->C, d0, d1, d2);
510	+	return(1);
511	+	}
512	+	return 0; /* nothing matched */
513	+	}
514	+
515	+
516	+	extern void
517	+	setparam(                               /* get/set program parameter */
518	+	register char  *s
519	+	)
520	+	{
521		char  buf[128];
522
523		if (s[0] == '\0') {
524	<	(*dev->comout)("aa ab ad ar as av ds lr lw sd sp: ");
525	<	(*dev->comin)(buf);
524	>	(*dev->comout)(
525	>	"aa ab ad ar as av aw b bv dc dv dj ds dt i lr lw me ma mg ms ps pt sj st u: ");
526	>	(*dev->comin)(buf, NULL);
527		s = buf;
528		}
529		switch (s[0]) {
530	+	case 'u':                       /* uncorrelated sampling */
531	+	getparam(s+1, "uncorrelated sampling", 'b',
532	+	(void *)&rand_samp);
533	+	break;
534		case 'l':                       /* limit */
535		switch (s[1]) {
536		case 'w':                       /* weight */
537	<	if (sscanf(s+2, "%lf", &d0) != 1) {
538	<	sprintf(buf, "limit weight (%.6g): ",
416	<	minweight);
417	<	(*dev->comout)(buf);
418	<	(*dev->comin)(buf);
419	<	if (sscanf(buf, "%lf", &d0) != 1)
420	<	break;
421	<	}
422	<	minweight = d0;
537	>	getparam(s+2, "limit weight", 'r',
538	>	(void *)&minweight);
539		break;
540		case 'r':                       /* reflection */
541	<	if (sscanf(s+2, "%d", &i0) != 1) {
542	<	sprintf(buf, "limit reflection (%d): ",
427	<	maxdepth);
428	<	(*dev->comout)(buf);
429	<	(*dev->comin)(buf);
430	<	if (sscanf(buf, "%d", &i0) != 1)
431	<	break;
432	<	}
433	<	maxdepth = i0;
541	>	getparam(s+2, "limit reflection", 'i',
542	>	(void *)&maxdepth);
543		break;
544		default:
545		goto badparam;
546		}
547		break;
548	<	case 'd':                       /* distribute source */
549	<	if (s[1] != 's')
548	>	case 'd':                       /* direct */
549	>	switch (s[1]) {
550	>	case 'j':                       /* jitter */
551	>	getparam(s+2, "direct jitter", 'r',
552	>	(void *)&dstrsrc);
553	>	break;
554	>	case 'c':                       /* certainty */
555	>	getparam(s+2, "direct certainty", 'r',
556	>	(void *)&shadcert);
557	>	break;
558	>	case 't':                       /* threshold */
559	>	getparam(s+2, "direct threshold", 'r',
560	>	(void *)&shadthresh);
561	>	break;
562	>	case 'v':                       /* visibility */
563	>	getparam(s+2, "direct visibility", 'b',
564	>	(void *)&directvis);
565	>	break;
566	>	case 's':                       /* sampling */
567	>	getparam(s+2, "direct sampling", 'r',
568	>	(void *)&srcsizerat);
569	>	break;
570	>	default:
571		goto badparam;
442	–	if (sscanf(s+2, "%lf", &d0) != 1) {
443	–	sprintf(buf, "distribute source (%.6g): ", dstrsrc);
444	–	(*dev->comout)(buf);
445	–	(*dev->comin)(buf);
446	–	if (sscanf(buf, "%lf", &d0) != 1)
447	–	break;
572		}
449	–	dstrsrc = d0;
573		break;
574	+	case 'b':                       /* back faces or black and white */
575	+	switch (s[1]) {
576	+	case 'v':                       /* back face visibility */
577	+	getparam(s+2, "back face visibility", 'b',
578	+	(void *)&backvis);
579	+	break;
580	+	case '\0':                      /* black and white */
581	+	case ' ':
582	+	case 'y': case 'Y': case 't': case 'T': case '1': case '+':
583	+	case 'n': case 'N': case 'f': case 'F': case '0': case '-':
584	+	getparam(s+1, "black and white", 'b',
585	+	(void *)&greyscale);
586	+	break;
587	+	default:
588	+	goto badparam;
589	+	}
590	+	break;
591	+	case 'i':                       /* irradiance */
592	+	getparam(s+1, "irradiance", 'b',
593	+	(void *)&do_irrad);
594	+	break;
595		case 'a':                       /* ambient */
596		switch (s[1]) {
597		case 'v':                       /* value */
598	<	if (sscanf(s+2, "%lf %lf %lf", &d0, &d1, &d2) != 3) {
599	<	sprintf(buf,
456	<	"ambient value (%.6g %.6g %.6g): ",
457	<	colval(ambval,RED),
458	<	colval(ambval,GRN),
459	<	colval(ambval,BLU));
460	<	(*dev->comout)(buf);
461	<	(*dev->comin)(buf);
462	<	if (sscanf(buf, "%lf %lf %lf",
463	<	&d0, &d1, &d2) != 3)
464	<	break;
465	<	}
466	<	setcolor(ambval, d0, d1, d2);
598	>	getparam(s+2, "ambient value", 'C',
599	>	(void *)ambval);
600		break;
601	+	case 'w':                       /* weight */
602	+	getparam(s+2, "ambient value weight", 'i',
603	+	(void *)&ambvwt);
604	+	break;
605		case 'a':                       /* accuracy */
606	<	if (sscanf(s+2, "%lf", &d0) != 1) {
607	<	sprintf(buf, "ambient accuracy (%.6g): ",
608	<	ambacc);
472	<	(*dev->comout)(buf);
473	<	(*dev->comin)(buf);
474	<	if (sscanf(buf, "%lf", &d0) != 1)
475	<	break;
476	<	}
477	<	ambacc = d0;
606	>	if (getparam(s+2, "ambient accuracy", 'r',
607	>	(void *)&ambacc))
608	>	setambacc(ambacc);
609		break;
610		case 'd':                       /* divisions */
611	<	if (sscanf(s+2, "%d", &i0) != 1) {
612	<	sprintf(buf, "ambient divisions (%d): ",
482	<	ambdiv);
483	<	(*dev->comout)(buf);
484	<	(*dev->comin)(buf);
485	<	if (sscanf(buf, "%d", &i0) != 1)
486	<	break;
487	<	}
488	<	ambdiv = i0;
611	>	getparam(s+2, "ambient divisions", 'i',
612	>	(void *)&ambdiv);
613		break;
614		case 's':                       /* samples */
615	<	if (sscanf(s+2, "%d", &i0) != 1) {
616	<	sprintf(buf, "ambient super-samples (%d): ",
493	<	ambssamp);
494	<	(*dev->comout)(buf);
495	<	(*dev->comin)(buf);
496	<	if (sscanf(buf, "%d", &i0) != 1)
497	<	break;
498	<	}
499	<	ambssamp = i0;
615	>	getparam(s+2, "ambient super-samples", 'i',
616	>	(void *)&ambssamp);
617		break;
618		case 'b':                       /* bounces */
619	<	if (sscanf(s+2, "%d", &i0) != 1) {
620	<	sprintf(buf, "ambient bounces (%d): ",
504	<	ambounce);
505	<	(*dev->comout)(buf);
506	<	(*dev->comin)(buf);
507	<	if (sscanf(buf, "%d", &i0) != 1)
508	<	break;
509	<	}
510	<	ambounce = i0;
619	>	getparam(s+2, "ambient bounces", 'i',
620	>	(void *)&ambounce);
621		break;
622		case 'r':
623	<	if (sscanf(s+2, "%d", &i0) != 1) {
624	<	sprintf(buf, "ambient resolution (%d): ",
625	<	ambres);
516	<	(*dev->comout)(buf);
517	<	(*dev->comin)(buf);
518	<	if (sscanf(buf, "%d", &i0) != 1)
519	<	break;
520	<	}
521	<	ambres = i0;
522	<	minarad = ambres > 0 ? thescene.cusize/ambres : 0.0;
623	>	if (getparam(s+2, "ambient resolution", 'i',
624	>	(void *)&ambres))
625	>	setambres(ambres);
626		break;
627		default:
628		goto badparam;
629		}
630		break;
631	<	case 's':                       /* sample */
631	>	case 'm':                       /* medium */
632		switch (s[1]) {
633	<	case 'p':                       /* pixel */
634	<	if (sscanf(s+2, "%d", &i0) != 1) {
635	<	sprintf(buf, "sample pixel (%d): ", psample);
533	<	(*dev->comout)(buf);
534	<	(*dev->comin)(buf);
535	<	if (sscanf(buf, "%d", &i0) != 1)
536	<	break;
537	<	}
538	<	psample = i0;
539	<	pdepth = 0;
633	>	case 'e':                       /* extinction coefficient */
634	>	getparam(s+2, "extinction coefficient", 'C',
635	>	(void *)cextinction);
636		break;
637	<	case 'd':                       /* difference */
638	<	if (sscanf(s+2, "%lf", &d0) != 1) {
639	<	sprintf(buf, "sample difference (%.6g): ",
544	<	maxdiff);
545	<	(*dev->comout)(buf);
546	<	(*dev->comin)(buf);
547	<	if (sscanf(buf, "%lf", &d0) != 1)
548	<	break;
549	<	}
550	<	maxdiff = d0;
551	<	pdepth = 0;
637	>	case 'a':                       /* scattering albedo */
638	>	getparam(s+2, "scattering albedo", 'C',
639	>	(void *)salbedo);
640		break;
641	+	case 'g':                       /* scattering eccentricity */
642	+	getparam(s+2, "scattering eccentricity", 'r',
643	+	(void *)&seccg);
644	+	break;
645	+	case 's':                       /* sampling distance */
646	+	getparam(s+2, "mist sampling distance", 'r',
647	+	(void *)&ssampdist);
648	+	break;
649		default:
650		goto badparam;
651		}
652		break;
653	+	case 'p':                       /* pixel */
654	+	switch (s[1]) {
655	+	case 's':                       /* sample */
656	+	if (getparam(s+2, "pixel sample", 'i',
657	+	(void *)&psample))
658	+	pdepth = 0;
659	+	break;
660	+	case 't':                       /* threshold */
661	+	if (getparam(s+2, "pixel threshold", 'r',
662	+	(void *)&maxdiff))
663	+	pdepth = 0;
664	+	break;
665	+	default:
666	+	goto badparam;
667	+	}
668	+	break;
669	+	case 's':                       /* specular */
670	+	switch (s[1]) {
671	+	case 'j':                       /* jitter */
672	+	getparam(s+2, "specular jitter", 'r',
673	+	(void *)&specjitter);
674	+	break;
675	+	case 't':                       /* threshold */
676	+	getparam(s+2, "specular threshold", 'r',
677	+	(void *)&specthresh);
678	+	break;
679	+	default:
680	+	goto badparam;
681	+	}
682	+	break;
683		case '\0':                      /* nothing */
684		break;
685		default:;
686		badparam:
687	+	*sskip(s) = '\0';
688		sprintf(errmsg, "%s: unknown variable", s);
689		error(COMMAND, errmsg);
690		break;
#	Line 565 | Line 692 | badparam:
692		}
693
694
695	+	extern void
696		traceray(s)                             /* trace a single ray */
697		char  *s;
698		{
699		char  buf[128];
700		int  x, y;
701	+	OBJREC  *ino;
702		RAY  thisray;
703
704	<	if (sscanf(s, "%lf %lf %lf %lf %lf %lf",
576	<	&thisray.rorg[0], &thisray.rorg[1], &thisray.rorg[2],
577	<	&thisray.rdir[0], &thisray.rdir[1], &thisray.rdir[2]) != 6) {
704	>	thisray.rmax = 0.0;
705
706	+	if (!sscanvec(s, thisray.rorg) ||
707	+	!sscanvec(sskip2(s,3), thisray.rdir)) {
708	+
709		if (dev->getcur == NULL)
710		return;
711		(*dev->comout)("Pick ray\n");
712		if ((*dev->getcur)(&x, &y) == ABORT)
713		return;
714
715	<	rayview(thisray.rorg, thisray.rdir, &ourview, x+.5, y+.5);
716	<
715	>	if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
716	>	&ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
717	>	error(COMMAND, "not on image");
718	>	return;
719	>	}
720	>
721		} else if (normalize(thisray.rdir) == 0.0) {
722		error(COMMAND, "zero ray direction");
723		return;
724		}
725
726	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
726	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
727
728		rayvalue(&thisray);
729
730		if (thisray.ro == NULL)
731		(*dev->comout)("ray hit nothing");
732		else {
733	<	sprintf(buf, "ray hit %s %s \"%s\"",
734	<	objptr(thisray.ro->omod)->oname,
733	>	OBJREC  *mat = NULL;
734	>	OBJREC  *mod = NULL;
735	>	char    matspec[256];
736	>	matspec[0] = '\0';
737	>	if (thisray.ro->omod != OVOID) {
738	>	mod = objptr(thisray.ro->omod);
739	>	mat = findmaterial(mod);
740	>	}
741	>	if (thisray.rod < 0.0)
742	>	strcpy(matspec, "back of ");
743	>	if (mod != NULL) {
744	>	strcat(matspec, mod->oname);
745	>	if (mat != mod && mat != NULL)
746	>	sprintf(matspec+strlen(matspec),
747	>	" (%s)", mat->oname);
748	>	} else
749	>	strcat(matspec, VOIDID);
750	>	sprintf(buf, "ray hit %s %s \"%s\"", matspec,
751		ofun[thisray.ro->otype].funame,
752		thisray.ro->oname);
753	+	if ((ino = objptr(thisray.robj)) != thisray.ro)
754	+	sprintf(buf+strlen(buf), " in %s \"%s\"",
755	+	ofun[ino->otype].funame, ino->oname);
756		(*dev->comout)(buf);
757	<	(*dev->comin)(buf);
757	>	(*dev->comin)(buf, NULL);
758		if (thisray.rot >= FHUGE)
759		(*dev->comout)("at infinity");
760		else {
761	<	sprintf(buf, "at (%.6g %.6g %.6g)", thisray.rop[0],
762	<	thisray.rop[1], thisray.rop[2]);
761	>	sprintf(buf, "at (%.6g %.6g %.6g) (%.6g)",
762	>	thisray.rop[0], thisray.rop[1],
763	>	thisray.rop[2], thisray.rt);
764		(*dev->comout)(buf);
765		}
766	<	(*dev->comin)(buf);
767	<	sprintf(buf, "with value (%.6g %.6g %.6g)",
766	>	(*dev->comin)(buf, NULL);
767	>	sprintf(buf, "value (%.5g %.5g %.5g) (%.3gL)",
768		colval(thisray.rcol,RED),
769		colval(thisray.rcol,GRN),
770	<	colval(thisray.rcol,BLU));
770	>	colval(thisray.rcol,BLU),
771	>	luminance(thisray.rcol));
772		(*dev->comout)(buf);
773		}
774	<	(*dev->comin)(buf);
774	>	(*dev->comin)(buf, NULL);
775		}
776
777
778	+	extern void
779		writepict(s)                            /* write the picture to a file */
780		char  *s;
781		{
782		static char  buf[128];
783	<	char  *fname, *getpath();
783	>	char  *fname;
784		FILE  *fp;
785		COLR  *scanline;
786		int  y;
787
788	<	if (sscanf(s, "%s", buf) != 1 && buf[0] == '\0') {
788	>	while (isspace(*s))
789	>	s++;
790	>	if (*s)
791	>	atos(buf, sizeof(buf), s);
792	>	else if (buf[0] == '\0') {
793		error(COMMAND, "no file");
794		return;
795		}
796	<	if ((fname = getpath(buf, NULL)) == NULL ||
796	>	if ((fname = getpath(buf, NULL, 0)) == NULL ||
797		(fp = fopen(fname, "w")) == NULL) {
798		sprintf(errmsg, "cannot open \"%s\"", buf);
799		error(COMMAND, errmsg);
800		return;
801		}
802	+	SET_FILE_BINARY(fp);
803		(*dev->comout)("writing \"");
804		(*dev->comout)(fname);
805		(*dev->comout)("\"...\n");
806		/* write header */
807	+	newheader("RADIANCE", fp);
808		fputs(progname, fp);
809		fprintview(&ourview, fp);
810	<	fputs("\n", fp);
810	>	if (octname != NULL)
811	>	fprintf(fp, " %s\n", octname);
812	>	else
813	>	putc('\n', fp);
814	>	fprintf(fp, "SOFTWARE= %s\n", VersionID);
815	>	fputnow(fp);
816		if (exposure != 1.0)
817	<	fprintf(fp, "EXPOSURE=%e\n", exposure);
818	<	fprintf(fp, "\n-Y %d +X %d\n", ourview.vresolu, ourview.hresolu);
817	>	fputexpos(exposure, fp);
818	>	if (dev->pixaspect != 1.0)
819	>	fputaspect(dev->pixaspect, fp);
820	>	fputformat(COLRFMT, fp);
821	>	putc('\n', fp);
822	>	fprtresolu(hresolu, vresolu, fp);
823
824	<	scanline = (COLR *)malloc(ourview.hresolu*sizeof(COLR));
825	<	if (scanline == NULL)
826	<	error(SYSTEM, "out of memory in writepict");
827	<	for (y = ourview.vresolu-1; y >= 0; y--) {
828	<	getpictcolrs(y, scanline, &ptrunk,
829	<	ourview.hresolu, ourview.vresolu);
830	<	if (fwritecolrs(scanline, ourview.hresolu, fp) < 0)
824	>	scanline = (COLR *)malloc(hresolu*sizeof(COLR));
825	>	if (scanline == NULL) {
826	>	error(COMMAND, "not enough memory!");
827	>	fclose(fp);
828	>	unlink(fname);
829	>	return;
830	>	}
831	>	for (y = vresolu-1; y >= 0; y--) {
832	>	getpictcolrs(y, scanline, &ptrunk, hresolu, vresolu);
833	>	if (fwritecolrs(scanline, hresolu, fp) < 0)
834		break;
835		}
836	+	free((void *)scanline);
837		if (fclose(fp) < 0)
838		error(COMMAND, "write error");
664	–	free((char *)scanline);
839		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)