27 |
|
struct splist *next; /* next source in list */ |
28 |
|
int sn; /* source number */ |
29 |
|
short nv; /* number of vertices */ |
30 |
< |
FLOAT vl[3][2]; /* vertex array (last) */ |
30 |
> |
RREAL vl[3][2]; /* vertex array (last) */ |
31 |
|
} SPLIST; /* source polygon list */ |
32 |
|
|
33 |
|
extern VIEW ourview; /* our view parameters */ |
37 |
|
|
38 |
|
static int |
39 |
|
inregion(p, cv, crit) /* check if vertex is in region */ |
40 |
< |
FLOAT p[2]; |
40 |
> |
RREAL p[2]; |
41 |
|
double cv; |
42 |
|
int crit; |
43 |
|
{ |
57 |
|
|
58 |
|
static |
59 |
|
clipregion(a, b, cv, crit, r) /* find intersection with boundary */ |
60 |
< |
register FLOAT a[2], b[2]; |
60 |
> |
register RREAL a[2], b[2]; |
61 |
|
double cv; |
62 |
|
int crit; |
63 |
< |
FLOAT r[2]; /* return value */ |
63 |
> |
RREAL r[2]; /* return value */ |
64 |
|
{ |
65 |
|
switch (crit) { |
66 |
|
case CLIP_ABOVE: |
79 |
|
|
80 |
|
static int |
81 |
|
hp_clip_poly(vl, nv, cv, crit, vlo) /* clip polygon to half-plane */ |
82 |
< |
FLOAT vl[][2]; |
82 |
> |
RREAL vl[][2]; |
83 |
|
int nv; |
84 |
|
double cv; |
85 |
|
int crit; |
86 |
< |
FLOAT vlo[][2]; /* return value */ |
86 |
> |
RREAL vlo[][2]; /* return value */ |
87 |
|
{ |
88 |
< |
FLOAT *s, *p; |
88 |
> |
RREAL *s, *p; |
89 |
|
register int j, nvo; |
90 |
|
|
91 |
|
s = vl[nv-1]; |
106 |
|
|
107 |
|
static int |
108 |
|
box_clip_poly(vl, nv, xl, xr, yb, ya, vlo) /* clip polygon to box */ |
109 |
< |
FLOAT vl[MAXVERT][2]; |
109 |
> |
RREAL vl[MAXVERT][2]; |
110 |
|
int nv; |
111 |
|
double xl, xr, yb, ya; |
112 |
< |
FLOAT vlo[MAXVERT][2]; /* return value */ |
112 |
> |
RREAL vlo[MAXVERT][2]; /* return value */ |
113 |
|
{ |
114 |
< |
FLOAT vlt[MAXVERT][2]; |
114 |
> |
RREAL vlt[MAXVERT][2]; |
115 |
|
int nvt, nvo; |
116 |
|
|
117 |
|
nvt = hp_clip_poly(vl, nv, yb, CLIP_BELOW, vlt); |
125 |
|
|
126 |
|
static double |
127 |
|
minw2(vl, nv, ar2) /* compute square of minimum width */ |
128 |
< |
FLOAT vl[][2]; |
128 |
> |
RREAL vl[][2]; |
129 |
|
int nv; |
130 |
|
double ar2; |
131 |
|
{ |
132 |
|
double d2, w2, w2min, w2max; |
133 |
< |
register FLOAT *p0, *p1, *p2; |
133 |
> |
register RREAL *p0, *p1, *p2; |
134 |
|
int i, j; |
135 |
|
/* find minimum for all widths */ |
136 |
|
w2min = FHUGE; |
158 |
|
|
159 |
|
static |
160 |
|
convex_center(vl, nv, cv) /* compute center of convex polygon */ |
161 |
< |
register FLOAT vl[][2]; |
161 |
> |
register RREAL vl[][2]; |
162 |
|
int nv; |
163 |
< |
FLOAT cv[2]; /* return value */ |
163 |
> |
RREAL cv[2]; /* return value */ |
164 |
|
{ |
165 |
|
register int i; |
166 |
|
/* simple average (suboptimal) */ |
176 |
|
|
177 |
|
static double |
178 |
|
poly_area(vl, nv) /* compute area of polygon */ |
179 |
< |
register FLOAT vl[][2]; |
179 |
> |
register RREAL vl[][2]; |
180 |
|
int nv; |
181 |
|
{ |
182 |
|
double a; |
183 |
< |
FLOAT v0[2], v1[2]; |
183 |
> |
RREAL v0[2], v1[2]; |
184 |
|
register int i; |
185 |
|
|
186 |
|
a = 0.; |
198 |
|
|
199 |
|
static int |
200 |
|
convex_hull(vl, nv, vlo) /* compute polygon's convex hull */ |
201 |
< |
FLOAT vl[][2]; |
201 |
> |
RREAL vl[][2]; |
202 |
|
int nv; |
203 |
< |
FLOAT vlo[][2]; /* return value */ |
203 |
> |
RREAL vlo[][2]; /* return value */ |
204 |
|
{ |
205 |
|
int nvo, nvt; |
206 |
< |
FLOAT vlt[MAXVERT][2]; |
206 |
> |
RREAL vlt[MAXVERT][2]; |
207 |
|
double voa, vta; |
208 |
|
register int i, j; |
209 |
|
/* start with original polygon */ |
235 |
|
static |
236 |
|
spinsert(sn, vl, nv) /* insert new source polygon */ |
237 |
|
int sn; |
238 |
< |
FLOAT vl[][2]; |
238 |
> |
RREAL vl[][2]; |
239 |
|
int nv; |
240 |
|
{ |
241 |
|
register SPLIST *spn; |
244 |
|
if (nv < 3) |
245 |
|
return; |
246 |
|
if (nv > 3) |
247 |
< |
spn = (SPLIST *)malloc(sizeof(SPLIST)+sizeof(FLOAT)*2*(nv-3)); |
247 |
> |
spn = (SPLIST *)malloc(sizeof(SPLIST)+sizeof(RREAL)*2*(nv-3)); |
248 |
|
else |
249 |
|
spn = (SPLIST *)malloc(sizeof(SPLIST)); |
250 |
|
if (spn == NULL) |
261 |
|
int |
262 |
|
sourcepoly(sn, sp) /* compute image polygon for source */ |
263 |
|
int sn; |
264 |
< |
FLOAT sp[MAXVERT][2]; |
264 |
> |
RREAL sp[MAXVERT][2]; |
265 |
|
{ |
266 |
|
static char cubeord[8][6] = {{1,3,2,6,4,5},{0,4,5,7,3,2}, |
267 |
|
{0,1,3,7,6,4},{0,1,5,7,6,2}, |
269 |
|
{0,2,3,7,5,4},{1,5,4,6,2,3}}; |
270 |
|
register SRCREC *s = source + sn; |
271 |
|
FVECT ap, ip; |
272 |
< |
FLOAT pt[6][2]; |
272 |
> |
RREAL pt[6][2]; |
273 |
|
int dir; |
274 |
|
register int i, j; |
275 |
|
|
331 |
|
init_drawsources(rad) |
332 |
|
int rad; /* source sample size */ |
333 |
|
{ |
334 |
< |
FLOAT spoly[MAXVERT][2]; |
334 |
> |
RREAL spoly[MAXVERT][2]; |
335 |
|
int nsv; |
336 |
|
register SPLIST *sp; |
337 |
|
register int i; |
363 |
|
float *zbf[]; /* subimage distance array (opt.) */ |
364 |
|
int x0, xsiz, y0, ysiz; /* origin and size of subimage */ |
365 |
|
{ |
366 |
< |
FLOAT spoly[MAXVERT][2], ppoly[MAXVERT][2]; |
366 |
> |
RREAL spoly[MAXVERT][2], ppoly[MAXVERT][2]; |
367 |
|
int nsv, npv; |
368 |
|
int xmin, xmax, ymin, ymax, x, y; |
369 |
< |
FLOAT cxy[2]; |
369 |
> |
RREAL cxy[2]; |
370 |
|
double w; |
371 |
|
RAY sr; |
372 |
|
register SPLIST *sp; |