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.9 by greg, Wed Oct 1 22:07:19 2003 UTC vs.
Revision 2.19 by greg, Thu Nov 8 00:54:07 2018 UTC

#	Line 10 | Line 10 | static const char      RCSid[] = "$Id$";
10		#include "copyright.h"
11
12		#include  "ray.h"
13	–
13		#include  "view.h"
14	<
14	>	#include  "otypes.h"
15	>	#include  "otspecial.h"
16		#include  "source.h"
17
18
#	Line 34 | Line 34 | extern VIEW    ourview;                /* our view parameters */
34		extern int      hres, vres;             /* our image resolution */
35		static SPLIST   *sphead = NULL;         /* our list of source polys */
36
37	+	static int inregion(RREAL p[2], double cv, int crit);
38	+	static void clipregion(RREAL a[2], RREAL b[2], double cv, int crit, RREAL r[2]);
39	+	static int hp_clip_poly(RREAL vl[][2], int nv, double cv, int crit,
40	+	RREAL vlo[][2]);
41	+	static int box_clip_poly(RREAL vl[MAXVERT][2], int nv,
42	+	double xl, double xr, double yb, double ya, RREAL vlo[MAXVERT][2]);
43	+	static double minw2(RREAL vl[][2], int nv, double ar2);
44	+	static void convex_center(RREAL vl[][2], int nv, RREAL cv[2]);
45	+	static double poly_area(RREAL vl[][2], int nv);
46	+	static int convex_hull(RREAL vl[][2], int nv, RREAL vlo[][2]);
47	+	static void spinsert(int sn, RREAL vl[][2], int nv);
48	+	static int sourcepoly(int sn, RREAL sp[MAXVERT][2]);
49
50	+
51		static int
52	<	inregion(p, cv, crit)                   /* check if vertex is in region */
53	<	RREAL   p[2];
54	<	double  cv;
55	<	int     crit;
52	>	inregion(                       /* check if vertex is in region */
53	>	RREAL   p[2],
54	>	double  cv,
55	>	int     crit
56	>	)
57		{
58		switch (crit) {
59		case CLIP_ABOVE:
#	Line 55 | Line 69 | int    crit;
69		}
70
71
72	<	static
73	<	clipregion(a, b, cv, crit, r)           /* find intersection with boundary */
74	<	register RREAL  a[2], b[2];
75	<	double  cv;
76	<	int     crit;
77	<	RREAL   r[2];   /* return value */
72	>	static void
73	>	clipregion(             /* find intersection with boundary */
74	>	RREAL   a[2],
75	>	RREAL   b[2],
76	>	double  cv,
77	>	int     crit,
78	>	RREAL   r[2]    /* return value */
79	>	)
80		{
81		switch (crit) {
82		case CLIP_ABOVE:
#	Line 78 | Line 94 | RREAL  r[2];   /* return value */
94
95
96		static int
97	<	hp_clip_poly(vl, nv, cv, crit, vlo)     /* clip polygon to half-plane */
98	<	RREAL   vl[][2];
99	<	int     nv;
100	<	double  cv;
101	<	int     crit;
102	<	RREAL   vlo[][2];       /* return value */
97	>	hp_clip_poly(   /* clip polygon to half-plane */
98	>	RREAL   vl[][2],
99	>	int     nv,
100	>	double  cv,
101	>	int     crit,
102	>	RREAL   vlo[][2]        /* return value */
103	>	)
104		{
105		RREAL   *s, *p;
106	<	register int    j, nvo;
106	>	int     j, nvo;
107
108		s = vl[nv-1];
109		nvo = 0;
#	Line 105 | Line 122 | RREAL  vlo[][2];       /* return value */
122
123
124		static int
125	<	box_clip_poly(vl, nv, xl, xr, yb, ya, vlo)      /* clip polygon to box */
126	<	RREAL   vl[MAXVERT][2];
127	<	int     nv;
128	<	double  xl, xr, yb, ya;
129	<	RREAL   vlo[MAXVERT][2];        /* return value */
125	>	box_clip_poly(  /* clip polygon to box */
126	>	RREAL   vl[MAXVERT][2],
127	>	int     nv,
128	>	double  xl,
129	>	double  xr,
130	>	double  yb,
131	>	double  ya,
132	>	RREAL   vlo[MAXVERT][2] /* return value */
133	>	)
134		{
135		RREAL   vlt[MAXVERT][2];
136		int     nvt, nvo;
#	Line 124 | Line 145 | RREAL  vlo[MAXVERT][2];        /* return value */
145
146
147		static double
148	<	minw2(vl, nv, ar2)                      /* compute square of minimum width */
149	<	RREAL   vl[][2];
150	<	int     nv;
151	<	double  ar2;
148	>	minw2(                  /* compute square of minimum width */
149	>	RREAL   vl[][2],
150	>	int     nv,
151	>	double  ar2
152	>	)
153		{
154		double  d2, w2, w2min, w2max;
155	<	register RREAL  *p0, *p1, *p2;
155	>	RREAL   *p0, *p1, *p2;
156		int     i, j;
157		/* find minimum for all widths */
158		w2min = FHUGE;
#	Line 156 | Line 178 | double ar2;
178		}
179
180
181	<	static
182	<	convex_center(vl, nv, cv)               /* compute center of convex polygon */
183	<	register RREAL  vl[][2];
184	<	int     nv;
185	<	RREAL   cv[2];          /* return value */
181	>	static void
182	>	convex_center(          /* compute center of convex polygon */
183	>	RREAL   vl[][2],
184	>	int     nv,
185	>	RREAL   cv[2]           /* return value */
186	>	)
187		{
188	<	register int    i;
188	>	int     i;
189		/* simple average (suboptimal) */
190		cv[0] = cv[1] = 0.;
191		for (i = 0; i < nv; i++) {
#	Line 175 | Line 198 | RREAL  cv[2];          /* return value */
198
199
200		static double
201	<	poly_area(vl, nv)                       /* compute area of polygon */
202	<	register RREAL  vl[][2];
203	<	int     nv;
201	>	poly_area(                      /* compute area of polygon */
202	>	RREAL   vl[][2],
203	>	int     nv
204	>	)
205		{
206		double  a;
207		RREAL   v0[2], v1[2];
208	<	register int    i;
208	>	int     i;
209
210		a = 0.;
211		v0[0] = vl[1][0] - vl[0][0];
#	Line 197 | Line 221 | int    nv;
221
222
223		static int
224	<	convex_hull(vl, nv, vlo)                /* compute polygon's convex hull */
225	<	RREAL   vl[][2];
226	<	int     nv;
227	<	RREAL   vlo[][2];       /* return value */
224	>	convex_hull(            /* compute polygon's convex hull */
225	>	RREAL   vl[][2],
226	>	int     nv,
227	>	RREAL   vlo[][2]        /* return value */
228	>	)
229		{
230		int     nvo, nvt;
231		RREAL   vlt[MAXVERT][2];
232		double  voa, vta;
233	<	register int    i, j;
233	>	int     i, j;
234		/* start with original polygon */
235		for (i = nvo = nv; i--; ) {
236		vlo[i][0] = vl[i][0]; vlo[i][1] = vl[i][1];
#	Line 232 | Line 257 | RREAL  vlo[][2];       /* return value */
257		}
258
259
260	<	static
261	<	spinsert(sn, vl, nv)                    /* insert new source polygon */
262	<	int     sn;
263	<	RREAL   vl[][2];
264	<	int     nv;
260	>	static void
261	>	spinsert(                       /* insert new source polygon */
262	>	int     sn,
263	>	RREAL   vl[][2],
264	>	int     nv
265	>	)
266		{
267	<	register SPLIST *spn;
268	<	register int    i;
267	>	SPLIST  *spn;
268	>	int     i;
269
270		if (nv < 3)
271		return;
#	Line 258 | Line 284 | int    nv;
284		}
285
286
287	<	int
288	<	sourcepoly(sn, sp)                      /* compute image polygon for source */
289	<	int     sn;
290	<	RREAL   sp[MAXVERT][2];
287	>	static int
288	>	sourcepoly(                     /* compute image polygon for source */
289	>	int     sn,
290	>	RREAL   sp[MAXVERT][2]
291	>	)
292		{
293		static short    cubeord[8][6] = {{1,3,2,6,4,5},{0,4,5,7,3,2},
294		{0,1,3,7,6,4},{0,1,5,7,6,2},
295		{0,2,6,7,5,1},{0,4,6,7,3,1},
296		{0,2,3,7,5,4},{1,5,4,6,2,3}};
297	<	register SRCREC *s = source + sn;
297	>	SRCREC  *s = source + sn;
298		FVECT   ap, ip;
299		RREAL   pt[6][2];
300		int     dir;
301	<	register int    i, j;
301	>	int     i, j;
302
303		if (s->sflags & (SDISTANT|SFLAT)) {
304	<	if (s->sflags & SDISTANT && ourview.type == VT_PAR)
305	<	return(0);              /* all or nothing case */
304	>	if (s->sflags & SDISTANT) {
305	>	if (ourview.type == VT_PAR)
306	>	return(0);      /* all or nothing case */
307	>	if (s->srad >= 0.05)
308	>	return(0);      /* should never be a problem */
309	>	}
310		if (s->sflags & SFLAT) {
311		for (i = 0; i < 3; i++)
312		ap[i] = s->sloc[i] - ourview.vp[i];
#	Line 294 | Line 325 | RREAL  sp[MAXVERT][2];
325		ap[i] += ourview.vp[i];
326		}
327		}
328	<	viewloc(ip, &ourview, ap);      /* find image point */
329	<	if (ip[2] <= 0.)
328	>	/* find image point */
329	>	if (viewloc(ip, &ourview, ap) <= 0)
330		return(0);              /* in front of view */
331		sp[j][0] = ip[0]; sp[j][1] = ip[1];
332		}
#	Line 318 | Line 349 | RREAL  sp[MAXVERT][2];
349		if (cubeord[dir][j] & 4) ap[i] += s->ss[SW][i];
350		else ap[i] -= s->ss[SW][i];
351		}
352	<	viewloc(ip, &ourview, ap);      /* find image point */
353	<	if (ip[2] <= 0.)
352	>	/* find image point */
353	>	if (viewloc(ip, &ourview, ap) <= 0)
354		return(0);              /* in front of view */
355		pt[j][0] = ip[0]; pt[j][1] = ip[1];
356		}
#	Line 328 | Line 359 | RREAL  sp[MAXVERT][2];
359
360
361		/* initialize by finding sources smaller than rad */
362	<	init_drawsources(rad)
363	<	int     rad;                            /* source sample size */
362	>	void
363	>	init_drawsources(
364	>	int     rad                             /* source sample size */
365	>	)
366		{
367		RREAL   spoly[MAXVERT][2];
368		int     nsv;
369	<	register SPLIST *sp;
370	<	register int    i;
369	>	SPLIST  *sp;
370	>	int     i;
371		/* free old source list if one */
372		for (sp = sphead; sp != NULL; sp = sphead) {
373		sphead = sp->next;
#	Line 342 | Line 375 | int    rad;                            /* source sample size */
375		}
376		/* loop through all sources */
377		for (i = nsources; i--; ) {
378	+	/* skip illum's */
379	+	if (findmaterial(source[i].so)->otype == MAT_ILLUM)
380	+	continue;
381		/* compute image polygon for source */
382		if (!(nsv = sourcepoly(i, spoly)))
383		continue;
#	Line 357 | Line 393 | int    rad;                            /* source sample size */
393		}
394		}
395
396	<	void                    /* add sources smaller than rad to computed subimage */
397	<	drawsources(pic, zbf, x0, xsiz, y0, ysiz)
398	<	COLOR   *pic[];                         /* subimage pixel value array */
399	<	float   *zbf[];                         /* subimage distance array (opt.) */
400	<	int     x0, xsiz, y0, ysiz;             /* origin and size of subimage */
396	>	void                            /* add sources smaller than rad to computed subimage */
397	>	drawsources(
398	>	COLOR   *pic[],                         /* subimage pixel value array */
399	>	float   *zbf[],                         /* subimage distance array (opt.) */
400	>	int     x0,                             /* origin and size of subimage */
401	>	int     xsiz,
402	>	int     y0,
403	>	int     ysiz
404	>	)
405		{
406		RREAL   spoly[MAXVERT][2], ppoly[MAXVERT][2];
407		int     nsv, npv;
#	Line 369 | Line 409 | int    x0, xsiz, y0, ysiz;             /* origin and size of subimag
409		RREAL   cxy[2];
410		double  w;
411		RAY     sr;
412	<	register SPLIST *sp;
413	<	register int    i;
412	>	SPLIST  *sp;
413	>	int     i;
414		/* check each source in our list */
415		for (sp = sphead; sp != NULL; sp = sp->next) {
416		/* clip source poly to subimage */
#	Line 409 | Line 449 | int    x0, xsiz, y0, ysiz;             /* origin and size of subimag
449		if (source[sp->sn].sflags & SSPOT &&
450		spotout(&sr, source[sp->sn].sl.s))
451		continue;       /* outside spot */
452	<	w = poly_area(ppoly, npv) * hres * vres;
453	<	if (w < .95) {          /* subpixel source */
414	<	rayorigin(&sr, NULL, SHADOW, 1.0);
415	<	sr.rsrc = sp->sn;
416	<	} else
417	<	rayorigin(&sr, NULL, PRIMARY, 1.0);
452	>	rayorigin(&sr, SHADOW, NULL, NULL);
453	>	sr.rsrc = sp->sn;
454		rayvalue(&sr);          /* compute value */
455		if (bright(sr.rcol) <= FTINY)
456		continue;       /* missed/blocked */
457		/* modify pixel */
458	+	w = poly_area(ppoly, npv) * hres * vres;
459		if (zbf[y-y0] != NULL &&
460	<	sr.rt < 0.999*zbf[y-y0][x-x0])
460	>	sr.rt < 0.99*zbf[y-y0][x-x0]) {
461		zbf[y-y0][x-x0] = sr.rt;
462	<	else if (!bigdiff(sr.rcol, pic[y-y0][x-x0],
463	<	0.01))  /* source sample */
464	<	setcolor(pic[y-y0][x-x0], 0., 0., 0.);
462	>	} else if (!bigdiff(sr.rcol, pic[y-y0][x-x0],
463	>	0.01)) { /* source sample */
464	>	scalecolor(pic[y-y0][x-x0], w);
465	>	continue;
466	>	}
467		scalecolor(sr.rcol, w);
468		scalecolor(pic[y-y0][x-x0], 1.-w);
469		addcolor(pic[y-y0][x-x0], sr.rcol);

Diff Legend

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