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 |
|
|
25 |
|
struct splist *next; /* next source in list */ |
26 |
|
int sn; /* source number */ |
27 |
|
short nv; /* number of vertices */ |
28 |
< |
FLOAT vl[3][2]; /* vertex array (last) */ |
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: |
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: |
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]; |
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); |
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; |
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) */ |
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.; |
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 */ |
255 |
|
} |
256 |
|
|
257 |
|
|
258 |
< |
static |
259 |
< |
spinsert(sn, vl, nv) /* insert new source polygon */ |
260 |
< |
int sn; |
261 |
< |
FLOAT vl[][2]; |
262 |
< |
int nv; |
258 |
> |
static void |
259 |
> |
spinsert( /* insert new source polygon */ |
260 |
> |
int sn, |
261 |
> |
RREAL vl[][2], |
262 |
> |
int nv |
263 |
> |
) |
264 |
|
{ |
265 |
|
register SPLIST *spn; |
266 |
|
register int i; |
268 |
|
if (nv < 3) |
269 |
|
return; |
270 |
|
if (nv > 3) |
271 |
< |
spn = (SPLIST *)malloc(sizeof(SPLIST)+sizeof(FLOAT)*2*(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) |
282 |
|
} |
283 |
|
|
284 |
|
|
285 |
< |
int |
286 |
< |
sourcepoly(sn, sp) /* compute image polygon for source */ |
287 |
< |
int sn; |
288 |
< |
FLOAT sp[MAXVERT][2]; |
285 |
> |
static int |
286 |
> |
sourcepoly( /* compute image polygon for source */ |
287 |
> |
int sn, |
288 |
> |
RREAL sp[MAXVERT][2] |
289 |
> |
) |
290 |
|
{ |
291 |
< |
static char cubeord[8][6] = {{1,3,2,6,4,5},{0,4,5,7,3,2}, |
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 |
|
|
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. + ourview.vfore; |
353 |
|
|
354 |
|
|
355 |
|
/* initialize by finding sources smaller than rad */ |
356 |
< |
init_drawsources(rad) |
357 |
< |
int rad; /* source sample size */ |
356 |
> |
extern void |
357 |
> |
init_drawsources( |
358 |
> |
int rad /* source sample size */ |
359 |
> |
) |
360 |
|
{ |
361 |
< |
FLOAT spoly[MAXVERT][2]; |
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((char *)sp); |
368 |
> |
free((void *)sp); |
369 |
|
} |
370 |
|
/* loop through all sources */ |
371 |
|
for (i = nsources; i--; ) { |
384 |
|
} |
385 |
|
} |
386 |
|
|
387 |
< |
/* add sources smaller than rad to computed subimage */ |
388 |
< |
drawsources(pic, zbf, x0, xsiz, y0, ysiz) |
389 |
< |
COLOR *pic[]; /* subimage pixel value array */ |
390 |
< |
float *zbf[]; /* subimage distance array (opt.) */ |
391 |
< |
int x0, xsiz, y0, ysiz; /* origin and size of subimage */ |
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 |
< |
FLOAT spoly[MAXVERT][2], ppoly[MAXVERT][2]; |
397 |
> |
RREAL spoly[MAXVERT][2], ppoly[MAXVERT][2]; |
398 |
|
int nsv, npv; |
399 |
|
int xmin, xmax, ymin, ymax, x, y; |
400 |
< |
FLOAT cxy[2]; |
401 |
< |
double pa; |
400 |
> |
RREAL cxy[2]; |
401 |
> |
double w; |
402 |
|
RAY sr; |
403 |
|
register SPLIST *sp; |
404 |
|
register int i; |
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 = sp->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*hres*vres); |
458 |
< |
scalecolor(pic[y-y0][x-x0], (1.-pa*hres*vres)); |
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 |
|
} |