| 8 |
|
* Source sampling routines |
| 9 |
|
*/ |
| 10 |
|
|
| 11 |
< |
#include "standard.h" |
| 11 |
> |
#include "ray.h" |
| 12 |
|
|
| 13 |
– |
#include "object.h" |
| 14 |
– |
|
| 13 |
|
#include "source.h" |
| 14 |
|
|
| 15 |
|
#include "random.h" |
| 16 |
|
|
| 17 |
|
|
| 20 |
– |
extern int dimlist[]; /* dimension list for distribution */ |
| 21 |
– |
extern int ndims; /* number of dimensions so far */ |
| 22 |
– |
extern int samplendx; /* index for this sample */ |
| 23 |
– |
|
| 24 |
– |
|
| 18 |
|
double |
| 19 |
< |
nextssamp(org, dir, si) /* compute sample for source, rtn. distance */ |
| 20 |
< |
FVECT org, dir; /* origin is read only, direction is set */ |
| 19 |
> |
nextssamp(r, si) /* compute sample for source, rtn. distance */ |
| 20 |
> |
register RAY *r; /* origin is read, direction is set */ |
| 21 |
|
register SRCINDEX *si; /* source index (modified to current) */ |
| 22 |
|
{ |
| 23 |
|
int cent[3], size[3], parr[2]; |
| 29 |
|
if (++si->sn >= nsources) |
| 30 |
|
return(0.0); /* no more */ |
| 31 |
|
if (srcsizerat <= FTINY) |
| 32 |
< |
nopart(si, org); |
| 32 |
> |
nopart(si, r); |
| 33 |
|
else { |
| 34 |
|
for (i = si->sn; source[i].sflags & SVIRTUAL; |
| 35 |
|
i = source[i].sa.sv.sn) |
| 36 |
|
; /* partition source */ |
| 37 |
< |
(*sfun[source[i].so->otype].of->partit)(si, org); |
| 37 |
> |
(*sfun[source[i].so->otype].of->partit)(si, r); |
| 38 |
|
} |
| 39 |
|
si->sp = -1; |
| 40 |
|
} |
| 64 |
|
vpos[i] += (double)cent[i]/MAXSPART; |
| 65 |
|
/* compute direction */ |
| 66 |
|
for (i = 0; i < 3; i++) |
| 67 |
< |
dir[i] = source[si->sn].sloc[i] + |
| 67 |
> |
r->rdir[i] = source[si->sn].sloc[i] + |
| 68 |
|
vpos[SU]*source[si->sn].ss[SU][i] + |
| 69 |
|
vpos[SV]*source[si->sn].ss[SV][i] + |
| 70 |
|
vpos[SW]*source[si->sn].ss[SW][i]; |
| 71 |
|
|
| 72 |
|
if (!(source[si->sn].sflags & SDISTANT)) |
| 73 |
|
for (i = 0; i < 3; i++) |
| 74 |
< |
dir[i] -= org[i]; |
| 74 |
> |
r->rdir[i] -= r->rorg[i]; |
| 75 |
|
/* compute distance */ |
| 76 |
< |
if ((d = normalize(dir)) == 0.0) |
| 76 |
> |
if ((d = normalize(r->rdir)) == 0.0) |
| 77 |
|
goto tryagain; /* at source! */ |
| 78 |
|
|
| 79 |
|
/* compute sample size */ |
| 80 |
|
si->dom = source[si->sn].ss2; |
| 81 |
|
if (source[si->sn].sflags & SFLAT) { |
| 82 |
< |
si->dom *= sflatform(si->sn, dir); |
| 82 |
> |
si->dom *= sflatform(si->sn, r->rdir); |
| 83 |
|
if (si->dom <= FTINY) { /* behind source */ |
| 84 |
|
si->np = 0; |
| 85 |
|
goto tryagain; |
| 86 |
|
} |
| 87 |
|
si->dom *= (double)(size[SU]*size[SV])/(MAXSPART*MAXSPART); |
| 88 |
|
} else if (source[si->sn].sflags & SCYL) { |
| 89 |
< |
si->dom *= scylform(si->sn, dir); |
| 89 |
> |
si->dom *= scylform(si->sn, r->rdir); |
| 90 |
|
si->dom *= (double)size[SU]/MAXSPART; |
| 91 |
|
} else { |
| 92 |
|
si->dom *= (double)(size[SU]*size[SV]*size[SW]) / |
| 130 |
|
} |
| 131 |
|
|
| 132 |
|
|
| 133 |
< |
nopart(si, ro) /* single source partition */ |
| 133 |
> |
nopart(si, r) /* single source partition */ |
| 134 |
|
register SRCINDEX *si; |
| 135 |
< |
FVECT ro; |
| 135 |
> |
RAY *r; |
| 136 |
|
{ |
| 137 |
|
clrpart(si->spt); |
| 138 |
|
setpart(si->spt, 0, S0); |
| 140 |
|
} |
| 141 |
|
|
| 142 |
|
|
| 143 |
< |
cylpart(si, ro) /* partition a cylinder */ |
| 143 |
> |
cylpart(si, r) /* partition a cylinder */ |
| 144 |
|
SRCINDEX *si; |
| 145 |
< |
FVECT ro; |
| 145 |
> |
register RAY *r; |
| 146 |
|
{ |
| 147 |
|
double dist2, safedist2, dist2cent, rad2; |
| 148 |
|
FVECT v; |
| 150 |
|
int pi; |
| 151 |
|
/* first check point location */ |
| 152 |
|
clrpart(si->spt); |
| 153 |
< |
sp = &source[si->sn]; |
| 153 |
> |
sp = source + si->sn; |
| 154 |
|
rad2 = 1.365 * DOT(sp->ss[SV],sp->ss[SV]); |
| 155 |
< |
v[0] = ro[0] - sp->sloc[0]; |
| 156 |
< |
v[1] = ro[1] - sp->sloc[1]; |
| 157 |
< |
v[2] = ro[2] - sp->sloc[2]; |
| 155 |
> |
v[0] = r->rorg[0] - sp->sloc[0]; |
| 156 |
> |
v[1] = r->rorg[1] - sp->sloc[1]; |
| 157 |
> |
v[2] = r->rorg[2] - sp->sloc[2]; |
| 158 |
|
dist2 = DOT(v,sp->ss[SU]); |
| 159 |
|
safedist2 = DOT(sp->ss[SU],sp->ss[SU]); |
| 160 |
|
dist2 *= dist2 / safedist2; |
| 164 |
|
si->np = 0; |
| 165 |
|
return; |
| 166 |
|
} |
| 167 |
< |
safedist2 *= 4./(srcsizerat*srcsizerat); |
| 167 |
> |
safedist2 *= 4.*r->rweight*r->rweight/(srcsizerat*srcsizerat); |
| 168 |
|
if (dist2 <= 4.*rad2 || /* point too close to subdivide? */ |
| 169 |
< |
dist2cent >= safedist2) { |
| 169 |
> |
dist2cent >= safedist2) { /* too far? */ |
| 170 |
|
setpart(si->spt, 0, S0); |
| 171 |
|
si->np = 1; |
| 172 |
|
return; |
| 173 |
|
} |
| 174 |
|
pi = 0; |
| 175 |
< |
si->np = cyl_partit(ro, si->spt, &pi, MAXSPART, |
| 175 |
> |
si->np = cyl_partit(r->rorg, si->spt, &pi, MAXSPART, |
| 176 |
|
sp->sloc, sp->ss[SU], safedist2); |
| 177 |
|
} |
| 178 |
|
|
| 216 |
|
} |
| 217 |
|
|
| 218 |
|
|
| 219 |
< |
flatpart(si, ro) /* partition a flat source */ |
| 219 |
> |
flatpart(si, r) /* partition a flat source */ |
| 220 |
|
register SRCINDEX *si; |
| 221 |
< |
FVECT ro; |
| 221 |
> |
RAY *r; |
| 222 |
|
{ |
| 223 |
|
register double *vp; |
| 224 |
|
double du2, dv2; |
| 225 |
|
int pi; |
| 226 |
|
|
| 227 |
+ |
dv2 = 2.*r->rweight/srcsizerat; |
| 228 |
+ |
dv2 *= dv2; |
| 229 |
|
vp = source[si->sn].ss[SU]; |
| 230 |
< |
du2 = 4./(srcsizerat*srcsizerat) * DOT(vp,vp); |
| 230 |
> |
du2 = dv2 * DOT(vp,vp); |
| 231 |
|
vp = source[si->sn].ss[SV]; |
| 232 |
< |
dv2 = 4./(srcsizerat*srcsizerat) * DOT(vp,vp); |
| 232 |
> |
dv2 *= DOT(vp,vp); |
| 233 |
|
clrpart(si->spt); |
| 234 |
|
pi = 0; |
| 235 |
< |
si->np = flt_partit(ro, si->spt, &pi, MAXSPART, source[si->sn].sloc, |
| 235 |
> |
si->np = flt_partit(r->rorg, si->spt, &pi, MAXSPART, |
| 236 |
> |
source[si->sn].sloc, |
| 237 |
|
source[si->sn].ss[SU], source[si->sn].ss[SV], du2, dv2); |
| 238 |
|
} |
| 239 |
|
|
