ViewVC Help

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

root/Development/ray/src/rt/srcdraw.c

Comparing ray/src/rt/srcdraw.c (file contents):
Revision 2.2 by greg, Sat Jun 8 20:43:03 1996 UTC vs.
Revision 2.11 by schorsch, Tue Mar 30 16:13:01 2004 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1996 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		* Draw small sources into image in case we missed them.
6	+	*
7	+	*  External symbols declared in ray.h
8		*/
9
10	<	#include  "ray.h"
10	>	#include "copyright.h"
11
12	+	#include  "ray.h"
13		#include  "view.h"
14	–
14		#include  "source.h"
15
16
#	Line 22 | Line 21 | static char SCCSid[] = "$SunId$ LBL";
21
22		#define MAXVERT         10
23
24	+	typedef struct splist {
25	+	struct splist   *next;                  /* next source in list */
26	+	int     sn;                             /* source number */
27	+	short   nv;                             /* number of vertices */
28	+	RREAL   vl[3][2];                       /* vertex array (last) */
29	+	} SPLIST;                               /* source polygon list */
30
31	+	extern VIEW     ourview;                /* our view parameters */
32	+	extern int      hres, vres;             /* our image resolution */
33	+	static SPLIST   *sphead = NULL;         /* our list of source polys */
34	+
35	+	static int inregion(RREAL p[2], double cv, int crit);
36	+	static void clipregion(RREAL a[2], RREAL b[2], double cv, int crit, RREAL r[2]);
37	+	static int hp_clip_poly(RREAL vl[][2], int nv, double cv, int crit,
38	+	RREAL vlo[][2]);
39	+	static int box_clip_poly(RREAL vl[MAXVERT][2], int nv,
40	+	double xl, double xr, double yb, double ya, RREAL vlo[MAXVERT][2]);
41	+	static double minw2(RREAL vl[][2], int nv, double ar2);
42	+	static void convex_center(RREAL vl[][2], int nv, RREAL cv[2]);
43	+	static double poly_area(RREAL vl[][2], int nv);
44	+	static int convex_hull(RREAL vl[][2], int nv, RREAL vlo[][2]);
45	+	static void spinsert(int sn, RREAL vl[][2], int nv);
46	+	static int sourcepoly(int sn, RREAL sp[MAXVERT][2]);
47	+
48	+
49		static int
50	<	inregion(p, cv, crit)                   /* check if vertex is in region */
51	<	FLOAT   p[2];
52	<	double  cv;
53	<	int     crit;
50	>	inregion(                       /* check if vertex is in region */
51	>	RREAL   p[2],
52	>	double  cv,
53	>	int     crit
54	>	)
55		{
56		switch (crit) {
57		case CLIP_ABOVE:
#	Line 43 | Line 67 | int    crit;
67		}
68
69
70	<	static
71	<	clipregion(a, b, cv, crit, r)           /* find intersection with boundary */
72	<	register FLOAT  a[2], b[2];
73	<	double  cv;
74	<	int     crit;
75	<	FLOAT   r[2];   /* return value */
70	>	static void
71	>	clipregion(             /* find intersection with boundary */
72	>	register RREAL  a[2],
73	>	register RREAL  b[2],
74	>	double  cv,
75	>	int     crit,
76	>	RREAL   r[2]    /* return value */
77	>	)
78		{
79		switch (crit) {
80		case CLIP_ABOVE:
#	Line 66 | Line 92 | FLOAT  r[2];   /* return value */
92
93
94		static int
95	<	hp_clip_poly(vl, nv, cv, crit, vlo)     /* clip polygon to half-plane */
96	<	FLOAT   vl[][2];
97	<	int     nv;
98	<	double  cv;
99	<	int     crit;
100	<	FLOAT   vlo[][2];       /* return value */
95	>	hp_clip_poly(   /* clip polygon to half-plane */
96	>	RREAL   vl[][2],
97	>	int     nv,
98	>	double  cv,
99	>	int     crit,
100	>	RREAL   vlo[][2]        /* return value */
101	>	)
102		{
103	<	FLOAT   *s, *p;
103	>	RREAL   *s, *p;
104		register int    j, nvo;
105
106		s = vl[nv-1];
#	Line 93 | Line 120 | FLOAT  vlo[][2];       /* return value */
120
121
122		static int
123	<	box_clip_poly(vl, nv, xl, xr, yb, ya, vlo)      /* clip polygon to box */
124	<	FLOAT   vl[MAXVERT][2];
125	<	int     nv;
126	<	double  xl, xr, yb, ya;
127	<	FLOAT   vlo[MAXVERT][2];        /* return value */
123	>	box_clip_poly(  /* clip polygon to box */
124	>	RREAL   vl[MAXVERT][2],
125	>	int     nv,
126	>	double  xl,
127	>	double  xr,
128	>	double  yb,
129	>	double  ya,
130	>	RREAL   vlo[MAXVERT][2] /* return value */
131	>	)
132		{
133	<	FLOAT   vlt[MAXVERT][2];
133	>	RREAL   vlt[MAXVERT][2];
134		int     nvt, nvo;
135
136		nvt = hp_clip_poly(vl, nv, yb, CLIP_BELOW, vlt);
#	Line 112 | Line 143 | FLOAT  vlo[MAXVERT][2];        /* return value */
143
144
145		static double
146	<	minw2(vl, nv, ar2)                      /* compute square of minimum width */
147	<	FLOAT   vl[][2];
148	<	int     nv;
149	<	double  ar2;
146	>	minw2(                  /* compute square of minimum width */
147	>	RREAL   vl[][2],
148	>	int     nv,
149	>	double  ar2
150	>	)
151		{
152		double  d2, w2, w2min, w2max;
153	<	register FLOAT  *p0, *p1, *p2;
153	>	register RREAL  *p0, *p1, *p2;
154		int     i, j;
155		/* find minimum for all widths */
156		w2min = FHUGE;
#	Line 144 | Line 176 | double ar2;
176		}
177
178
179	<	static
180	<	convex_center(vl, nv, cv)               /* compute center of convex polygon */
181	<	register FLOAT  vl[][2];
182	<	int     nv;
183	<	FLOAT   cv[2];          /* return value */
179	>	static void
180	>	convex_center(          /* compute center of convex polygon */
181	>	register RREAL  vl[][2],
182	>	int     nv,
183	>	RREAL   cv[2]           /* return value */
184	>	)
185		{
186		register int    i;
187		/* simple average (suboptimal) */
#	Line 163 | Line 196 | FLOAT  cv[2];          /* return value */
196
197
198		static double
199	<	poly_area(vl, nv)                       /* compute area of polygon */
200	<	register FLOAT  vl[][2];
201	<	int     nv;
199	>	poly_area(                      /* compute area of polygon */
200	>	register RREAL  vl[][2],
201	>	int     nv
202	>	)
203		{
204		double  a;
205	<	FLOAT   v0[2], v1[2];
205	>	RREAL   v0[2], v1[2];
206		register int    i;
207
208		a = 0.;
#	Line 185 | Line 219 | int    nv;
219
220
221		static int
222	<	convex_hull(vl, nv, vlo)                /* compute polygon's convex hull */
223	<	FLOAT   vl[][2];
224	<	int     nv;
225	<	FLOAT   vlo[][2];       /* return value */
222	>	convex_hull(            /* compute polygon's convex hull */
223	>	RREAL   vl[][2],
224	>	int     nv,
225	>	RREAL   vlo[][2]        /* return value */
226	>	)
227		{
228		int     nvo, nvt;
229	<	FLOAT   vlt[MAXVERT][2];
229	>	RREAL   vlt[MAXVERT][2];
230		double  voa, vta;
231		register int    i, j;
232		/* start with original polygon */
#	Line 220 | Line 255 | FLOAT  vlo[][2];       /* return value */
255		}
256
257
258	<	int
259	<	sourcepoly(vw, sn, sp)                  /* compute image polygon for source */
260	<	VIEW    *vw;
261	<	int     sn;
262	<	FLOAT   sp[MAXVERT][2];
258	>	static void
259	>	spinsert(                       /* insert new source polygon */
260	>	int     sn,
261	>	RREAL   vl[][2],
262	>	int     nv
263	>	)
264		{
265	<	static char     cubeord[8][6] = {{1,3,2,6,4,5},{0,4,5,7,3,2},
265	>	register SPLIST *spn;
266	>	register int    i;
267	>
268	>	if (nv < 3)
269	>	return;
270	>	if (nv > 3)
271	>	spn = (SPLIST *)malloc(sizeof(SPLIST)+sizeof(RREAL)*2*(nv-3));
272	>	else
273	>	spn = (SPLIST *)malloc(sizeof(SPLIST));
274	>	if (spn == NULL)
275	>	error(SYSTEM, "out of memory in spinsert");
276	>	spn->sn = sn;
277	>	for (i = spn->nv = nv; i--; ) {
278	>	spn->vl[i][0] = vl[i][0]; spn->vl[i][1] = vl[i][1];
279	>	}
280	>	spn->next = sphead;             /* push onto global list */
281	>	sphead = spn;
282	>	}
283	>
284	>
285	>	static int
286	>	sourcepoly(                     /* compute image polygon for source */
287	>	int     sn,
288	>	RREAL   sp[MAXVERT][2]
289	>	)
290	>	{
291	>	static short    cubeord[8][6] = {{1,3,2,6,4,5},{0,4,5,7,3,2},
292		{0,1,3,7,6,4},{0,1,5,7,6,2},
293		{0,2,6,7,5,1},{0,4,6,7,3,1},
294		{0,2,3,7,5,4},{1,5,4,6,2,3}};
295		register SRCREC *s = source + sn;
296		FVECT   ap, ip;
297	<	FLOAT   pt[6][2];
297	>	RREAL   pt[6][2];
298		int     dir;
299		register int    i, j;
300
301		if (s->sflags & (SDISTANT|SFLAT)) {
302	<	if (s->sflags & SDISTANT && vw->type == VT_PAR)
302	>	if (s->sflags & SDISTANT && ourview.type == VT_PAR)
303		return(0);              /* all or nothing case */
304		if (s->sflags & SFLAT) {
305		for (i = 0; i < 3; i++)
306	<	ap[i] = s->sloc[i] - vw->vp[i];
306	>	ap[i] = s->sloc[i] - ourview.vp[i];
307		if (DOT(ap, s->snorm) >= 0.)
308		return(0);      /* source faces away */
309		}
310		for (j = 0; j < 4; j++) {       /* four corners */
311		for (i = 0; i < 3; i++) {
312		ap[i] = s->sloc[i];
313	<	if (j==1|j==2) ap[i] += s->ss[SU][i];
313	>	if ((j==1)|(j==2)) ap[i] += s->ss[SU][i];
314		else ap[i] -= s->ss[SU][i];
315	<	if (j==2|j==3) ap[i] += s->ss[SV][i];
315	>	if ((j==2)|(j==3)) ap[i] += s->ss[SV][i];
316		else ap[i] -= s->ss[SV][i];
317		if (s->sflags & SDISTANT) {
318	<	ap[i] *= 1. + vw->vfore;
319	<	ap[i] += vw->vp[i];
318	>	ap[i] *= 1. + ourview.vfore;
319	>	ap[i] += ourview.vp[i];
320		}
321		}
322	<	viewloc(ip, vw, ap);            /* find image point */
322	>	viewloc(ip, &ourview, ap);      /* find image point */
323		if (ip[2] <= 0.)
324		return(0);              /* in front of view */
325		sp[j][0] = ip[0]; sp[j][1] = ip[1];
#	Line 266 | Line 328 | FLOAT  sp[MAXVERT][2];
328		}
329		/* identify furthest corner */
330		for (i = 0; i < 3; i++)
331	<	ap[i] = s->sloc[i] - vw->vp[i];
331	>	ap[i] = s->sloc[i] - ourview.vp[i];
332		dir =   (DOT(ap,s->ss[SU])>0.) |
333		(DOT(ap,s->ss[SV])>0.)<<1 |
334		(DOT(ap,s->ss[SW])>0.)<<2 ;
#	Line 281 | Line 343 | FLOAT  sp[MAXVERT][2];
343		if (cubeord[dir][j] & 4) ap[i] += s->ss[SW][i];
344		else ap[i] -= s->ss[SW][i];
345		}
346	<	viewloc(ip, vw, ap);            /* find image point */
346	>	viewloc(ip, &ourview, ap);      /* find image point */
347		if (ip[2] <= 0.)
348		return(0);              /* in front of view */
349		pt[j][0] = ip[0]; pt[j][1] = ip[1];
#	Line 290 | Line 352 | FLOAT  sp[MAXVERT][2];
352		}
353
354
355	<	/* add sources smaller than rad to computed subimage */
356	<	drawsources(vw, xr, yr, pic, zbf, x0, xsiz, y0, ysiz, rad)
357	<	VIEW    *vw;                            /* full image view */
358	<	int     xr, yr;                         /* full image dimensions */
359	<	COLOR   *pic[];                         /* subimage pixel value array */
298	<	float   *zbf[];                         /* subimage distance array (opt.) */
299	<	int     x0, xsiz, y0, ysiz;             /* origin and size of subimage */
300	<	int     rad;                            /* source sample size */
355	>	/* initialize by finding sources smaller than rad */
356	>	extern void
357	>	init_drawsources(
358	>	int     rad                             /* source sample size */
359	>	)
360		{
361	<	int     sn;
362	<	FLOAT   spoly[MAXVERT][2], ppoly[MAXVERT][2];
363	<	int     nsv, npv;
364	<	int     xmin, xmax, ymin, ymax, x, y, i;
365	<	FLOAT   cxy[2];
366	<	double  pa;
367	<	RAY     sr;
361	>	RREAL   spoly[MAXVERT][2];
362	>	int     nsv;
363	>	register SPLIST *sp;
364	>	register int    i;
365	>	/* free old source list if one */
366	>	for (sp = sphead; sp != NULL; sp = sphead) {
367	>	sphead = sp->next;
368	>	free((void *)sp);
369	>	}
370		/* loop through all sources */
371	<	for (sn = 0; sn < nsources; sn++) {
371	>	for (i = nsources; i--; ) {
372		/* compute image polygon for source */
373	<	if (!(nsv = sourcepoly(vw, sn, spoly)))
373	>	if (!(nsv = sourcepoly(i, spoly)))
374		continue;
375	+	/* clip to image boundaries */
376	+	if (!(nsv = box_clip_poly(spoly, nsv, 0., 1., 0., 1., spoly)))
377	+	continue;
378		/* big enough for standard sampling? */
379	<	if (minw2(spoly, nsv, vw->vn2/vw->hn2) > (double)rad*rad/xr/xr)
379	>	if (minw2(spoly, nsv, ourview.vn2/ourview.hn2) >
380	>	(double)rad*rad/hres/hres)
381		continue;
382	+	/* OK, add to our list */
383	+	spinsert(i, spoly, nsv);
384	+	}
385	+	}
386	+
387	+	extern void                     /* add sources smaller than rad to computed subimage */
388	+	drawsources(
389	+	COLOR   *pic[],                         /* subimage pixel value array */
390	+	float   *zbf[],                         /* subimage distance array (opt.) */
391	+	int     x0,                             /* origin and size of subimage */
392	+	int     xsiz,
393	+	int     y0,
394	+	int     ysiz
395	+	)
396	+	{
397	+	RREAL   spoly[MAXVERT][2], ppoly[MAXVERT][2];
398	+	int     nsv, npv;
399	+	int     xmin, xmax, ymin, ymax, x, y;
400	+	RREAL   cxy[2];
401	+	double  w;
402	+	RAY     sr;
403	+	register SPLIST *sp;
404	+	register int    i;
405	+	/* check each source in our list */
406	+	for (sp = sphead; sp != NULL; sp = sp->next) {
407		/* clip source poly to subimage */
408	<	nsv = box_clip_poly(spoly, nsv,
409	<	(double)x0/xr, (double)(x0+xsiz)/xr,
410	<	(double)y0/yr, (double)(y0+ysiz)/yr, spoly);
408	>	nsv = box_clip_poly(sp->vl, sp->nv,
409	>	(double)x0/hres, (double)(x0+xsiz)/hres,
410	>	(double)y0/vres, (double)(y0+ysiz)/vres, spoly);
411		if (!nsv)
412		continue;
413		/* find common subimage (BBox) */
414		xmin = x0 + xsiz; xmax = x0;
415		ymin = y0 + ysiz; ymax = y0;
416		for (i = 0; i < nsv; i++) {
417	<	if ((double)xmin/xr > spoly[i][0])
418	<	xmin = spoly[i][0]*xr + FTINY;
419	<	if ((double)xmax/xr < spoly[i][0])
420	<	xmax = spoly[i][0]*xr - FTINY;
421	<	if ((double)ymin/yr > spoly[i][1])
422	<	ymin = spoly[i][1]*yr + FTINY;
423	<	if ((double)ymax/yr < spoly[i][1])
424	<	ymax = spoly[i][1]*yr - FTINY;
417	>	if ((double)xmin/hres > spoly[i][0])
418	>	xmin = spoly[i][0]*hres + FTINY;
419	>	if ((double)xmax/hres < spoly[i][0])
420	>	xmax = spoly[i][0]*hres - FTINY;
421	>	if ((double)ymin/vres > spoly[i][1])
422	>	ymin = spoly[i][1]*vres + FTINY;
423	>	if ((double)ymax/vres < spoly[i][1])
424	>	ymax = spoly[i][1]*vres - FTINY;
425		}
426		/* evaluate each pixel in BBox */
427		for (y = ymin; y <= ymax; y++)
428		for (x = xmin; x <= xmax; x++) {
429		/* subarea for pixel */
430		npv = box_clip_poly(spoly, nsv,
431	<	(double)x/xr, (x+1.)/xr,
432	<	(double)y/yr, (y+1.)/yr, ppoly);
431	>	(double)x/hres, (x+1.)/hres,
432	>	(double)y/vres, (y+1.)/vres,
433	>	ppoly);
434		if (!npv)
435		continue;       /* no overlap */
436		convex_center(ppoly, npv, cxy);
437	<	if ((sr.rmax = viewray(sr.rorg, sr.rdir, vw,
438	<	cxy[0], cxy[1])) < -FTINY)
437	>	if ((sr.rmax = viewray(sr.rorg,sr.rdir,&ourview,
438	>	cxy[0],cxy[1])) < -FTINY)
439		continue;       /* not in view */
440	<	if (source[sn].sflags & SSPOT &&
441	<	spotout(&sr, source[sn].sl.s))
440	>	if (source[sp->sn].sflags & SSPOT &&
441	>	spotout(&sr, source[sp->sn].sl.s))
442		continue;       /* outside spot */
443	<	rayorigin(&sr, NULL, SHADOW, 1.0);
444	<	sr.rsrc = sn;
443	>	w = poly_area(ppoly, npv) * hres * vres;
444	>	if (w < .95) {          /* subpixel source */
445	>	rayorigin(&sr, NULL, SHADOW, 1.0);
446	>	sr.rsrc = sp->sn;
447	>	} else
448	>	rayorigin(&sr, NULL, PRIMARY, 1.0);
449		rayvalue(&sr);          /* compute value */
450		if (bright(sr.rcol) <= FTINY)
451		continue;       /* missed/blocked */
452		/* modify pixel */
453		if (zbf[y-y0] != NULL &&
454	<	sr.rt < zbf[y-y0][x-x0])
454	>	sr.rt < 0.99*zbf[y-y0][x-x0])
455		zbf[y-y0][x-x0] = sr.rt;
456	<	pa = poly_area(ppoly, npv);
457	<	scalecolor(sr.rcol, pa*xr*yr);
458	<	scalecolor(pic[y-y0][x-x0], (1.-pa*xr*yr));
456	>	else if (!bigdiff(sr.rcol, pic[y-y0][x-x0],
457	>	0.01))  /* source sample */
458	>	setcolor(pic[y-y0][x-x0], 0., 0., 0.);
459	>	scalecolor(sr.rcol, w);
460	>	scalecolor(pic[y-y0][x-x0], 1.-w);
461		addcolor(pic[y-y0][x-x0], sr.rcol);
462		}
463		}

Diff Legend

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