ViewVC Help

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

root/Development/ray/src/util/rtcontrib.c

Comparing ray/src/util/rtcontrib.c (file contents):
Revision 1.2 by greg, Thu May 26 06:55:22 2005 UTC vs.
Revision 1.3 by greg, Thu May 26 15:14:42 2005 UTC

#	Line 68 | Line 68 | struct rtproc {
68
69		/* rtrace command and defaults */
70		char            *rtargv[256] = { "rtrace", "-dt", "0", "-dj", ".5", "-dr", "3",
71	<	"-ab", "1", "-ad", "512", };
71	>	"-ab", "1", "-ad", "128", };
72		int  rtargc = 11;
73		/* overriding rtrace options */
74		char            *myrtopts[] = { "-o~~TmWdp", "-h-",
#	Line 113 | Line 113 | void init(int np);
113		void tracecontribs(FILE *fp);
114		struct rtproc *wait_rproc(void);
115		struct rtproc *get_rproc(void);
116	<	void process_rays(struct rtproc *rtp);
116	>	void queue_raytree(struct rtproc *rtp);
117	>	void process_queue(void);
118
119		void putcontrib(const DCOLOR cnt, FILE *fout);
120		void add_contrib(const char *modn);
#	Line 188 | Line 189 | main(int argc, char *argv[])
189		case '\0':
190		header = !header;
191		continue;
192	<	case '+': case '1': case 'T': case 't':
192	>	case '+': case '1':
193	>	case 'T': case 't':
194	>	case 'Y': case 'y':
195		header = 1;
196		continue;
197	<	case '-': case '0': case 'F': case 'f':
197	>	case '-': case '0':
198	>	case 'F': case 'f':
199	>	case 'N': case 'n':
200		header = 0;
201		continue;
202		}
#	Line 345 | Line 350 | init(int np)
350		scompile("Dx=$1;Dy=$2;Dz=$3;", NULL, 0);
351		scompile("Px=$4;Py=$5;Pz=$6;", NULL, 0);
352		/* set up signal handling */
353	<	#ifdef SIGPIPE /* not present on Windows */
353	>	signal(SIGINT, quit);
354	>	#ifdef SIGHUP
355	>	signal(SIGHUP, quit);
356	>	#endif
357	>	#ifdef SIGTERM
358	>	signal(SIGTERM, quit);
359	>	#endif
360	>	#ifdef SIGPIPE
361		signal(SIGPIPE, quit);
362		#endif
363		rtp = &rt0;                     /* start rtrace process(es) */
#	Line 679 | Line 691 | done_contrib(void)
691		}
692		}
693
694	<	/* process (or save) ray tree produced by rtrace process */
694	>	/* queue completed ray tree produced by rtrace process */
695		void
696	<	process_rays(struct rtproc *rtp)
696	>	queue_raytree(struct rtproc *rtp)
697		{
698	<	struct rtproc   *rtu;
699	<	/* check if time to process it */
700	<	if (rtp->raynum == lastdone+1) {
698	>	struct rtproc   *rtu, *rtl = NULL;
699	>	/* insert following ray order */
700	>	for (rtu = rt_unproc; rtu != NULL; rtu = (rtl=rtu)->next)
701	>	if (rtp->raynum < rtu->raynum)
702	>	break;
703	>	rtu = (struct rtproc *)malloc(sizeof(struct rtproc));
704	>	if (rtu == NULL)
705	>	error(SYSTEM, "out of memory in queue_raytree");
706	>	*rtu = *rtp;
707	>	if (rtl == NULL) {
708	>	rtu->next = rt_unproc;
709	>	rt_unproc = rtu;
710	>	} else {
711	>	rtu->next = rtl->next;
712	>	rtl->next = rtu;
713	>	}
714	>	rtp->raynum = 0;                /* clear path for next ray tree */
715	>	rtp->bsiz = 0;
716	>	rtp->buf = NULL;
717	>	rtp->nbr = 0;
718	>	}
719	>
720	>	/* process completed ray trees from our queue */
721	>	void
722	>	process_queue(void)
723	>	{
724	>	char    modname[128];
725	>	/* ray-ordered queue */
726	>	while (rt_unproc != NULL && rt_unproc->raynum == lastdone+1) {
727	>	struct rtproc   *rtp = rt_unproc;
728		int             n = rtp->nbr;
729		const char      *cp = rtp->buf;
691	–	char            modname[128];
730		while (n > 0) {         /* process rays */
731		register char   *mnp = modname;
732		/* skip leading tabs */
#	Line 712 | Line 750 | process_rays(struct rtproc *rtp)
750		}
751		done_contrib();         /* sum up contributions & output */
752		lastdone = rtp->raynum;
753	<	free(rtp->buf);
754	<	/* catch up with unprocessed list */
755	<	while (rt_unproc != NULL && rt_unproc->raynum == lastdone+1) {
718	<	process_rays(rt_unproc);
719	<	rt_unproc = (rtu=rt_unproc)->next;
720	<	free(rtu);
721	<	}
722	<	} else {                        /* else insert in unprocessed list */
723	<	struct rtproc   *rtl = NULL;
724	<	for (rtu = rt_unproc; rtu != NULL; rtu = (rtl=rtu)->next)
725	<	if (rtp->raynum < rtu->raynum)
726	<	break;
727	<	rtu = (struct rtproc *)malloc(sizeof(struct rtproc));
728	<	if (rtu == NULL)
729	<	error(SYSTEM, "out of memory in process_rays");
730	<	*rtu = *rtp;
731	<	if (rtl == NULL) {
732	<	rtu->next = rt_unproc;
733	<	rt_unproc = rtu;
734	<	} else {
735	<	rtu->next = rtl->next;
736	<	rtl->next = rtu;
737	<	}
753	>	free(rtp->buf);         /* free up buffer space */
754	>	rt_unproc = rtp->next;
755	>	free(rtp);              /* done with this ray tree */
756		}
739	–	rtp->raynum = 0;                /* clear path for next ray tree */
740	–	rtp->bsiz = 0;
741	–	rtp->buf = NULL;
742	–	rtp->nbr = 0;
757		}
758
759		/* wait for rtrace process to finish with ray tree */
#	Line 796 | Line 810 | wait_rproc(void)
810		if (rt->nbr >= 4 && !memcmp(rt->buf+rt->nbr-4,
811		"~\t~\t", 4)) {
812		rt->nbr -= 4;   /* elide terminator */
813	<	process_rays(rt);
813	>	queue_raytree(rt);
814		rtfree = rt;    /* ready for next ray */
815		}
816		}
#	Line 827 | Line 841 | tracecontribs(FILE *fin)
841		while ((iblen = getinp(inpbuf, fin)) > 0) {
842		if (lastray+1 < lastray) {      /* counter rollover? */
843		while (wait_rproc() != NULL)
844	<	;
844	>	process_queue();
845		lastdone = lastray = 0;
846		}
847		rtp = get_rproc();              /* get avail. rtrace process */
848	<	rtp->raynum = ++lastray;        /* assign this ray to it */
848	>	rtp->raynum = ++lastray;        /* assign ray to it */
849		writebuf(rtp->pd.w, inpbuf, iblen);
850		if (!--raysleft)
851	<	break;                  /* explicit EOF */
851	>	break;
852	>	process_queue();                /* catch up with results */
853		}
854		while (wait_rproc() != NULL)            /* process outstanding rays */
855	<	;
855	>	process_queue();
856		if (raysleft > 0)
857		error(USER, "unexpected EOF on input");
858		}

Diff Legend

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