[ViewVC] Diff of: radiance/ray/src/rt/rv2.c

Comparing ray/src/rt/rv2.c (file contents):
Revision 2.13 by greg, Thu Nov 19 20:27:03 1992 UTC vs.
Revision 2.55 by greg, Thu Aug 21 07:05:59 2008 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1992 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 "resolu.h"
22	>	extern int psample; /* pixel sample size */
23	>	extern double maxdiff; /* max. sample difference */
24
23	–	#include <ctype.h>
24	–
25		#define CTRL(c) ((c)-'@')
26
27		#ifdef SMLFLT
#	Line 30 \| Line 30 \| static char SCCSid[] = "$SunId$ LBL";
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
34	–	extern char VersionID[];
35		extern char *progname;
36		extern char *octname;
37
38
39	<	getframe(s) /* get a new frame */
40	<	char *s;
39	>	void
40	>	getframe( /* get a new frame */
41	>	char *s
42	>	)
43		{
44		if (getrect(s, &pframe) < 0)
45		return;
#	Line 45 \| Line 47 \| *char s;**
47		}
48
49
50	<	getrepaint(s) /* get area and repaint */
51	<	char *s;
50	>	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);
59	>	paintrect(&ptrunk, &box);
60		}
61
62
63	<	getview(s) /* get/show view parameters */
64	<	char *s;
63	>	void
64	>	getview( /* get/show view parameters */
65	>	char *s
66	>	)
67		{
68		FILE *fp;
69		char buf[128];
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 */
71	–	copystruct(&nv, &ourview);
77		if (sscanview(&nv, s))
78		newview(&nv);
79		else
#	Line 85 \| Line 90 \| *char s;**
90		fputs(progname, fp);
91		fprintview(&ourview, fp);
92		fputs(sskip(s), fp);
93	<	fputs("\n", fp);
93	>	putc('\n', fp);
94		fclose(fp);
95		return;
96		}
#	Line 96 \| Line 101 \| *char s;**
101		if (buf[0] && buf[0] != ourview.type) {
102		nv.type = buf[0];
103		change++;
104	<	} else
100	<	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);
#	Line 105 \| Line 109 \| *char s;**
109		if (buf[0] == CTRL('C')) return;
110		if (sscanvec(buf, nv.vp))
111		change++;
108	–	else
109	–	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, NULL);
118		if (buf[0] == CTRL('C')) return;
119	<	if (sscanvec(buf, nv.vdir))
119	>	if (sscanvec(buf, nv.vdir)) {
120	>	nv.vdist = 1.;
121		change++;
122	<	else
118	<	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);
#	Line 123 \| Line 127 \| *char s;**
127		if (buf[0] == CTRL('C')) return;
128		if (sscanvec(buf, nv.vup))
129		change++;
126	–	else
127	–	VCOPY(nv.vup, ourview.vup);
130		sprintf(buf, "view horiz and vert size (%.6g %.6g): ",
131		ourview.horiz, ourview.vert);
132		(*dev->comout)(buf);
#	Line 132 \| Line 134 \| *char s;**
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	<	}
137	>	sprintf(buf, "fore and aft clipping plane (%.6g %.6g): ",
138	>	ourview.vfore, ourview.vaft);
139	>	(*dev->comout)(buf);
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		sprintf(buf, "view shift and lift (%.6g %.6g): ",
145		ourview.hoff, ourview.voff);
146		(*dev->comout)(buf);
#	Line 142 \| Line 148 \| *char s;**
148		if (buf[0] == CTRL('C')) return;
149		if (sscanf(buf, "%lf %lf", &nv.hoff, &nv.voff) == 2)
150		change++;
145	–	else {
146	–	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
147	–	}
151		if (change)
152		newview(&nv);
153		}
154
155
156	<	lastview(s) /* return to a previous view */
157	<	char *s;
156	>	void
157	>	lastview( /* return to a previous view */
158	>	char *s
159	>	)
160		{
161		char buf[128];
162		char *fname;
#	Line 159 \| Line 164 \| *char s;**
164		VIEW nv;
165
166		if (sscanf(s, "%s", buf) == 1) { /* get parameters from a file */
167	<	copystruct(&nv, &stdview);
168	<	if ((fname = getpath(buf, NULL, 0)) == NULL \|\|
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);
#	Line 176 \| Line 181 \| *char s;**
181		error(COMMAND, "no previous view");
182		return;
183		}
184	<	copystruct(&nv, &ourview);
185	<	copystruct(&ourview, &oldview);
186	<	copystruct(&oldview, &nv);
187	<	newimage();
184	>	nv = ourview;
185	>	ourview = oldview;
186	>	oldview = nv;
187	>	newimage(NULL);
188		}
189
190
191	<	getaim(s) /* aim camera */
192	<	char *s;
191	>	void
192	>	saveview( /* save view to rad file */
193	>	char *s
194	>	)
195		{
196	<	double zfact;
196	>	char view[64];
197	>	char *fname;
198	>	FILE *fp;
199	>
200	>	if (*atos(view, sizeof(view), s)) {
201	>	if (isint(view)) {
202	>	error(COMMAND, "cannot write view by number");
203	>	return;
204	>	}
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	>	void
230	>	loadview( /* load view from rad file */
231	>	char *s
232	>	)
233	>	{
234	>	char buf[512];
235	>	char *fname;
236	>	FILE *fp;
237		VIEW nv;
238
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;
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	+	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;
194	–	nv.type = ourview.type;
195	–	VCOPY(nv.vp, ourview.vp);
196	–	VCOPY(nv.vup, ourview.vup);
197	–	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
198	–	nv.horiz = ourview.horiz; nv.vert = ourview.vert;
282		zoomview(&nv, zfact);
283		newview(&nv);
284		}
285
286
287	<	getmove(s) /* move camera */
288	<	char *s;
287	>	void
288	>	getfocus( /* set focus distance */
289	>	char *s
290	>	)
291		{
292	+	char buf[64];
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	+	sprintf(buf, "Focus distance set to %f\n", dist);
320	+	(*dev->comout)(buf);
321	+	}
322	+
323	+
324	+	void
325	+	getmove( /* move camera */
326	+	char *s
327	+	)
328	+	{
329		FVECT vc;
330		double mag;
331
#	Line 213 \| Line 335 \| *char s;**
335		}
336
337
338	<	getrotate(s) /* rotate camera */
339	<	char *s;
338	>	void
339	>	getrotate( /* rotate camera */
340	>	char *s
341	>	)
342		{
343	<	VIEW nv;
343	>	VIEW nv = ourview;
344		FVECT v1;
345		double angle, elev, zfact;
346
#	Line 225 \| Line 349 \| *char s;**
349		error(COMMAND, "missing angle");
350		return;
351		}
228	–	nv.type = ourview.type;
229	–	VCOPY(nv.vp, ourview.vp);
230	–	VCOPY(nv.vup, ourview.vup);
231	–	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
352		spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
353		if (elev != 0.0) {
354		fcross(v1, nv.vdir, ourview.vup);
355		normalize(v1);
356		spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
357		}
238	–	nv.horiz = ourview.horiz; nv.vert = ourview.vert;
358		zoomview(&nv, zfact);
359		newview(&nv);
360		}
361
362
363	<	getpivot(s) /* pivot viewpoint */
364	<	register char *s;
363	>	void
364	>	getpivot( /* pivot viewpoint */
365	>	char *s
366	>	)
367		{
368		FVECT vc;
369		double angle, elev, mag;
#	Line 252 \| Line 373 \| *register char s;**
373		error(COMMAND, "missing angle");
374		return;
375		}
376	<	if (getinterest(sskip(sskip(s)), 0, vc, &mag) < 0)
376	>	if (getinterest(sskip2(s,2), 0, vc, &mag) < 0)
377		return;
378		moveview(angle, elev, mag, vc);
379		}
380
381
382	<	getexposure(s) /* get new exposure */
383	<	char *s;
382	>	void
383	>	getexposure( /* get new exposure */
384	>	char *s
385	>	)
386		{
387		char buf[128];
388	<	register char *cp;
266	<	register PNODE *p;
267	<	RECT r;
388	>	char *cp;
389		int x, y;
390	<	double e;
390	>	PNODE *p = &ptrunk;
391	>	int adapt = 0;
392	>	double e = 1.0;
393
394		for (cp = s; isspace(*cp); cp++)
395		;
396	+	if (*cp == '@') {
397	+	adapt++;
398	+	while (isspace(*++cp))
399	+	;
400	+	}
401		if (cp == '\0') { / normalize to point */
402		if (dev->getcur == NULL)
403		return;
404		(*dev->comout)("Pick point for exposure\n");
405		if ((*dev->getcur)(&x, &y) == ABORT)
406		return;
407	<	r.l = r.d = 0;
280	<	r.r = hresolu; r.u = vresolu;
281	<	p = findrect(x, y, &ptrunk, &r, -1);
282	<	e = 1.0;
407	>	p = findrect(x, y, &ptrunk, -1);
408		} else {
409		if (cp == '=') { / absolute setting */
410		p = NULL;
#	Line 287 \| Line 412 \| *char s;**
412		for (cp++; isspace(*cp); cp++)
413		;
414		if (cp == '\0') { / interactive */
415	<	sprintf(buf, "exposure (%lf): ", exposure);
415	>	sprintf(buf, "exposure (%f): ", exposure);
416		(*dev->comout)(buf);
417		(*dev->comin)(buf, NULL);
418		for (cp = buf; isspace(*cp); cp++)
#	Line 295 \| Line 420 \| *char s;**
420		if (*cp == '\0')
421		return;
422		}
298	–	} else { /* normalize to average */
299	–	p = &ptrunk;
300	–	e = 1.0;
423		}
424		if (cp == '+' \|\| cp == '-') /* f-stops */
425		e *= pow(2.0, atof(cp));
#	Line 305 \| Line 427 \| *char s;**
427		e *= atof(cp);
428		}
429		if (p != NULL) { /* relative setting */
430	<	if (bright(p->v) < 1e-25) {
430	>	if (bright(p->v) < 1e-15) {
431		error(COMMAND, "cannot normalize to zero");
432		return;
433		}
434	<	e *= 0.5 / bright(p->v);
434	>	if (adapt)
435	>	e *= 106./pow(1.219+pow(luminance(p->v)/exposure,.4),2.5)/exposure;
436	>	else
437	>	e *= 0.5 / bright(p->v);
438		}
439		if (e <= FTINY \|\| fabs(1.0 - e) <= FTINY)
440		return;
#	Line 318 \| Line 443 \| *char s;**
443		redraw();
444		}
445
446	+	typedef union {int i; double d; COLOR C;} *MyUptr;
447
448	<	getparam(str, dsc, typ, ptr) /* get variable from user */
449	<	char str, dsc;
450	<	int typ;
451	<	register union {int i; double d; COLOR C;} *ptr;
448	>	int
449	>	getparam( /* get variable from user */
450	>	char *str,
451	>	char *dsc,
452	>	int typ,
453	>	void *p
454	>	)
455		{
456	<	extern char *index();
456	>	MyUptr ptr = (MyUptr)p;
457		int i0;
458		double d0, d1, d2;
459		char buf[48];
#	Line 340 \| Line 469 \| *register union {int i; double d; COLOR C;} ptr;**
469		return(0);
470		}
471		ptr->i = i0;
472	<	return(1);
472	>	break;
473		case 'r': /* real */
474		if (sscanf(str, "%lf", &d0) != 1) {
475		(*dev->comout)(dsc);
#	Line 351 \| Line 480 \| *register union {int i; double d; COLOR C;} ptr;**
480		return(0);
481		}
482		ptr->d = d0;
483	<	return(1);
483	>	break;
484		case 'b': /* boolean */
485		if (sscanf(str, "%1s", buf) != 1) {
486		(*dev->comout)(dsc);
#	Line 359 \| Line 488 \| *register union {int i; double d; COLOR C;} ptr;**
488		(*dev->comout)(buf);
489		(*dev->comin)(buf, NULL);
490		if (buf[0] == '\0' \|\|
491	<	index("yY+1tTnN-0fF", buf[0]) == NULL)
491	>	strchr("yY+1tTnN-0fF", buf[0]) == NULL)
492		return(0);
493		}
494	<	ptr->i = index("yY+1tT", buf[0]) != NULL;
495	<	return(1);
494	>	ptr->i = strchr("yY+1tT", buf[0]) != NULL;
495	>	break;
496		case 'C': /* color */
497		if (sscanf(str, "%lf %lf %lf", &d0, &d1, &d2) != 3) {
498		(*dev->comout)(dsc);
#	Line 377 \| Line 506 \| *register union {int i; double d; COLOR C;} ptr;**
506		return(0);
507		}
508		setcolor(ptr->C, d0, d1, d2);
509	<	return(1);
509	>	break;
510	>	default:
511	>	return(0); /* shouldn't happen */
512		}
513	+	newparam++;
514	+	return(1);
515		}
516
517
518	<	setparam(s) /* get/set program parameter */
519	<	register char *s;
518	>	void
519	>	setparam( /* get/set program parameter */
520	>	char *s
521	>	)
522		{
388	–	extern int psample;
389	–	extern double maxdiff;
390	–	extern double minweight;
391	–	extern int maxdepth;
392	–	extern double dstrsrc;
393	–	extern double shadthresh;
394	–	extern double shadcert;
395	–	extern COLOR ambval;
396	–	extern double ambacc;
397	–	extern int ambres;
398	–	extern int ambdiv;
399	–	extern int ambssamp;
400	–	extern int ambounce;
401	–	extern int directvis;
402	–	extern double srcsizerat;
403	–	extern int do_irrad;
404	–	extern double specjitter;
405	–	extern double specthresh;
523		char buf[128];
524
525		if (s[0] == '\0') {
526		(*dev->comout)(
527	<	"aa ab ad ar as av b dc di dj ds dt i lr lw ps pt sj st: ");
527	>	"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: ");
528		(*dev->comin)(buf, NULL);
529		s = buf;
530		}
531		switch (s[0]) {
532	+	case 'u': /* uncorrelated sampling */
533	+	getparam(s+1, "uncorrelated sampling", 'b',
534	+	(void *)&rand_samp);
535	+	break;
536		case 'l': /* limit */
537		switch (s[1]) {
538		case 'w': /* weight */
539	<	getparam(s+2, "limit weight", 'r', &minweight);
539	>	getparam(s+2, "limit weight", 'r',
540	>	(void *)&minweight);
541		break;
542		case 'r': /* reflection */
543	<	getparam(s+2, "limit reflection", 'i', &maxdepth);
543	>	getparam(s+2, "limit reflection", 'i',
544	>	(void *)&maxdepth);
545		break;
546		default:
547		goto badparam;
#	Line 427 \| Line 550 \| *register char s;**
550		case 'd': /* direct */
551		switch (s[1]) {
552		case 'j': /* jitter */
553	<	getparam(s+2, "direct jitter", 'r', &dstrsrc);
553	>	getparam(s+2, "direct jitter", 'r',
554	>	(void *)&dstrsrc);
555		break;
556		case 'c': /* certainty */
557	<	getparam(s+2, "direct certainty", 'r', &shadcert);
557	>	getparam(s+2, "direct certainty", 'r',
558	>	(void *)&shadcert);
559		break;
560		case 't': /* threshold */
561	<	getparam(s+2, "direct threshold", 'r', &shadthresh);
561	>	getparam(s+2, "direct threshold", 'r',
562	>	(void *)&shadthresh);
563		break;
564		case 'v': /* visibility */
565	<	getparam(s+2, "direct visibility",
566	<	'b', &directvis);
565	>	getparam(s+2, "direct visibility", 'b',
566	>	(void *)&directvis);
567		break;
568		case 's': /* sampling */
569	<	getparam(s+2, "direct sampling", 'r', &srcsizerat);
569	>	getparam(s+2, "direct sampling", 'r',
570	>	(void *)&srcsizerat);
571		break;
572		default:
573		goto badparam;
574		}
575		break;
576	<	case 'b': /* black and white */
577	<	getparam(s+1, "black and white", 'b', &greyscale);
576	>	case 'b': /* back faces or black and white */
577	>	switch (s[1]) {
578	>	case 'v': /* back face visibility */
579	>	getparam(s+2, "back face visibility", 'b',
580	>	(void *)&backvis);
581	>	break;
582	>	case '\0': /* black and white */
583	>	case ' ':
584	>	case 'y': case 'Y': case 't': case 'T': case '1': case '+':
585	>	case 'n': case 'N': case 'f': case 'F': case '0': case '-':
586	>	getparam(s+1, "black and white", 'b',
587	>	(void *)&greyscale);
588	>	break;
589	>	default:
590	>	goto badparam;
591	>	}
592		break;
593		case 'i': /* irradiance */
594	<	getparam(s+1, "irradiance", 'b', &do_irrad);
594	>	getparam(s+1, "irradiance", 'b',
595	>	(void *)&do_irrad);
596		break;
597		case 'a': /* ambient */
598		switch (s[1]) {
599		case 'v': /* value */
600	<	getparam(s+2, "ambient value", 'C', (COLOR *)ambval);
600	>	getparam(s+2, "ambient value", 'C',
601	>	(void *)ambval);
602		break;
603	+	case 'w': /* weight */
604	+	getparam(s+2, "ambient value weight", 'i',
605	+	(void *)&ambvwt);
606	+	break;
607		case 'a': /* accuracy */
608	<	getparam(s+2, "ambient accuracy", 'r', &ambacc);
608	>	if (getparam(s+2, "ambient accuracy", 'r',
609	>	(void *)&ambacc))
610	>	setambacc(ambacc);
611		break;
612		case 'd': /* divisions */
613	<	getparam(s+2, "ambient divisions", 'i', &ambdiv);
613	>	getparam(s+2, "ambient divisions", 'i',
614	>	(void *)&ambdiv);
615		break;
616		case 's': /* samples */
617	<	getparam(s+2, "ambient super-samples", 'i', &ambssamp);
617	>	getparam(s+2, "ambient super-samples", 'i',
618	>	(void *)&ambssamp);
619		break;
620		case 'b': /* bounces */
621	<	getparam(s+2, "ambient bounces", 'i', &ambounce);
621	>	getparam(s+2, "ambient bounces", 'i',
622	>	(void *)&ambounce);
623		break;
624		case 'r':
625	<	if (getparam(s+2, "ambient resolution", 'i', &ambres))
625	>	if (getparam(s+2, "ambient resolution", 'i',
626	>	(void *)&ambres))
627		setambres(ambres);
628		break;
629		default:
630		goto badparam;
631		}
632		break;
633	+	case 'm': /* medium */
634	+	switch (s[1]) {
635	+	case 'e': /* extinction coefficient */
636	+	getparam(s+2, "extinction coefficient", 'C',
637	+	(void *)cextinction);
638	+	break;
639	+	case 'a': /* scattering albedo */
640	+	getparam(s+2, "scattering albedo", 'C',
641	+	(void *)salbedo);
642	+	break;
643	+	case 'g': /* scattering eccentricity */
644	+	getparam(s+2, "scattering eccentricity", 'r',
645	+	(void *)&seccg);
646	+	break;
647	+	case 's': /* sampling distance */
648	+	getparam(s+2, "mist sampling distance", 'r',
649	+	(void *)&ssampdist);
650	+	break;
651	+	default:
652	+	goto badparam;
653	+	}
654	+	break;
655		case 'p': /* pixel */
656		switch (s[1]) {
657		case 's': /* sample */
658	<	if (getparam(s+2, "pixel sample", 'i', &psample))
658	>	if (getparam(s+2, "pixel sample", 'i',
659	>	(void *)&psample))
660		pdepth = 0;
661		break;
662		case 't': /* threshold */
663	<	if (getparam(s+2, "pixel threshold", 'r', &maxdiff))
663	>	if (getparam(s+2, "pixel threshold", 'r',
664	>	(void *)&maxdiff))
665		pdepth = 0;
666		break;
667		default:
#	Line 494 \| Line 671 \| *register char s;**
671		case 's': /* specular */
672		switch (s[1]) {
673		case 'j': /* jitter */
674	<	getparam(s+2, "specular jitter", 'r', &specjitter);
674	>	getparam(s+2, "specular jitter", 'r',
675	>	(void *)&specjitter);
676		break;
677		case 't': /* threshold */
678	<	getparam(s+2, "specular threshold", 'r', &specthresh);
678	>	getparam(s+2, "specular threshold", 'r',
679	>	(void *)&specthresh);
680		break;
681		default:
682		goto badparam;
#	Line 515 \| Line 694 \| badparam:
694		}
695
696
697	<	traceray(s) /* trace a single ray */
698	<	char *s;
697	>	void
698	>	traceray( /* trace a single ray */
699	>	char *s
700	>	)
701		{
702		char buf[128];
703		int x, y;
704	+	OBJREC *ino;
705		RAY thisray;
706
707	+	thisray.rmax = 0.0;
708	+
709		if (!sscanvec(s, thisray.rorg) \|\|
710	<	!sscanvec(sskip(sskip(sskip(s))), thisray.rdir)) {
710	>	!sscanvec(sskip2(s,3), thisray.rdir)) {
711
712		if (dev->getcur == NULL)
713		return;
#	Line 531 \| Line 715 \| *char s;**
715		if ((*dev->getcur)(&x, &y) == ABORT)
716		return;
717
718	<	if (viewray(thisray.rorg, thisray.rdir, &ourview,
719	<	(x+.5)/hresolu, (y+.5)/vresolu) < 0) {
718	>	if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
719	>	&ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
720		error(COMMAND, "not on image");
721		return;
722		}
#	Line 542 \| Line 726 \| *char s;**
726		return;
727		}
728
729	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
729	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
730
731		rayvalue(&thisray);
732
733		if (thisray.ro == NULL)
734		(*dev->comout)("ray hit nothing");
735		else {
736	<	sprintf(buf, "ray hit %s %s \"%s\"",
737	<	objptr(thisray.ro->omod)->oname,
736	>	OBJREC *mat = NULL;
737	>	OBJREC *mod = NULL;
738	>	char matspec[256];
739	>	matspec[0] = '\0';
740	>	if (thisray.ro->omod != OVOID) {
741	>	mod = objptr(thisray.ro->omod);
742	>	mat = findmaterial(mod);
743	>	}
744	>	if (thisray.rod < 0.0)
745	>	strcpy(matspec, "back of ");
746	>	if (mod != NULL) {
747	>	strcat(matspec, mod->oname);
748	>	if (mat != mod && mat != NULL)
749	>	sprintf(matspec+strlen(matspec),
750	>	" (%s)", mat->oname);
751	>	} else
752	>	strcat(matspec, VOIDID);
753	>	sprintf(buf, "ray hit %s %s \"%s\"", matspec,
754		ofun[thisray.ro->otype].funame,
755		thisray.ro->oname);
756	+	if ((ino = objptr(thisray.robj)) != thisray.ro)
757	+	sprintf(buf+strlen(buf), " in %s \"%s\"",
758	+	ofun[ino->otype].funame, ino->oname);
759		(*dev->comout)(buf);
760		(*dev->comin)(buf, NULL);
761		if (thisray.rot >= FHUGE)
762		(*dev->comout)("at infinity");
763		else {
764	<	sprintf(buf, "at (%.6g %.6g %.6g)", thisray.rop[0],
765	<	thisray.rop[1], thisray.rop[2]);
764	>	sprintf(buf, "at (%.6g %.6g %.6g) (%.6g)",
765	>	thisray.rop[0], thisray.rop[1],
766	>	thisray.rop[2], thisray.rt);
767		(*dev->comout)(buf);
768		}
769		(*dev->comin)(buf, NULL);
770	<	sprintf(buf, "value (%.5g %.5g %.5g) (%.1fL)",
770	>	sprintf(buf, "value (%.5g %.5g %.5g) (%.3gL)",
771		colval(thisray.rcol,RED),
772		colval(thisray.rcol,GRN),
773		colval(thisray.rcol,BLU),
#	Line 574 \| Line 778 \| *char s;**
778		}
779
780
781	<	writepict(s) /* write the picture to a file */
782	<	char *s;
781	>	void
782	>	writepict( /* write the picture to a file */
783	>	char *s
784	>	)
785		{
786		static char buf[128];
787		char *fname;
#	Line 583 \| Line 789 \| *char s;**
789		COLR *scanline;
790		int y;
791
792	<	if (sscanf(s, "%s", buf) != 1 && buf[0] == '\0') {
792	>	while (isspace(*s))
793	>	s++;
794	>	if (*s)
795	>	atos(buf, sizeof(buf), s);
796	>	else if (buf[0] == '\0') {
797		error(COMMAND, "no file");
798		return;
799		}
#	Line 593 \| Line 803 \| *char s;**
803		error(COMMAND, errmsg);
804		return;
805		}
806	<	#ifdef MSDOS
597	<	setmode(fileno(fp), O_BINARY);
598	<	#endif
806	>	SET_FILE_BINARY(fp);
807		(*dev->comout)("writing \"");
808		(*dev->comout)(fname);
809		(*dev->comout)("\"...\n");
810		/* write header */
811	+	newheader("RADIANCE", fp);
812		fputs(progname, fp);
813		fprintview(&ourview, fp);
814		if (octname != NULL)
#	Line 607 \| Line 816 \| *char s;**
816		else
817		putc('\n', fp);
818		fprintf(fp, "SOFTWARE= %s\n", VersionID);
819	+	fputnow(fp);
820		if (exposure != 1.0)
821		fputexpos(exposure, fp);
822		if (dev->pixaspect != 1.0)
#	Line 627 \| Line 837 \| *char s;**
837		if (fwritecolrs(scanline, hresolu, fp) < 0)
838		break;
839		}
840	<	free((char *)scanline);
840	>	free((void *)scanline);
841		if (fclose(fp) < 0)
842		error(COMMAND, "write error");
843		}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ray/src/rt/rv2.c (file contents): Revision 2.13 by greg, Thu Nov 19 20:27:03 1992 UTC vs. Revision 2.55 by greg, Thu Aug 21 07:05:59 2008 UTC

Diff Legend

Comparing ray/src/rt/rv2.c (file contents):
Revision 2.13 by greg, Thu Nov 19 20:27:03 1992 UTC vs.
Revision 2.55 by greg, Thu Aug 21 07:05:59 2008 UTC