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

Comparing ray/src/rt/rv2.c (file contents):
Revision 2.21 by greg, Thu Sep 9 14:57:53 1993 UTC vs.
Revision 2.74 by greg, Wed Nov 15 18:02:53 2023 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1993 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 "rtprocess.h" /* win_popen() */
17	+	#include "paths.h"
18	+	#include "ray.h"
19	+	#include "ambient.h"
20		#include "otypes.h"
21	<
21	>	#include "otspecial.h"
22		#include "rpaint.h"
23
24	<	#include "resolu.h"
24	>	extern int psample; /* pixel sample size */
25	>	extern double maxdiff; /* max. sample difference */
26
23	–	#include <ctype.h>
24	–
27		#define CTRL(c) ((c)-'@')
28
29	<	#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
29	>	#define sscanvec(s,v) (sscanf(s,FVFORMAT,v,v+1,v+2)==3)
30
33	–	extern char *atos();
34	–
35	–	extern FILE *popen();
36	–
31		extern char rifname[128]; /* rad input file name */
32
39	–	extern char VersionID[];
33		extern char *progname;
34		extern char *octname;
35
36
37	<	getframe(s) /* get a new frame */
38	<	char *s;
37	>	void
38	>	getframe( /* get a new frame */
39	>	char *s
40	>	)
41		{
42		if (getrect(s, &pframe) < 0)
43		return;
#	Line 50 \| Line 45 \| *char s;**
45		}
46
47
48	<	getrepaint(s) /* get area and repaint */
49	<	char *s;
48	>	void
49	>	getrepaint( /* get area and repaint */
50	>	char *s
51	>	)
52		{
53		RECT box;
54
55		if (getrect(s, &box) < 0)
56		return;
57	<	paintrect(&ptrunk, 0, 0, hresolu, vresolu, &box);
57	>	paintrect(&ptrunk, &box);
58		}
59
60
61	<	getview(s) /* get/show view parameters */
62	<	char *s;
61	>	void
62	>	getview( /* get/show/save view parameters */
63	>	char *s
64	>	)
65		{
66		FILE *fp;
67		char buf[128];
68		char *fname;
69		int change = 0;
70	<	VIEW nv;
70	>	VIEW nv = ourview;
71
72		while (isspace(*s))
73		s++;
74		if (s == '-') { / command line parameters */
76	–	copystruct(&nv, &ourview);
75		if (sscanview(&nv, s))
76		newview(&nv);
77		else
78		error(COMMAND, "bad view option(s)");
79		return;
80		}
81	<	if (sscanf(s, "%s", buf) == 1) { /* write parameters to a file */
81	>	if (nextword(buf, sizeof(buf), s) != NULL) { /* write to a file */
82		if ((fname = getpath(buf, NULL, 0)) == NULL \|\|
83		(fp = fopen(fname, "a")) == NULL) {
84		sprintf(errmsg, "cannot open \"%s\"", buf);
#	Line 101 \| Line 99 \| *char s;**
99		if (buf[0] && buf[0] != ourview.type) {
100		nv.type = buf[0];
101		change++;
102	<	} else
105	<	nv.type = ourview.type;
102	>	}
103		sprintf(buf, "view point (%.6g %.6g %.6g): ",
104		ourview.vp[0], ourview.vp[1], ourview.vp[2]);
105		(*dev->comout)(buf);
#	Line 110 \| Line 107 \| *char s;**
107		if (buf[0] == CTRL('C')) return;
108		if (sscanvec(buf, nv.vp))
109		change++;
113	–	else
114	–	VCOPY(nv.vp, ourview.vp);
110		sprintf(buf, "view direction (%.6g %.6g %.6g): ",
111	<	ourview.vdir[0], ourview.vdir[1], ourview.vdir[2]);
111	>	ourview.vdir[0]*ourview.vdist,
112	>	ourview.vdir[1]*ourview.vdist,
113	>	ourview.vdir[2]*ourview.vdist);
114		(*dev->comout)(buf);
115		(*dev->comin)(buf, NULL);
116		if (buf[0] == CTRL('C')) return;
117	<	if (sscanvec(buf, nv.vdir))
117	>	if (sscanvec(buf, nv.vdir)) {
118	>	nv.vdist = 1.;
119		change++;
120	<	else
123	<	VCOPY(nv.vdir, ourview.vdir);
120	>	}
121		sprintf(buf, "view up (%.6g %.6g %.6g): ",
122		ourview.vup[0], ourview.vup[1], ourview.vup[2]);
123		(*dev->comout)(buf);
#	Line 128 \| Line 125 \| *char s;**
125		if (buf[0] == CTRL('C')) return;
126		if (sscanvec(buf, nv.vup))
127		change++;
131	–	else
132	–	VCOPY(nv.vup, ourview.vup);
128		sprintf(buf, "view horiz and vert size (%.6g %.6g): ",
129		ourview.horiz, ourview.vert);
130		(*dev->comout)(buf);
#	Line 137 \| Line 132 \| *char s;**
132		if (buf[0] == CTRL('C')) return;
133		if (sscanf(buf, "%lf %lf", &nv.horiz, &nv.vert) == 2)
134		change++;
135	<	else {
136	<	nv.horiz = ourview.horiz; nv.vert = ourview.vert;
137	<	}
135	>	sprintf(buf, "fore and aft clipping plane (%.6g %.6g): ",
136	>	ourview.vfore, ourview.vaft);
137	>	(*dev->comout)(buf);
138	>	(*dev->comin)(buf, NULL);
139	>	if (buf[0] == CTRL('C')) return;
140	>	if (sscanf(buf, "%lf %lf", &nv.vfore, &nv.vaft) == 2)
141	>	change++;
142		sprintf(buf, "view shift and lift (%.6g %.6g): ",
143		ourview.hoff, ourview.voff);
144		(*dev->comout)(buf);
#	Line 147 \| Line 146 \| *char s;**
146		if (buf[0] == CTRL('C')) return;
147		if (sscanf(buf, "%lf %lf", &nv.hoff, &nv.voff) == 2)
148		change++;
150	–	else {
151	–	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
152	–	}
149		if (change)
150		newview(&nv);
151		}
152
153
154	<	lastview(s) /* return to a previous view */
155	<	char *s;
154	>	void
155	>	lastview( /* return to a previous view */
156	>	char *s
157	>	)
158		{
159		char buf[128];
160		char *fname;
161		int success;
162		VIEW nv;
163	<
164	<	if (sscanf(s, "%s", buf) == 1) { /* get parameters from a file */
165	<	copystruct(&nv, &stdview);
163	>	/* get parameters from a file */
164	>	if (nextword(buf, sizeof(buf), s) != NULL) {
165	>	nv = stdview;
166		if ((fname = getpath(buf, "", R_OK)) == NULL \|\|
167		(success = viewfile(fname, &nv, NULL)) == -1) {
168		sprintf(errmsg, "cannot open \"%s\"", buf);
#	Line 181 \| Line 179 \| *char s;**
179		error(COMMAND, "no previous view");
180		return;
181		}
182	<	copystruct(&nv, &ourview);
183	<	copystruct(&ourview, &oldview);
184	<	copystruct(&oldview, &nv);
185	<	newimage();
182	>	nv = ourview;
183	>	ourview = oldview;
184	>	oldview = nv;
185	>	newimage(NULL);
186		}
187
188
189	<	saveview(s) /* save view to rad file */
190	<	char *s;
189	>	void
190	>	saveview( /* save view to rad file */
191	>	char *s
192	>	)
193		{
194		char view[64];
195		char *fname;
#	Line 202 \| Line 202 \| *char s;**
202		}
203		s = sskip(s);
204		}
205	<	while (isspace(*s))
206	<	s++;
207	<	if (*s)
208	<	atos(rifname, sizeof(rifname), s);
209	<	else if (rifname[0] == '\0') {
205	>	if (nextword(rifname, sizeof(rifname), s) == NULL && !rifname[0]) {
206		error(COMMAND, "no previous rad file");
207		return;
208		}
#	Line 224 \| Line 220 \| *char s;**
220		}
221
222
223	<	loadview(s) /* load view from rad file */
224	<	char *s;
223	>	void
224	>	loadview( /* load view from rad file */
225	>	char *s
226	>	)
227		{
228		char buf[512];
229		char *fname;
#	Line 237 \| Line 235 \| *char s;**
235		s = sskip(s);
236		else
237		strcat(buf, "1");
238	<	if (*s)
241	<	atos(rifname, sizeof(rifname), s);
242	<	else if (rifname[0] == '\0') {
238	>	if (nextword(rifname, sizeof(rifname), s) == NULL && !rifname[0]) {
239		error(COMMAND, "no previous rad file");
240		return;
241		}
#	Line 256 \| Line 252 \| *char s;**
252		buf[0] = '\0';
253		fgets(buf, sizeof(buf), fp);
254		pclose(fp);
255	<	copystruct(&nv, &stdview);
255	>	nv = stdview;
256		if (!sscanview(&nv, buf)) {
257		error(COMMAND, "rad error -- no such view?");
258		return;
#	Line 265 \| Line 261 \| *char s;**
261		}
262
263
264	<	getaim(s) /* aim camera */
265	<	char *s;
264	>	void
265	>	getaim( /* aim camera */
266	>	char *s
267	>	)
268		{
269	+	VIEW nv = ourview;
270		double zfact;
272	–	VIEW nv;
271
272		if (getinterest(s, 1, nv.vdir, &zfact) < 0)
273		return;
276	–	nv.type = ourview.type;
277	–	VCOPY(nv.vp, ourview.vp);
278	–	VCOPY(nv.vup, ourview.vup);
279	–	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
280	–	nv.horiz = ourview.horiz; nv.vert = ourview.vert;
274		zoomview(&nv, zfact);
275		newview(&nv);
276		}
277
278
279	<	getmove(s) /* move camera */
280	<	char *s;
279	>	void
280	>	getfocus( /* set focus distance */
281	>	char *s
282	>	)
283		{
284	+	char buf[64];
285	+	double dist;
286	+
287	+	if (sscanf(s, "%lf", &dist) < 1) {
288	+	int x, y;
289	+	RAY thisray;
290	+	if (dev->getcur == NULL)
291	+	return;
292	+	(*dev->comout)("Pick focus point\n");
293	+	if ((*dev->getcur)(&x, &y) == ABORT)
294	+	return;
295	+	if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
296	+	&ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
297	+	error(COMMAND, "not on image");
298	+	return;
299	+	}
300	+	rayorigin(&thisray, PRIMARY, NULL, NULL);
301	+	if (!localhit(&thisray, &thescene)) {
302	+	error(COMMAND, "not a local object");
303	+	return;
304	+	}
305	+	dist = thisray.rot;
306	+	} else if (dist <= .0) {
307	+	error(COMMAND, "focus distance must be positive");
308	+	return;
309	+	}
310	+	ourview.vdist = dist;
311	+	sprintf(buf, "Focus distance set to %f\n", dist);
312	+	(*dev->comout)(buf);
313	+	}
314	+
315	+
316	+	void
317	+	getmove( /* move camera */
318	+	char *s
319	+	)
320	+	{
321		FVECT vc;
322		double mag;
323
#	Line 295 \| Line 327 \| *char s;**
327		}
328
329
330	<	getrotate(s) /* rotate camera */
331	<	char *s;
330	>	void
331	>	getrotate( /* rotate camera */
332	>	char *s
333	>	)
334		{
335	<	VIEW nv;
302	<	FVECT v1;
335	>	VIEW nv = ourview;
336		double angle, elev, zfact;
337
338		elev = 0.0; zfact = 1.0;
#	Line 307 \| Line 340 \| *char s;**
340		error(COMMAND, "missing angle");
341		return;
342		}
310	–	nv.type = ourview.type;
311	–	VCOPY(nv.vp, ourview.vp);
312	–	VCOPY(nv.vup, ourview.vup);
313	–	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
343		spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
344	<	if (elev != 0.0) {
345	<	fcross(v1, nv.vdir, ourview.vup);
346	<	normalize(v1);
318	<	spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
319	<	}
320	<	nv.horiz = ourview.horiz; nv.vert = ourview.vert;
344	>	if (elev != 0.0)
345	>	geodesic(nv.vdir, nv.vdir, nv.vup, elev*(PI/180.), GEOD_RAD);
346	>
347		zoomview(&nv, zfact);
348		newview(&nv);
349		}
350
351
352	<	getpivot(s) /* pivot viewpoint */
353	<	register char *s;
352	>	void
353	>	getpivot( /* pivot viewpoint */
354	>	char *s
355	>	)
356		{
357		FVECT vc;
358		double angle, elev, mag;
#	Line 334 \| Line 362 \| *register char s;**
362		error(COMMAND, "missing angle");
363		return;
364		}
365	<	if (getinterest(sskip(sskip(s)), 0, vc, &mag) < 0)
365	>	if (getinterest(sskip2(s,2), 0, vc, &mag) < 0)
366		return;
367		moveview(angle, elev, mag, vc);
368		}
369
370
371	<	getexposure(s) /* get new exposure */
372	<	char *s;
371	>	void
372	>	getorigin( /* origin viewpoint */
373	>	char *s
374	>	)
375		{
376	+	VIEW nv = ourview;
377	+	double d;
378	+	/* get new view origin */
379	+	if (sscanf(s, "%lf %lf", &d, &d) == 1) {
380	+	/* just moving some distance */
381	+	VSUM(nv.vp, nv.vp, nv.vdir, d);
382	+	} else if (!sscanvec(s, nv.vp)) {
383	+	int x, y; /* need to pick origin */
384	+	RAY thisray;
385	+	if (dev->getcur == NULL)
386	+	return;
387	+	(*dev->comout)("Pick point on surface for new origin\n");
388	+	if ((*dev->getcur)(&x, &y) == ABORT)
389	+	return;
390	+	if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
391	+	&ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
392	+	error(COMMAND, "not on image");
393	+	return;
394	+	}
395	+	rayorigin(&thisray, PRIMARY, NULL, NULL);
396	+	if (!localhit(&thisray, &thescene)) {
397	+	error(COMMAND, "not a local object");
398	+	return;
399	+	}
400	+	if (thisray.rod < 0.0) /* don't look through other side */
401	+	flipsurface(&thisray);
402	+	VSUM(nv.vp, thisray.rop, thisray.ron, 20.0*FTINY);
403	+	VCOPY(nv.vdir, thisray.ron);
404	+	} else if (!sscanvec(sskip2(s,3), nv.vdir) \|\| normalize(nv.vdir) == 0.0)
405	+	VCOPY(nv.vdir, ourview.vdir);
406	+
407	+	d = DOT(nv.vdir, nv.vup); /* need different up vector? */
408	+	if (dd >= 1.-2.FTINY) {
409	+	int i;
410	+	nv.vup[0] = nv.vup[1] = nv.vup[2] = 0.0;
411	+	for (i = 3; i--; )
412	+	if (nv.vdir[i]*nv.vdir[i] < 0.34)
413	+	break;
414	+	nv.vup[i] = 1.;
415	+	}
416	+	newview(&nv);
417	+	}
418	+
419	+
420	+	void
421	+	getexposure( /* get new exposure */
422	+	char *s
423	+	)
424	+	{
425		char buf[128];
426	<	register char *cp;
348	<	RECT r;
426	>	char *cp;
427		int x, y;
428	<	register PNODE *p = &ptrunk;
428	>	PNODE *p = &ptrunk;
429		int adapt = 0;
430		double e = 1.0;
431	<	start:
431	>
432		for (cp = s; isspace(*cp); cp++)
433		;
434		if (*cp == '@') {
435		adapt++;
436	<	goto start;
436	>	while (isspace(*++cp))
437	>	;
438		}
439		if (cp == '\0') { / normalize to point */
440		if (dev->getcur == NULL)
#	Line 363 \| Line 442 \| start:
442		(*dev->comout)("Pick point for exposure\n");
443		if ((*dev->getcur)(&x, &y) == ABORT)
444		return;
445	<	r.l = r.d = 0;
367	<	r.r = hresolu; r.u = vresolu;
368	<	p = findrect(x, y, &ptrunk, &r, -1);
445	>	p = findrect(x, y, &ptrunk, -1);
446		} else {
447		if (cp == '=') { / absolute setting */
448		p = NULL;
#	Line 388 \| Line 465 \| start:
465		e *= atof(cp);
466		}
467		if (p != NULL) { /* relative setting */
468	+	compavg(p);
469		if (bright(p->v) < 1e-15) {
470		error(COMMAND, "cannot normalize to zero");
471		return;
#	Line 404 \| Line 482 \| start:
482		redraw();
483		}
484
485	+	typedef union {int i; double d; COLOR C;} *MyUptr;
486
487	<	getparam(str, dsc, typ, ptr) /* get variable from user */
488	<	char str, dsc;
489	<	int typ;
490	<	register union {int i; double d; COLOR C;} *ptr;
487	>	int
488	>	getparam( /* get variable from user */
489	>	char *str,
490	>	char *dsc,
491	>	int typ,
492	>	void *p
493	>	)
494		{
495	<	extern char *index();
495	>	MyUptr ptr = (MyUptr)p;
496		int i0;
497		double d0, d1, d2;
498		char buf[48];
#	Line 425 \| Line 507 \| *register union {int i; double d; COLOR C;} ptr;**
507		if (sscanf(buf, "%d", &i0) != 1)
508		return(0);
509		}
510	+	if (ptr->i == i0)
511	+	return(0);
512		ptr->i = i0;
513	<	return(1);
513	>	break;
514		case 'r': /* real */
515		if (sscanf(str, "%lf", &d0) != 1) {
516		(*dev->comout)(dsc);
#	Line 436 \| Line 520 \| *register union {int i; double d; COLOR C;} ptr;**
520		if (sscanf(buf, "%lf", &d0) != 1)
521		return(0);
522		}
523	+	if (FABSEQ(ptr->d, d0))
524	+	return(0);
525		ptr->d = d0;
526	<	return(1);
526	>	break;
527		case 'b': /* boolean */
528		if (sscanf(str, "%1s", buf) != 1) {
529		(*dev->comout)(dsc);
530		sprintf(buf, "? (%c): ", ptr->i ? 'y' : 'n');
531		(*dev->comout)(buf);
532		(*dev->comin)(buf, NULL);
533	<	if (buf[0] == '\0' \|\|
448	<	index("yY+1tTnN-0fF", buf[0]) == NULL)
533	>	if (buf[0] == '\0')
534		return(0);
535		}
536	<	ptr->i = index("yY+1tT", buf[0]) != NULL;
537	<	return(1);
536	>	if (strchr("yY+1tTnN-0fF", buf[0]) == NULL)
537	>	return(0);
538	>	i0 = strchr("yY+1tT", buf[0]) != NULL;
539	>	if (ptr->i == i0)
540	>	return(0);
541	>	ptr->i = i0;
542	>	break;
543		case 'C': /* color */
544		if (sscanf(str, "%lf %lf %lf", &d0, &d1, &d2) != 3) {
545		(*dev->comout)(dsc);
#	Line 462 \| Line 552 \| *register union {int i; double d; COLOR C;} ptr;**
552		if (sscanf(buf, "%lf %lf %lf", &d0, &d1, &d2) != 3)
553		return(0);
554		}
555	+	if (FABSEQ(colval(ptr->C,RED), d0) &&
556	+	FABSEQ(colval(ptr->C,GRN), d1) &&
557	+	FABSEQ(colval(ptr->C,BLU), d2))
558	+	return(0);
559		setcolor(ptr->C, d0, d1, d2);
560	<	return(1);
560	>	break;
561	>	default:
562	>	return(0); /* shouldn't happen */
563		}
564	+	newparam++;
565	+	return(1);
566		}
567
568
569	<	setparam(s) /* get/set program parameter */
570	<	register char *s;
569	>	void
570	>	setparam( /* get/set program parameter */
571	>	char *s
572	>	)
573		{
574	<	extern int psample;
475	<	extern double maxdiff;
476	<	extern double minweight;
477	<	extern int maxdepth;
478	<	extern double dstrsrc;
479	<	extern double shadthresh;
480	<	extern double shadcert;
481	<	extern COLOR ambval;
482	<	extern double ambacc;
483	<	extern int ambres;
484	<	extern int ambdiv;
485	<	extern int ambssamp;
486	<	extern int ambounce;
487	<	extern int directvis;
488	<	extern double srcsizerat;
489	<	extern int do_irrad;
490	<	extern double specjitter;
491	<	extern double specthresh;
574	>	int prev_newp = newparam;
575		char buf[128];
576
577		if (s[0] == '\0') {
578		(*dev->comout)(
579	<	"aa ab ad ar as av b dc di dj ds dt i lr lw ps pt sj st: ");
579	>	"aa ab ad ar as av aw b bv dc dv dj ds dt i lr lw me ma mg ms ps pt ss st u: ");
580		(*dev->comin)(buf, NULL);
581		s = buf;
582		}
583		switch (s[0]) {
584	+	case 'u': /* uncorrelated sampling */
585	+	getparam(s+1, "uncorrelated sampling", 'b',
586	+	(void *)&rand_samp);
587	+	break;
588		case 'l': /* limit */
589		switch (s[1]) {
590		case 'w': /* weight */
591	<	getparam(s+2, "limit weight", 'r', &minweight);
591	>	getparam(s+2, "limit weight", 'r',
592	>	(void *)&minweight);
593		break;
594		case 'r': /* reflection */
595	<	getparam(s+2, "limit reflection", 'i', &maxdepth);
595	>	getparam(s+2, "limit reflection", 'i',
596	>	(void *)&maxdepth);
597		break;
598		default:
599		goto badparam;
#	Line 513 \| Line 602 \| *register char s;**
602		case 'd': /* direct */
603		switch (s[1]) {
604		case 'j': /* jitter */
605	<	getparam(s+2, "direct jitter", 'r', &dstrsrc);
605	>	getparam(s+2, "direct jitter", 'r',
606	>	(void *)&dstrsrc);
607		break;
608		case 'c': /* certainty */
609	<	getparam(s+2, "direct certainty", 'r', &shadcert);
609	>	getparam(s+2, "direct certainty", 'r',
610	>	(void *)&shadcert);
611		break;
612		case 't': /* threshold */
613	<	getparam(s+2, "direct threshold", 'r', &shadthresh);
613	>	getparam(s+2, "direct threshold", 'r',
614	>	(void *)&shadthresh);
615		break;
616		case 'v': /* visibility */
617	<	getparam(s+2, "direct visibility",
618	<	'b', &directvis);
617	>	getparam(s+2, "direct visibility", 'b',
618	>	(void *)&directvis);
619		break;
620		case 's': /* sampling */
621	<	getparam(s+2, "direct sampling", 'r', &srcsizerat);
621	>	getparam(s+2, "direct sampling", 'r',
622	>	(void *)&srcsizerat);
623		break;
624		default:
625		goto badparam;
626		}
627		break;
628	<	case 'b': /* black and white */
629	<	getparam(s+1, "black and white", 'b', &greyscale);
628	>	case 'b': /* back faces or black and white */
629	>	switch (s[1]) {
630	>	case 'v': /* back face visibility */
631	>	getparam(s+2, "back face visibility", 'b',
632	>	(void *)&backvis);
633	>	break;
634	>	case '\0': /* black and white */
635	>	case ' ':
636	>	case 'y': case 'Y': case 't': case 'T': case '1': case '+':
637	>	case 'n': case 'N': case 'f': case 'F': case '0': case '-':
638	>	getparam(s+1, "black and white", 'b',
639	>	(void *)&greyscale);
640	>	newparam = prev_newp;
641	>	break;
642	>	default:
643	>	goto badparam;
644	>	}
645		break;
646		case 'i': /* irradiance */
647	<	getparam(s+1, "irradiance", 'b', &do_irrad);
647	>	getparam(s+1, "irradiance", 'b',
648	>	(void *)&do_irrad);
649		break;
650		case 'a': /* ambient */
651		switch (s[1]) {
652		case 'v': /* value */
653	<	getparam(s+2, "ambient value", 'C', (COLOR *)ambval);
653	>	getparam(s+2, "ambient value", 'C',
654	>	(void *)ambval);
655		break;
656	+	case 'w': /* weight */
657	+	getparam(s+2, "ambient value weight", 'i',
658	+	(void *)&ambvwt);
659	+	break;
660		case 'a': /* accuracy */
661	<	if (getparam(s+2, "ambient accuracy", 'r', &ambacc))
661	>	if (getparam(s+2, "ambient accuracy", 'r',
662	>	(void *)&ambacc))
663		setambacc(ambacc);
664		break;
665		case 'd': /* divisions */
666	<	getparam(s+2, "ambient divisions", 'i', &ambdiv);
666	>	getparam(s+2, "ambient divisions", 'i',
667	>	(void *)&ambdiv);
668		break;
669		case 's': /* samples */
670	<	getparam(s+2, "ambient super-samples", 'i', &ambssamp);
670	>	getparam(s+2, "ambient super-samples", 'i',
671	>	(void *)&ambssamp);
672		break;
673		case 'b': /* bounces */
674	<	getparam(s+2, "ambient bounces", 'i', &ambounce);
674	>	getparam(s+2, "ambient bounces", 'i',
675	>	(void *)&ambounce);
676		break;
677		case 'r':
678	<	if (getparam(s+2, "ambient resolution", 'i', &ambres))
678	>	if (getparam(s+2, "ambient resolution", 'i',
679	>	(void *)&ambres))
680		setambres(ambres);
681		break;
682		default:
683		goto badparam;
684		}
685		break;
686	+	case 'm': /* medium */
687	+	switch (s[1]) {
688	+	case 'e': /* extinction coefficient */
689	+	getparam(s+2, "extinction coefficient", 'C',
690	+	(void *)cextinction);
691	+	break;
692	+	case 'a': /* scattering albedo */
693	+	getparam(s+2, "scattering albedo", 'C',
694	+	(void *)salbedo);
695	+	break;
696	+	case 'g': /* scattering eccentricity */
697	+	getparam(s+2, "scattering eccentricity", 'r',
698	+	(void *)&seccg);
699	+	break;
700	+	case 's': /* sampling distance */
701	+	getparam(s+2, "mist sampling distance", 'r',
702	+	(void *)&ssampdist);
703	+	break;
704	+	default:
705	+	goto badparam;
706	+	}
707	+	break;
708		case 'p': /* pixel */
709		switch (s[1]) {
710		case 's': /* sample */
711	<	if (getparam(s+2, "pixel sample", 'i', &psample))
711	>	if (getparam(s+2, "pixel sample", 'i',
712	>	(void *)&psample))
713		pdepth = 0;
714		break;
715		case 't': /* threshold */
716	<	if (getparam(s+2, "pixel threshold", 'r', &maxdiff))
716	>	if (getparam(s+2, "pixel threshold", 'r',
717	>	(void *)&maxdiff))
718		pdepth = 0;
719		break;
720		default:
721		goto badparam;
722		}
723	+	newparam = prev_newp;
724		break;
725		case 's': /* specular */
726		switch (s[1]) {
727	<	case 'j': /* jitter */
728	<	getparam(s+2, "specular jitter", 'r', &specjitter);
727	>	case 's': /* sampling */
728	>	getparam(s+2, "specular sampling", 'r',
729	>	(void *)&specjitter);
730		break;
731		case 't': /* threshold */
732	<	getparam(s+2, "specular threshold", 'r', &specthresh);
732	>	getparam(s+2, "specular threshold", 'r',
733	>	(void *)&specthresh);
734		break;
735		default:
736		goto badparam;
#	Line 602 \| Line 748 \| badparam:
748		}
749
750
751	<	traceray(s) /* trace a single ray */
752	<	char *s;
751	>	void
752	>	traceray( /* trace a single ray */
753	>	char *s
754	>	)
755		{
756	<	char buf[128];
757	<	int x, y;
610	<	RAY thisray;
756	>	RAY thisray;
757	>	char buf[512];
758
759	+	thisray.rmax = 0.0;
760	+
761		if (!sscanvec(s, thisray.rorg) \|\|
762	<	!sscanvec(sskip(sskip(sskip(s))), thisray.rdir)) {
762	>	!sscanvec(sskip2(s,3), thisray.rdir)) {
763	>	int x, y;
764
765		if (dev->getcur == NULL)
766		return;
#	Line 618 \| Line 768 \| *char s;**
768		if ((*dev->getcur)(&x, &y) == ABORT)
769		return;
770
771	<	if (viewray(thisray.rorg, thisray.rdir, &ourview,
772	<	(x+.5)/hresolu, (y+.5)/vresolu) < 0) {
771	>	if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
772	>	&ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
773		error(COMMAND, "not on image");
774		return;
775		}
#	Line 629 \| Line 779 \| *char s;**
779		return;
780		}
781
782	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
633	<
634	<	rayvalue(&thisray);
782	>	ray_trace(&thisray);
783
784		if (thisray.ro == NULL)
785		(*dev->comout)("ray hit nothing");
786		else {
787	<	sprintf(buf, "ray hit %s %s \"%s\"",
788	<	objptr(thisray.ro->omod)->oname,
787	>	OBJREC *mat = NULL;
788	>	OBJREC *mod = NULL;
789	>	char matspec[256];
790	>	OBJREC *ino;
791	>
792	>	matspec[0] = '\0';
793	>	if (thisray.ro->omod != OVOID) {
794	>	mod = objptr(thisray.ro->omod);
795	>	mat = findmaterial(thisray.ro);
796	>	}
797	>	if (thisray.rod < 0.0)
798	>	strcpy(matspec, "back of ");
799	>	if (mod != NULL) {
800	>	strcat(matspec, mod->oname);
801	>	if (mat != mod && mat != NULL)
802	>	sprintf(matspec+strlen(matspec),
803	>	" (%s)", mat->oname);
804	>	} else
805	>	strcat(matspec, VOIDID);
806	>	sprintf(buf, "ray hit %s %s \"%s\"", matspec,
807		ofun[thisray.ro->otype].funame,
808		thisray.ro->oname);
809	+	if ((ino = objptr(thisray.robj)) != thisray.ro)
810	+	sprintf(buf+strlen(buf), " in %s \"%s\"",
811	+	ofun[ino->otype].funame, ino->oname);
812		(*dev->comout)(buf);
813		(*dev->comin)(buf, NULL);
814	<	if (thisray.rot >= FHUGE)
814	>	if (thisray.rot >= FHUGE*.99)
815		(*dev->comout)("at infinity");
816		else {
817	<	sprintf(buf, "at (%.6g %.6g %.6g)", thisray.rop[0],
818	<	thisray.rop[1], thisray.rop[2]);
817	>	sprintf(buf, "at (%.6g %.6g %.6g) (%.6g)",
818	>	thisray.rop[0], thisray.rop[1],
819	>	thisray.rop[2], raydistance(&thisray));
820		(*dev->comout)(buf);
821		}
822		(*dev->comin)(buf, NULL);
823	<	sprintf(buf, "value (%.5g %.5g %.5g) (%.1fL)",
824	<	colval(thisray.rcol,RED),
825	<	colval(thisray.rcol,GRN),
826	<	colval(thisray.rcol,BLU),
827	<	luminance(thisray.rcol));
823	>	sprintf(buf, "value (%.5g %.5g %.5g) (%.3gL)",
824	>	scolval(thisray.rcol,RED),
825	>	scolval(thisray.rcol,GRN),
826	>	scolval(thisray.rcol,BLU),
827	>	sluminance(thisray.rcol));
828		(*dev->comout)(buf);
829		}
830		(*dev->comin)(buf, NULL);
831		}
832
833
834	<	writepict(s) /* write the picture to a file */
835	<	char *s;
834	>	void
835	>	writepict( /* write the picture to a file */
836	>	char *s
837	>	)
838		{
839		static char buf[128];
840		char *fname;
841		FILE *fp;
842		COLR *scanline;
843		int y;
844	<
845	<	while (isspace(*s))
674	<	s++;
675	<	if (*s)
676	<	atos(buf, sizeof(buf), s);
677	<	else if (buf[0] == '\0') {
844	>	/* XXX relies on words.c 2.11 behavior */
845	>	if (nextword(buf, sizeof(buf), s) == NULL && !buf[0]) {
846		error(COMMAND, "no file");
847		return;
848		}
#	Line 684 \| Line 852 \| *char s;**
852		error(COMMAND, errmsg);
853		return;
854		}
855	<	#ifdef MSDOS
688	<	setmode(fileno(fp), O_BINARY);
689	<	#endif
855	>	SET_FILE_BINARY(fp);
856		(*dev->comout)("writing \"");
857		(*dev->comout)(fname);
858		(*dev->comout)("\"...\n");
859		/* write header */
860	+	newheader("RADIANCE", fp);
861		fputs(progname, fp);
862		fprintview(&ourview, fp);
863		if (octname != NULL)
#	Line 698 \| Line 865 \| *char s;**
865		else
866		putc('\n', fp);
867		fprintf(fp, "SOFTWARE= %s\n", VersionID);
868	+	fputnow(fp);
869		if (exposure != 1.0)
870		fputexpos(exposure, fp);
871		if (dev->pixaspect != 1.0)
872		fputaspect(dev->pixaspect, fp);
873	+	fputprims(stdprims, fp);
874		fputformat(COLRFMT, fp);
875		putc('\n', fp);
876		fprtresolu(hresolu, vresolu, fp);
#	Line 718 \| Line 887 \| *char s;**
887		if (fwritecolrs(scanline, hresolu, fp) < 0)
888		break;
889		}
890	<	free((char *)scanline);
890	>	free((void *)scanline);
891		if (fclose(fp) < 0)
892		error(COMMAND, "write error");
893		}

Diff Legend

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

Comparing ray/src/rt/rv2.c (file contents): Revision 2.21 by greg, Thu Sep 9 14:57:53 1993 UTC vs. Revision 2.74 by greg, Wed Nov 15 18:02:53 2023 UTC

Diff Legend

Comparing ray/src/rt/rv2.c (file contents):
Revision 2.21 by greg, Thu Sep 9 14:57:53 1993 UTC vs.
Revision 2.74 by greg, Wed Nov 15 18:02:53 2023 UTC