ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/srcsamp.c
(Generate patch)

Comparing ray/src/rt/srcsamp.c (file contents):
Revision 1.4 by greg, Tue Oct 22 15:45:21 1991 UTC vs.
Revision 2.6 by greg, Wed Jul 20 12:48:44 1994 UTC

# Line 15 | Line 15 | static char SCCSid[] = "$SunId$ LBL";
15   #include  "random.h"
16  
17  
18 + static int  cyl_partit(), flt_partit();
19 +
20 +
21   double
22   nextssamp(r, si)                /* compute sample for source, rtn. distance */
23   register RAY  *r;               /* origin is read, direction is set */
# Line 24 | Line 27 | register SRCINDEX  *si;                /* source index (modified to
27          FVECT  vpos;
28          double  d;
29          register int  i;
30 < tryagain:
30 > nextsample:
31          while (++si->sp >= si->np) {    /* get next sample */
32                  if (++si->sn >= nsources)
33                          return(0.0);    /* no more */
34 <                if (srcsizerat <= FTINY)
34 >                if (source[si->sn].sflags & SSKIP)
35 >                        si->np = 0;
36 >                else if (srcsizerat <= FTINY)
37                          nopart(si, r);
38                  else {
39                          for (i = si->sn; source[i].sflags & SVIRTUAL;
# Line 74 | Line 79 | tryagain:
79                          r->rdir[i] -= r->rorg[i];
80                                          /* compute distance */
81          if ((d = normalize(r->rdir)) == 0.0)
82 <                goto tryagain;  /* at source! */
82 >                goto nextsample;                /* at source! */
83  
84                                          /* compute sample size */
80 –        si->dom  = source[si->sn].ss2;
85          if (source[si->sn].sflags & SFLAT) {
86 <                si->dom *= sflatform(si->sn, r->rdir);
87 <                if (si->dom <= FTINY) {         /* behind source */
84 <                        si->np = 0;
85 <                        goto tryagain;
86 <                }
87 <                si->dom *= (double)(size[SU]*size[SV])/(MAXSPART*MAXSPART);
86 >                si->dom = sflatform(si->sn, r->rdir);
87 >                si->dom *= size[SU]*size[SV]/(MAXSPART*(double)MAXSPART);
88          } else if (source[si->sn].sflags & SCYL) {
89 <                si->dom *= scylform(si->sn, r->rdir);
90 <                si->dom *= (double)size[SU]/MAXSPART;
89 >                si->dom = scylform(si->sn, r->rdir);
90 >                si->dom *= size[SU]/(double)MAXSPART;
91          } else {
92 <                si->dom *= (double)(size[SU]*size[SV]*size[SW]) /
93 <                                (MAXSPART*MAXSPART*MAXSPART) ;
92 >                si->dom = size[SU]*size[SV]*(double)size[SW] /
93 >                                (MAXSPART*MAXSPART*(double)MAXSPART) ;
94          }
95 <        if (source[si->sn].sflags & SDISTANT)
95 >        if (source[si->sn].sflags & SDISTANT) {
96 >                si->dom *= source[si->sn].ss2;
97                  return(FHUGE);
98 <        si->dom /= d*d;
98 >        }
99 >        if (si->dom <= 1e-4)
100 >                goto nextsample;                /* behind source? */
101 >        si->dom *= source[si->sn].ss2/(d*d);
102          return(d);              /* sample OK, return distance */
103   }
104  
# Line 165 | Line 169 | register RAY  *r;
169                  return;
170          }
171          safedist2 *= 4.*r->rweight*r->rweight/(srcsizerat*srcsizerat);
172 <        if (dist2 <= 4.*rad2 ||         /* point too close to subdivide? */
173 <                        dist2cent >= safedist2) {       /* too far? */
172 >        if (dist2 <= 4.*rad2 ||         /* point too close to subdivide */
173 >                        dist2cent >= safedist2) {       /* or too far */
174                  setpart(si->spt, 0, S0);
175                  si->np = 1;
176                  return;
# Line 218 | Line 222 | double  d2;
222  
223   flatpart(si, r)                         /* partition a flat source */
224   register SRCINDEX  *si;
225 < RAY  *r;
225 > register RAY  *r;
226   {
227 <        register double  *vp;
227 >        register FLOAT  *vp;
228 >        FVECT  v;
229          double  du2, dv2;
230          int  pi;
231  
232 +        clrpart(si->spt);
233 +        vp = source[si->sn].sloc;
234 +        v[0] = r->rorg[0] - vp[0];
235 +        v[1] = r->rorg[1] - vp[1];
236 +        v[2] = r->rorg[2] - vp[2];
237 +        vp = source[si->sn].snorm;
238 +        if (DOT(v,vp) <= FTINY) {       /* behind source */
239 +                si->np = 0;
240 +                return;
241 +        }
242          dv2 = 2.*r->rweight/srcsizerat;
243          dv2 *= dv2;
244          vp = source[si->sn].ss[SU];
245          du2 = dv2 * DOT(vp,vp);
246          vp = source[si->sn].ss[SV];
247          dv2 *= DOT(vp,vp);
233 –        clrpart(si->spt);
248          pi = 0;
249          si->np = flt_partit(r->rorg, si->spt, &pi, MAXSPART,
250                  source[si->sn].sloc,
# Line 294 | Line 308 | scylform(sn, dir)              /* compute cosine for cylinder's pr
308   int  sn;
309   register FVECT  dir;            /* assume normalized */
310   {
311 <        register double  *dv;
311 >        register FLOAT  *dv;
312          double  d;
313  
314          dv = source[sn].ss[SU];

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines