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 2.49 by greg, Tue Apr 19 01:15:06 2005 UTC vs.
Revision 2.81 by greg, Fri Jun 20 03:43:17 2025 UTC

#	Line 13 | Line 13 | static const char      RCSid[] = "$Id$";
13		#include  <string.h>
14
15		#include  "platform.h"
16	+	#include  "rtprocess.h" /* win_popen() */
17		#include  "ray.h"
17	–	#include  "source.h"
18		#include  "ambient.h"
19		#include  "otypes.h"
20	+	#include  "otspecial.h"
21		#include  "rpaint.h"
22
23		extern int  psample;                    /* pixel sample size */
#	Line 24 | Line 25 | extern double  maxdiff;                        /* max. sample difference */
25
26		#define  CTRL(c)        ((c)-'@')
27
28	<	#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
28	>	#define  sscanvec(s,v)  (sscanf(s,FVFORMAT,v,v+1,v+2)==3)
29
30		extern char  rifname[128];              /* rad input file name */
31
#	Line 36 | Line 33 | extern char  *progname;
33		extern char  *octname;
34
35
36	<	extern void
36	>	void
37		getframe(                               /* get a new frame */
38		char  *s
39		)
#	Line 47 | Line 44 | getframe(                              /* get a new frame */
44		}
45
46
47	<	extern void
47	>	void
48		getrepaint(                             /* get area and repaint */
49		char  *s
50		)
#	Line 56 | Line 53 | getrepaint(                            /* get area and repaint */
53
54		if (getrect(s, &box) < 0)
55		return;
56	<	paintrect(&ptrunk, 0, 0, hresolu, vresolu, &box);
56	>	paintrect(&ptrunk, &box);
57		}
58
59
60	<	extern void
61	<	getview(                                /* get/show view parameters */
60	>	void
61	>	getview(                                /* get/show/save view parameters */
62		char  *s
63		)
64		{
#	Line 80 | Line 77 | getview(                               /* get/show view parameters */
77		error(COMMAND, "bad view option(s)");
78		return;
79		}
80	<	if (sscanf(s, "%s", buf) == 1) {        /* write parameters to a file */
80	>	if (nextword(buf, sizeof(buf), s) != NULL) {    /* write to a file */
81		if ((fname = getpath(buf, NULL, 0)) == NULL ||
82		(fp = fopen(fname, "a")) == NULL) {
83		sprintf(errmsg, "cannot open \"%s\"", buf);
#	Line 153 | Line 150 | getview(                               /* get/show view parameters */
150		}
151
152
153	<	extern void
153	>	void
154		lastview(                               /* return to a previous view */
155		char  *s
156		)
#	Line 162 | Line 159 | lastview(                              /* return to a previous view */
159		char  *fname;
160		int  success;
161		VIEW  nv;
162	<
163	<	if (sscanf(s, "%s", buf) == 1) {        /* get parameters from a file */
162	>	/* get parameters from a file */
163	>	if (nextword(buf, sizeof(buf), s) != NULL) {
164		nv = stdview;
165		if ((fname = getpath(buf, "", R_OK)) == NULL ||
166		(success = viewfile(fname, &nv, NULL)) == -1) {
#	Line 184 | Line 181 | lastview(                              /* return to a previous view */
181		nv = ourview;
182		ourview = oldview;
183		oldview = nv;
184	<	newimage();
184	>	newimage(NULL);
185		}
186
187
188	<	extern void
188	>	void
189		saveview(                               /* save view to rad file */
190		char  *s
191		)
#	Line 204 | Line 201 | saveview(                              /* save view to rad file */
201		}
202		s = sskip(s);
203		}
204	<	while (isspace(*s))
208	<	s++;
209	<	if (*s)
210	<	atos(rifname, sizeof(rifname), s);
211	<	else if (rifname[0] == '\0') {
204	>	if (nextword(rifname, sizeof(rifname), s) == NULL && !rifname[0]) {
205		error(COMMAND, "no previous rad file");
206		return;
207		}
#	Line 226 | Line 219 | saveview(                              /* save view to rad file */
219		}
220
221
222	<	extern void
222	>	void
223		loadview(                               /* load view from rad file */
224		char  *s
225		)
#	Line 241 | Line 234 | loadview(                              /* load view from rad file */
234		s = sskip(s);
235		else
236		strcat(buf, "1");
237	<	if (*s)
245	<	atos(rifname, sizeof(rifname), s);
246	<	else if (rifname[0] == '\0') {
237	>	if (nextword(rifname, sizeof(rifname), s) == NULL && !rifname[0]) {
238		error(COMMAND, "no previous rad file");
239		return;
240		}
#	Line 269 | Line 260 | loadview(                              /* load view from rad file */
260		}
261
262
263	<	extern void
263	>	void
264		getaim(                         /* aim camera */
265		char  *s
266		)
#	Line 284 | Line 275 | getaim(                                /* aim camera */
275		}
276
277
278	<	extern void
278	>	void
279		getfocus(                               /* set focus distance */
280		char *s
281		)
282		{
283	<	FVECT  vc;
283	>	char  buf[64];
284		double  dist;
285
286		if (sscanf(s, "%lf", &dist) < 1) {
#	Line 316 | Line 307 | getfocus(                              /* set focus distance */
307		return;
308		}
309		ourview.vdist = dist;
310	+	sprintf(buf, "Focus distance set to %f\n", dist);
311	+	(*dev->comout)(buf);
312		}
313
314
315	<	extern void
315	>	void
316		getmove(                                /* move camera */
317		char  *s
318		)
#	Line 333 | Line 326 | getmove(                               /* move camera */
326		}
327
328
329	<	extern void
329	>	void
330		getrotate(                              /* rotate camera */
331		char  *s
332		)
333		{
334		VIEW  nv = ourview;
342	–	FVECT  v1;
335		double  angle, elev, zfact;
336
337		elev = 0.0; zfact = 1.0;
#	Line 348 | Line 340 | getrotate(                             /* rotate camera */
340		return;
341		}
342		spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
343	<	if (elev != 0.0) {
344	<	fcross(v1, nv.vdir, ourview.vup);
345	<	normalize(v1);
354	<	spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
355	<	}
343	>	if (elev != 0.0)
344	>	geodesic(nv.vdir, nv.vdir, nv.vup, elev*(PI/180.), GEOD_RAD);
345	>
346		zoomview(&nv, zfact);
347		newview(&nv);
348		}
349
350
351	<	extern void
351	>	void
352		getpivot(                               /* pivot viewpoint */
353	<	register char  *s
353	>	char  *s
354		)
355		{
356		FVECT  vc;
#	Line 377 | Line 367 | getpivot(                              /* pivot viewpoint */
367		}
368
369
370	<	extern void
370	>	void
371	>	getorigin(                              /* origin viewpoint */
372	>	char  *s
373	>	)
374	>	{
375	>	VIEW    nv = ourview;
376	>	FVECT   voff;
377	>	int     i;
378	>	double  d;
379	>	/* check for view origin shift */
380	>	if (sscanf(s, "%lf", &d) == 1) {
381	>	double  d_fore=d, d_right=0, d_up=0;
382	>	sscanf(s, "%*f %lf %lf", &d_right, &d_up);
383	>	d_right /= sqrt(nv.hn2);
384	>	for (i = 3; i--; )
385	>	nv.vp[i] += d_fore*nv.vdir[i] +
386	>	d_right*nv.hvec[i] +
387	>	d_up*nv.vup[i];
388	>	} else {                        /* else pick new origin */
389	>	int     x, y;
390	>	RAY     thisray;
391	>	if (dev->getcur == NULL)
392	>	return;
393	>	(*dev->comout)("Pick point on surface for new origin\n");
394	>	if ((*dev->getcur)(&x, &y) == ABORT)
395	>	return;
396	>	if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
397	>	&ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
398	>	error(COMMAND, "not on image");
399	>	return;
400	>	}
401	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
402	>	if (!localhit(&thisray, &thescene)) {
403	>	error(COMMAND, "not a local object");
404	>	return;
405	>	}
406	>	if (thisray.rod < 0.0)  /* don't look through other side */
407	>	flipsurface(&thisray);
408	>	VSUM(nv.vp, thisray.rop, thisray.ron, 20.0*FTINY);
409	>	VCOPY(nv.vdir, thisray.ron);
410	>	d = DOT(nv.vdir, nv.vup);
411	>	if (d*d >= 1.-2.*FTINY) {
412	>	/* need different up vector */
413	>	nv.vup[0] = nv.vup[1] = nv.vup[2] = 0.0;
414	>	for (i = 3; i--; )
415	>	if (nv.vdir[i]*nv.vdir[i] < 0.34)
416	>	break;
417	>	nv.vup[i] = 1.;
418	>	}
419	>	}
420	>	newview(&nv);
421	>	}
422	>
423	>
424	>	void
425		getexposure(                            /* get new exposure */
426		char  *s
427		)
428		{
429		char  buf[128];
430	<	register char  *cp;
387	<	RECT  r;
430	>	char  *cp;
431		int  x, y;
432	<	register PNODE  *p = &ptrunk;
432	>	PNODE  *p = &ptrunk;
433		int  adapt = 0;
434		double  e = 1.0;
435
#	Line 403 | Line 446 | getexposure(                           /* get new exposure */
446		(*dev->comout)("Pick point for exposure\n");
447		if ((*dev->getcur)(&x, &y) == ABORT)
448		return;
449	<	r.l = r.d = 0;
407	<	r.r = hresolu; r.u = vresolu;
408	<	p = findrect(x, y, &ptrunk, &r, -1);
449	>	p = findrect(x, y, &ptrunk, -1);
450		} else {
451		if (*cp == '=') {       /* absolute setting */
452		p = NULL;
#	Line 422 | Line 463 | getexposure(                           /* get new exposure */
463		return;
464		}
465		}
466	<	if (*cp == '+' || *cp == '-')   /* f-stops */
466	>	if ((*cp == '+') | (*cp == '-'))        /* f-stops */
467		e *= pow(2.0, atof(cp));
468		else                            /* multiplier */
469		e *= atof(cp);
470		}
471		if (p != NULL) {                /* relative setting */
472	+	compavg(p);
473		if (bright(p->v) < 1e-15) {
474		error(COMMAND, "cannot normalize to zero");
475		return;
#	Line 446 | Line 488 | getexposure(                           /* get new exposure */
488
489		typedef union {int i; double d; COLOR C;}       *MyUptr;
490
491	<	extern int
491	>	int
492		getparam(               /* get variable from user */
493		char  *str,
494		char  *dsc,
#	Line 454 | Line 496 | getparam(              /* get variable from user */
496		void  *p
497		)
498		{
499	<	register MyUptr  ptr = (MyUptr)p;
499	>	MyUptr  ptr = (MyUptr)p;
500		int  i0;
501		double  d0, d1, d2;
502		char  buf[48];
#	Line 469 | Line 511 | getparam(              /* get variable from user */
511		if (sscanf(buf, "%d", &i0) != 1)
512		return(0);
513		}
514	+	if (ptr->i == i0)
515	+	return(0);
516		ptr->i = i0;
517	<	return(1);
517	>	break;
518		case 'r':                       /* real */
519		if (sscanf(str, "%lf", &d0) != 1) {
520		(*dev->comout)(dsc);
#	Line 480 | Line 524 | getparam(              /* get variable from user */
524		if (sscanf(buf, "%lf", &d0) != 1)
525		return(0);
526		}
527	+	if (FRELEQ(ptr->d, d0))
528	+	return(0);
529		ptr->d = d0;
530	<	return(1);
530	>	break;
531		case 'b':                       /* boolean */
532		if (sscanf(str, "%1s", buf) != 1) {
533		(*dev->comout)(dsc);
534		sprintf(buf, "? (%c): ", ptr->i ? 'y' : 'n');
535		(*dev->comout)(buf);
536		(*dev->comin)(buf, NULL);
537	<	if (buf[0] == '\0' ||
492	<	strchr("yY+1tTnN-0fF", buf[0]) == NULL)
537	>	if (buf[0] == '\0')
538		return(0);
539		}
540	<	ptr->i = strchr("yY+1tT", buf[0]) != NULL;
541	<	return(1);
540	>	if (strchr("yY+1tTnN-0fF", buf[0]) == NULL)
541	>	return(0);
542	>	i0 = strchr("yY+1tT", buf[0]) != NULL;
543	>	if (ptr->i == i0)
544	>	return(0);
545	>	ptr->i = i0;
546	>	break;
547		case 'C':                       /* color */
548		if (sscanf(str, "%lf %lf %lf", &d0, &d1, &d2) != 3) {
549		(*dev->comout)(dsc);
#	Line 506 | Line 556 | getparam(              /* get variable from user */
556		if (sscanf(buf, "%lf %lf %lf", &d0, &d1, &d2) != 3)
557		return(0);
558		}
559	+	if (FRELEQ(colval(ptr->C,RED), d0) &&
560	+	FRELEQ(colval(ptr->C,GRN), d1) &&
561	+	FRELEQ(colval(ptr->C,BLU), d2))
562	+	return(0);
563		setcolor(ptr->C, d0, d1, d2);
564	<	return(1);
564	>	break;
565	>	default:
566	>	return(0);              /* shouldn't happen */
567		}
568	<	return 0; /* nothing matched */
568	>	newparam++;
569	>	return(1);
570		}
571
572
573	<	extern void
573	>	void
574		setparam(                               /* get/set program parameter */
575	<	register char  *s
575	>	char  *s
576		)
577		{
578	+	int  prev_newp = newparam;
579		char  buf[128];
580
581		if (s[0] == '\0') {
582		(*dev->comout)(
583	<	"aa ab ad ar as av aw b dc dv dj ds dt i lr lw me ma mg ms ps pt sj st bv: ");
583	>	"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: ");
584		(*dev->comin)(buf, NULL);
585		s = buf;
586		}
587		switch (s[0]) {
588	+	case 'u':                       /* uncorrelated sampling */
589	+	if (getparam(s+1, "uncorrelated sampling", 'b',
590	+	(void *)&rand_samp))
591	+	reset_random();
592	+	break;
593		case 'l':                       /* limit */
594		switch (s[1]) {
595		case 'w':                       /* weight */
596	<	getparam(s+2, "limit weight", 'r',
534	<	(void *)&minweight);
596	>	getparam(s+2, "limit weight", 'r', &minweight);
597		break;
598		case 'r':                       /* reflection */
599	<	getparam(s+2, "limit reflection", 'i',
538	<	(void *)&maxdepth);
599	>	getparam(s+2, "limit reflection", 'i', &maxdepth);
600		break;
601		default:
602		goto badparam;
#	Line 544 | Line 605 | setparam(                              /* get/set program parameter */
605		case 'd':                       /* direct */
606		switch (s[1]) {
607		case 'j':                       /* jitter */
608	<	getparam(s+2, "direct jitter", 'r',
548	<	(void *)&dstrsrc);
608	>	getparam(s+2, "direct jitter", 'r', &dstrsrc);
609		break;
610		case 'c':                       /* certainty */
611	<	getparam(s+2, "direct certainty", 'r',
552	<	(void *)&shadcert);
611	>	getparam(s+2, "direct certainty", 'r', &shadcert);
612		break;
613		case 't':                       /* threshold */
614	<	getparam(s+2, "direct threshold", 'r',
556	<	(void *)&shadthresh);
614	>	getparam(s+2, "direct threshold", 'r', &shadthresh);
615		break;
616		case 'v':                       /* visibility */
617	<	getparam(s+2, "direct visibility", 'b',
560	<	(void *)&directvis);
617	>	getparam(s+2, "direct visibility", 'b', &directvis);
618		break;
619		case 's':                       /* sampling */
620	<	getparam(s+2, "direct sampling", 'r',
564	<	(void *)&srcsizerat);
620	>	getparam(s+2, "direct sampling", 'r', &srcsizerat);
621		break;
622		default:
623		goto badparam;
#	Line 577 | Line 633 | setparam(                              /* get/set program parameter */
633		case ' ':
634		case 'y': case 'Y': case 't': case 'T': case '1': case '+':
635		case 'n': case 'N': case 'f': case 'F': case '0': case '-':
636	<	getparam(s+1, "black and white", 'b',
637	<	(void *)&greyscale);
636	>	getparam(s+1, "black and white", 'b', &greyscale);
637	>	newparam = prev_newp;
638		break;
639		default:
640		goto badparam;
641		}
642		break;
643		case 'i':                       /* irradiance */
644	<	getparam(s+1, "irradiance", 'b',
589	<	(void *)&do_irrad);
644	>	getparam(s+1, "irradiance", 'b', &do_irrad);
645		break;
646		case 'a':                       /* ambient */
647		switch (s[1]) {
648		case 'v':                       /* value */
649	<	getparam(s+2, "ambient value", 'C',
595	<	(void *)ambval);
649	>	getparam(s+2, "ambient value", 'C', ambval);
650		break;
651		case 'w':                       /* weight */
652	<	getparam(s+2, "ambient value weight", 'i',
599	<	(void *)&ambvwt);
652	>	getparam(s+2, "ambient value weight", 'i', &ambvwt);
653		break;
654		case 'a':                       /* accuracy */
655	<	if (getparam(s+2, "ambient accuracy", 'r',
603	<	(void *)&ambacc))
655	>	if (getparam(s+2, "ambient accuracy", 'r', &ambacc))
656		setambacc(ambacc);
657		break;
658		case 'd':                       /* divisions */
659	<	getparam(s+2, "ambient divisions", 'i',
608	<	(void *)&ambdiv);
659	>	getparam(s+2, "ambient divisions", 'i', &ambdiv);
660		break;
661		case 's':                       /* samples */
662	<	getparam(s+2, "ambient super-samples", 'i',
612	<	(void *)&ambssamp);
662	>	getparam(s+2, "ambient super-samples", 'i', &ambssamp);
663		break;
664		case 'b':                       /* bounces */
665	<	getparam(s+2, "ambient bounces", 'i',
616	<	(void *)&ambounce);
665	>	getparam(s+2, "ambient bounces", 'i', &ambounce);
666		break;
667		case 'r':
668	<	if (getparam(s+2, "ambient resolution", 'i',
620	<	(void *)&ambres))
668	>	if (getparam(s+2, "ambient resolution", 'i', &ambres))
669		setambres(ambres);
670		break;
671		default:
#	Line 627 | Line 675 | setparam(                              /* get/set program parameter */
675		case 'm':                       /* medium */
676		switch (s[1]) {
677		case 'e':                       /* extinction coefficient */
678	<	getparam(s+2, "extinction coefficient", 'C',
631	<	(void *)cextinction);
678	>	getparam(s+2, "extinction coefficient", 'C', cextinction);
679		break;
680		case 'a':                       /* scattering albedo */
681	<	getparam(s+2, "scattering albedo", 'C',
635	<	(void *)salbedo);
681	>	getparam(s+2, "scattering albedo", 'C', salbedo);
682		break;
683		case 'g':                       /* scattering eccentricity */
684	<	getparam(s+2, "scattering eccentricity", 'r',
639	<	(void *)&seccg);
684	>	getparam(s+2, "scattering eccentricity", 'r', &seccg);
685		break;
686		case 's':                       /* sampling distance */
687	<	getparam(s+2, "mist sampling distance", 'r',
643	<	(void *)&ssampdist);
687	>	getparam(s+2, "mist sampling distance", 'r', &ssampdist);
688		break;
689		default:
690		goto badparam;
#	Line 649 | Line 693 | setparam(                              /* get/set program parameter */
693		case 'p':                       /* pixel */
694		switch (s[1]) {
695		case 's':                       /* sample */
696	<	if (getparam(s+2, "pixel sample", 'i',
653	<	(void *)&psample))
696	>	if (getparam(s+2, "pixel sample", 'i', &psample))
697		pdepth = 0;
698		break;
699		case 't':                       /* threshold */
700	<	if (getparam(s+2, "pixel threshold", 'r',
658	<	(void *)&maxdiff))
700	>	if (getparam(s+2, "pixel threshold", 'r', &maxdiff))
701		pdepth = 0;
702		break;
703		default:
704		goto badparam;
705		}
706	+	newparam = prev_newp;
707		break;
708		case 's':                       /* specular */
709		switch (s[1]) {
710	<	case 'j':                       /* jitter */
711	<	getparam(s+2, "specular jitter", 'r',
669	<	(void *)&specjitter);
710	>	case 's':                       /* sampling */
711	>	getparam(s+2, "specular sampling", 'r', &specjitter);
712		break;
713		case 't':                       /* threshold */
714	<	getparam(s+2, "specular threshold", 'r',
673	<	(void *)&specthresh);
714	>	getparam(s+2, "specular threshold", 'r', &specthresh);
715		break;
716		default:
717		goto badparam;
#	Line 688 | Line 729 | badparam:
729		}
730
731
732	<	extern void
733	<	traceray(s)                             /* trace a single ray */
734	<	char  *s;
732	>	void
733	>	traceray(                               /* trace a single ray */
734	>	char  *s
735	>	)
736		{
737	<	char  buf[128];
738	<	int  x, y;
739	<	OBJREC  *ino;
698	<	RAY  thisray;
737	>	RAY     thisray;
738	>	char    buf[512];
739	>	COLOR   col;
740
741		thisray.rmax = 0.0;
742
743		if (!sscanvec(s, thisray.rorg) ||
744		!sscanvec(sskip2(s,3), thisray.rdir)) {
745	+	int  x, y;
746
747		if (dev->getcur == NULL)
748		return;
#	Line 719 | Line 761 | char  *s;
761		return;
762		}
763
764	<	rayorigin(&thisray, PRIMARY, NULL, NULL);
723	<
724	<	rayvalue(&thisray);
764	>	ray_trace(&thisray);
765
766		if (thisray.ro == NULL)
767		(*dev->comout)("ray hit nothing");
768		else {
769		OBJREC  *mat = NULL;
770	<	OBJREC  *mod = NULL;;
770	>	OBJREC  *mod = NULL;
771		char    matspec[256];
772	+	OBJREC  *ino;
773	+
774		matspec[0] = '\0';
775		if (thisray.ro->omod != OVOID) {
776		mod = objptr(thisray.ro->omod);
777	<	mat = findmaterial(mod);
777	>	mat = findmaterial(thisray.ro);
778		}
779		if (thisray.rod < 0.0)
780		strcpy(matspec, "back of ");
#	Line 751 | Line 793 | char  *s;
793		ofun[ino->otype].funame, ino->oname);
794		(*dev->comout)(buf);
795		(*dev->comin)(buf, NULL);
796	<	if (thisray.rot >= FHUGE)
796	>	if (thisray.rot >= FHUGE*.99)
797		(*dev->comout)("at infinity");
798		else {
799	<	sprintf(buf, "at (%.6g %.6g %.6g) (%.6g)",
799	>	sprintf(buf, "at (%.3f %.3f %.3f) (%.6g)",
800		thisray.rop[0], thisray.rop[1],
801	<	thisray.rop[2], thisray.rt);
801	>	thisray.rop[2], raydistance(&thisray));
802		(*dev->comout)(buf);
803		}
804		(*dev->comin)(buf, NULL);
805	<	sprintf(buf, "value (%.5g %.5g %.5g) (%.3gL)",
806	<	colval(thisray.rcol,RED),
807	<	colval(thisray.rcol,GRN),
808	<	colval(thisray.rcol,BLU),
809	<	luminance(thisray.rcol));
805	>	scolor_rgb(col, thisray.rcol);
806	>	sprintf(buf, "value (%.4g %.4g %.4g) (%.3gL)",
807	>	colval(col,RED),
808	>	colval(col,GRN),
809	>	colval(col,BLU),
810	>	luminance(col));
811		(*dev->comout)(buf);
812		}
813		(*dev->comin)(buf, NULL);
814		}
815
816
817	<	extern void
818	<	writepict(s)                            /* write the picture to a file */
819	<	char  *s;
817	>	void
818	>	writepict(                              /* write the picture to a file */
819	>	char  *s
820	>	)
821		{
822		static char  buf[128];
823		char  *fname;
824		FILE  *fp;
825		COLR  *scanline;
826		int  y;
827	<
828	<	while (isspace(*s))
785	<	s++;
786	<	if (*s)
787	<	atos(buf, sizeof(buf), s);
788	<	else if (buf[0] == '\0') {
827	>	/* XXX relies on words.c 2.11 behavior */
828	>	if (nextword(buf, sizeof(buf), s) == NULL && !buf[0]) {
829		error(COMMAND, "no file");
830		return;
831		}
#	Line 813 | Line 853 | char  *s;
853		fputexpos(exposure, fp);
854		if (dev->pixaspect != 1.0)
855		fputaspect(dev->pixaspect, fp);
856	+	fputprims(stdprims, fp);
857		fputformat(COLRFMT, fp);
858		putc('\n', fp);
859		fprtresolu(hresolu, vresolu, fp);

Diff Legend

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