ViewVC Help

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

root/radiance/src/gen/mkillum2.c

Comparing src/gen/mkillum2.c (file contents):
Revision 1.10 by greg, Tue Aug 13 13:45:18 1991 UTC vs.
Revision 2.2 by greg, Wed Mar 11 12:25:47 1992 UTC

#	Line 26 | Line 26 | char  *nm;
26		sprintf(errmsg, "(%s): cannot make illum for %s \"%s\"",
27		nm, ofun[ob->otype].funame, ob->oname);
28		error(WARNING, errmsg);
29	<	if (!(il->flags & IL_LIGHT))
30	<	printobj(il->altmat, ob);
29	>	printobj(il->altmat, ob);
30		}
31
32
#	Line 56 | Line 55 | char  *nm;
55		return;
56		}
57		/* set up sampling */
58	<	n = PI * il->sampdens;
59	<	nalt = sqrt(n/PI) + .5;
60	<	nazi = PI*nalt + .5;
58	>	if (il->sampdens <= 0)
59	>	nalt = nazi = 1;
60	>	else {
61	>	n = PI * il->sampdens;
62	>	nalt = sqrt(n/PI) + .5;
63	>	nazi = PI*nalt + .5;
64	>	}
65		n = nalt*nazi;
66		distarr = (float *)calloc(n, 3*sizeof(float));
67		if (distarr == NULL)
#	Line 82 | Line 85 | char  *nm;
85		for (i = 0; i < il->nsamps; i++) {
86		/* random direction */
87		h = ilhash(dim, 3) + i;
88	<	peano(sp, 2, urand(h), .02);
88	>	multisamp(sp, 2, urand(h));
89		r1 = (dim[1] + sp[0])/nalt;
90	<	r2 = (dim[2] + sp[1])/nazi;
90	>	r2 = (dim[2] + sp[1] - .5)/nazi;
91		flatdir(dn, r1, r2);
92		for (j = 0; j < 3; j++)
93		dir[j] = -dn[0]*u[j] - dn[1]*v[j] - dn[2]*fa->norm[j];
94		/* random location */
95		do {
96	<	peano(sp, 2, urand(h+nmisses), .01);
96	>	multisamp(sp, 2, urand(h+4862+nmisses));
97		r1 = ur[0] + (ur[1]-ur[0]) * sp[0];
98		r2 = vr[0] + (vr[1]-vr[0]) * sp[1];
99		for (j = 0; j < 3; j++)
#	Line 111 | Line 114 | char  *nm;
114		raysamp(distarr+3*(dim[1]*nazi+dim[2]), org, dir, rt);
115		}
116		rayflush(rt);
117	<	/* write out the face w/ distribution */
118	<	flatout(il, distarr, nalt, nazi, u, v, fa->norm);
119	<	illumout(il, ob);
117	>	/* write out the face and its distribution */
118	>	if (average(il, distarr, nalt*nazi)) {
119	>	if (il->sampdens > 0)
120	>	flatout(il, distarr, nalt, nazi, u, v, fa->norm);
121	>	illumout(il, ob);
122	>	} else
123	>	printobj(il->altmat, ob);
124		/* clean up */
125		freeface(ob);
126		free((char *)distarr);
#	Line 138 | Line 145 | char  *nm;
145		if (ob->oargs.nfargs != 4)
146		objerror(ob, USER, "bad # of arguments");
147		/* set up sampling */
148	<	n = 4.*PI * il->sampdens;
149	<	nalt = sqrt(n/PI) + .5;
150	<	nazi = PI*nalt + .5;
148	>	if (il->sampdens <= 0)
149	>	nalt = nazi = 1;
150	>	else {
151	>	n = 4.*PI * il->sampdens;
152	>	nalt = sqrt(n/PI) + .5;
153	>	nazi = PI*nalt + .5;
154	>	}
155		n = nalt*nazi;
156		distarr = (float *)calloc(n, 3*sizeof(float));
157		if (distarr == NULL)
#	Line 151 | Line 162 | char  *nm;
162		for (dim[2] = 0; dim[2] < nazi; dim[2]++)
163		for (i = 0; i < il->nsamps; i++) {
164		/* next sample point */
165	<	peano(sp, 4, urand(ilhash(dim,3)+i), .02);
165	>	multisamp(sp, 4, urand(ilhash(dim,3)+i));
166		/* random direction */
167		r1 = (dim[1] + sp[0])/nalt;
168	<	r2 = (dim[2] + sp[1])/nazi;
168	>	r2 = (dim[2] + sp[1] - .5)/nazi;
169		rounddir(dir, r1, r2);
170		/* random location */
171		mkaxes(u, v, dir);          /* yuck! */
#	Line 172 | Line 183 | char  *nm;
183		raysamp(distarr+3*(dim[1]*nazi+dim[2]), org, dir, rt);
184		}
185		rayflush(rt);
186	<	/* write out the sphere w/ distribution */
187	<	roundout(il, distarr, nalt, nazi);
188	<	illumout(il, ob);
186	>	/* write out the sphere and its distribution */
187	>	if (average(il, distarr, nalt*nazi)) {
188	>	if (il->sampdens > 0)
189	>	roundout(il, distarr, nalt, nazi);
190	>	else
191	>	objerror(ob, WARNING, "diffuse distribution");
192	>	illumout(il, ob);
193	>	} else
194	>	printobj(il->altmat, ob);
195		/* clean up */
196		free((char *)distarr);
197		}
#	Line 197 | Line 214 | char  *nm;
214		/* get/check arguments */
215		co = getcone(ob, 0);
216		/* set up sampling */
217	<	n = PI * il->sampdens;
218	<	nalt = sqrt(n/PI) + .5;
219	<	nazi = PI*nalt + .5;
217	>	if (il->sampdens <= 0)
218	>	nalt = nazi = 1;
219	>	else {
220	>	n = PI * il->sampdens;
221	>	nalt = sqrt(n/PI) + .5;
222	>	nazi = PI*nalt + .5;
223	>	}
224		n = nalt*nazi;
225		distarr = (float *)calloc(n, 3*sizeof(float));
226		if (distarr == NULL)
#	Line 211 | Line 232 | char  *nm;
232		for (dim[2] = 0; dim[2] < nazi; dim[2]++)
233		for (i = 0; i < il->nsamps; i++) {
234		/* next sample point */
235	<	peano(sp, 4, urand(ilhash(dim,3)+i), .02);
235	>	multisamp(sp, 4, urand(ilhash(dim,3)+i));
236		/* random direction */
237		r1 = (dim[1] + sp[0])/nalt;
238	<	r2 = (dim[2] + sp[1])/nalt;
238	>	r2 = (dim[2] + sp[1] - .5)/nazi;
239		flatdir(dn, r1, r2);
240		for (j = 0; j < 3; j++)
241		dir[j] = -dn[0]*u[j] - dn[1]*v[j] - dn[2]*co->ad[j];
#	Line 232 | Line 253 | char  *nm;
253		raysamp(distarr+3*(dim[1]*nazi+dim[2]), org, dir, rt);
254		}
255		rayflush(rt);
256	<	/* write out the ring w/ distribution */
257	<	flatout(il, distarr, nalt, nazi, u, v, co->ad);
258	<	illumout(il, ob);
256	>	/* write out the ring and its distribution */
257	>	if (average(il, distarr, nalt*nazi)) {
258	>	if (il->sampdens > 0)
259	>	flatout(il, distarr, nalt, nazi, u, v, co->ad);
260	>	illumout(il, ob);
261	>	} else
262	>	printobj(il->altmat, ob);
263		/* clean up */
264		freecone(ob);
265		free((char *)distarr);
#	Line 265 | Line 290 | register struct rtproc  *rt;
290		if (rt->nrays <= 0)
291		return;
292		bzero(rt->buf+6*rt->nrays, 6*sizeof(float));
293	+	errno = 0;
294		if ( process(rt->pd, (char *)rt->buf, (char *)rt->buf,
295		3*sizeof(float)*rt->nrays,
296		6*sizeof(float)*(rt->nrays+1)) <

Diff Legend

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