13 |
|
#include "random.h" |
14 |
|
|
15 |
|
|
16 |
< |
o_default(ob, il, rt, nm) /* default illum action */ |
17 |
< |
OBJREC *ob; |
18 |
< |
struct illum_args *il; |
19 |
< |
struct rtproc *rt; |
20 |
< |
char *nm; |
16 |
> |
int o_default(FUN_ARGLIST); |
17 |
> |
int o_face(FUN_ARGLIST); |
18 |
> |
int o_sphere(FUN_ARGLIST); |
19 |
> |
int o_ring(FUN_ARGLIST); |
20 |
> |
void raysamp(float res[3], FVECT org, FVECT dir, struct rtproc *rt); |
21 |
> |
void rayflush(struct rtproc *rt); |
22 |
> |
void mkaxes(FVECT u, FVECT v, FVECT n); |
23 |
> |
void rounddir(FVECT dv, double alt, double azi); |
24 |
> |
void flatdir(FVECT dv, double alt, double azi); |
25 |
> |
|
26 |
> |
|
27 |
> |
int /* XXX type conflict with otypes.h */ |
28 |
> |
o_default( /* default illum action */ |
29 |
> |
OBJREC *ob, |
30 |
> |
struct illum_args *il, |
31 |
> |
struct rtproc *rt, |
32 |
> |
char *nm |
33 |
> |
) |
34 |
|
{ |
35 |
|
sprintf(errmsg, "(%s): cannot make illum for %s \"%s\"", |
36 |
|
nm, ofun[ob->otype].funame, ob->oname); |
37 |
|
error(WARNING, errmsg); |
38 |
|
printobj(il->altmat, ob); |
39 |
+ |
return(1); |
40 |
|
} |
41 |
|
|
42 |
|
|
43 |
< |
o_face(ob, il, rt, nm) /* make an illum face */ |
44 |
< |
OBJREC *ob; |
45 |
< |
struct illum_args *il; |
46 |
< |
struct rtproc *rt; |
47 |
< |
char *nm; |
43 |
> |
int |
44 |
> |
o_face( /* make an illum face */ |
45 |
> |
OBJREC *ob, |
46 |
> |
struct illum_args *il, |
47 |
> |
struct rtproc *rt, |
48 |
> |
char *nm |
49 |
> |
) |
50 |
|
{ |
51 |
|
#define MAXMISS (5*n*il->nsamps) |
52 |
|
int dim[3]; |
63 |
|
fa = getface(ob); |
64 |
|
if (fa->area == 0.0) { |
65 |
|
freeface(ob); |
66 |
< |
o_default(ob, il, rt, nm); |
51 |
< |
return; |
66 |
> |
return(o_default(ob, il, rt, nm)); |
67 |
|
} |
68 |
|
/* set up sampling */ |
69 |
|
if (il->sampdens <= 0) |
130 |
|
rt->nrays = 0; |
131 |
|
freeface(ob); |
132 |
|
free((void *)distarr); |
133 |
< |
o_default(ob, il, rt, nm); |
119 |
< |
return; |
133 |
> |
return(o_default(ob, il, rt, nm)); |
134 |
|
} |
135 |
|
for (j = 0; j < 3; j++) |
136 |
|
org[j] += .001*fa->norm[j]; |
152 |
|
} |
153 |
|
|
154 |
|
|
155 |
< |
o_sphere(ob, il, rt, nm) /* make an illum sphere */ |
156 |
< |
register OBJREC *ob; |
157 |
< |
struct illum_args *il; |
158 |
< |
struct rtproc *rt; |
159 |
< |
char *nm; |
155 |
> |
int |
156 |
> |
o_sphere( /* make an illum sphere */ |
157 |
> |
register OBJREC *ob, |
158 |
> |
struct illum_args *il, |
159 |
> |
struct rtproc *rt, |
160 |
> |
char *nm |
161 |
> |
) |
162 |
|
{ |
163 |
|
int dim[3]; |
164 |
|
int n, nalt, nazi; |
220 |
|
printobj(il->altmat, ob); |
221 |
|
/* clean up */ |
222 |
|
free((void *)distarr); |
223 |
+ |
return(1); |
224 |
|
} |
225 |
|
|
226 |
|
|
227 |
< |
o_ring(ob, il, rt, nm) /* make an illum ring */ |
228 |
< |
OBJREC *ob; |
229 |
< |
struct illum_args *il; |
230 |
< |
struct rtproc *rt; |
231 |
< |
char *nm; |
227 |
> |
int |
228 |
> |
o_ring( /* make an illum ring */ |
229 |
> |
OBJREC *ob, |
230 |
> |
struct illum_args *il, |
231 |
> |
struct rtproc *rt, |
232 |
> |
char *nm |
233 |
> |
) |
234 |
|
{ |
235 |
|
int dim[3]; |
236 |
|
int n, nalt, nazi; |
292 |
|
/* clean up */ |
293 |
|
freecone(ob); |
294 |
|
free((void *)distarr); |
295 |
+ |
return(1); |
296 |
|
} |
297 |
|
|
298 |
|
|
299 |
< |
raysamp(res, org, dir, rt) /* compute a ray sample */ |
300 |
< |
float res[3]; |
301 |
< |
FVECT org, dir; |
302 |
< |
register struct rtproc *rt; |
299 |
> |
void |
300 |
> |
raysamp( /* compute a ray sample */ |
301 |
> |
float res[3], |
302 |
> |
FVECT org, |
303 |
> |
FVECT dir, |
304 |
> |
register struct rtproc *rt |
305 |
> |
) |
306 |
|
{ |
307 |
|
register float *fp; |
308 |
|
|
315 |
|
} |
316 |
|
|
317 |
|
|
318 |
< |
rayflush(rt) /* flush buffered rays */ |
319 |
< |
register struct rtproc *rt; |
318 |
> |
void |
319 |
> |
rayflush( /* flush buffered rays */ |
320 |
> |
register struct rtproc *rt |
321 |
> |
) |
322 |
|
{ |
323 |
|
register int i; |
324 |
|
|
341 |
|
} |
342 |
|
|
343 |
|
|
344 |
< |
mkaxes(u, v, n) /* compute u and v to go with n */ |
345 |
< |
FVECT u, v, n; |
344 |
> |
void |
345 |
> |
mkaxes( /* compute u and v to go with n */ |
346 |
> |
FVECT u, |
347 |
> |
FVECT v, |
348 |
> |
FVECT n |
349 |
> |
) |
350 |
|
{ |
351 |
|
register int i; |
352 |
|
|
361 |
|
} |
362 |
|
|
363 |
|
|
364 |
< |
rounddir(dv, alt, azi) /* compute uniform spherical direction */ |
365 |
< |
register FVECT dv; |
366 |
< |
double alt, azi; |
364 |
> |
void |
365 |
> |
rounddir( /* compute uniform spherical direction */ |
366 |
> |
register FVECT dv, |
367 |
> |
double alt, |
368 |
> |
double azi |
369 |
> |
) |
370 |
|
{ |
371 |
|
double d1, d2; |
372 |
|
|
378 |
|
} |
379 |
|
|
380 |
|
|
381 |
< |
flatdir(dv, alt, azi) /* compute uniform hemispherical direction */ |
382 |
< |
register FVECT dv; |
383 |
< |
double alt, azi; |
381 |
> |
void |
382 |
> |
flatdir( /* compute uniform hemispherical direction */ |
383 |
> |
register FVECT dv, |
384 |
> |
double alt, |
385 |
> |
double azi |
386 |
> |
) |
387 |
|
{ |
388 |
|
double d1, d2; |
389 |
|
|