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

Comparing ray/src/rt/raytrace.c (file contents):
Revision 1.2 by greg, Tue Apr 11 13:30:31 1989 UTC vs.
Revision 2.67 by greg, Thu May 21 15:28:24 2015 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 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   *  raytrace.c - routines for tracing and shading rays.
6   *
7 < *     8/7/85
7 > *  External symbols declared in ray.h
8   */
9  
10 < #include  "ray.h"
10 > #include "copyright.h"
11  
12 < #include  "octree.h"
13 <
12 > #include  "ray.h"
13 > #include  "source.h"
14   #include  "otypes.h"
15 + #include  "otspecial.h"
16 + #include  "random.h"
17 + #include  "pmap.h"
18  
19 < extern CUBE  thescene;                  /* our scene */
20 < extern int  maxdepth;                   /* maximum recursion depth */
21 < extern double  minweight;               /* minimum ray weight */
19 > #define  MAXCSET        ((MAXSET+1)*2-1)        /* maximum check set size */
20  
21 < long  nrays = 0L;                       /* number of rays traced */
21 > RNUMBER  raynum = 0;            /* next unique ray number */
22 > RNUMBER  nrays = 0;             /* number of calls to localhit */
23  
24 < #define  MAXLOOP        32              /* modifier loop detection */
24 > static RREAL  Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
25 > OBJREC  Lamb = {
26 >        OVOID, MAT_PLASTIC, "Lambertian",
27 >        {NULL, Lambfa, 0, 5}, NULL
28 > };                                      /* a Lambertian surface */
29  
30 + OBJREC  Aftplane;                       /* aft clipping plane object */
31 +
32   #define  RAYHIT         (-1)            /* return value for intercepted ray */
33  
34 + static int raymove(FVECT  pos, OBJECT  *cxs, int  dirf, RAY  *r, CUBE  *cu);
35 + static int checkhit(RAY  *r, CUBE  *cu, OBJECT  *cxs);
36 + static void checkset(OBJECT  *os, OBJECT  *cs);
37  
38 < rayorigin(r, ro, rt, rw)                /* start new ray from old one */
39 < register RAY  *r, *ro;
40 < int  rt;
41 < double  rw;
38 >
39 > int
40 > rayorigin(              /* start new ray from old one */
41 >        RAY  *r,
42 >        int  rt,
43 >        const RAY  *ro,
44 >        const COLOR rc
45 > )
46   {
47 +        double  rw, re;
48 +                                                /* assign coefficient/weight */
49 +        if (rc == NULL) {
50 +                rw = 1.0;
51 +                setcolor(r->rcoef, 1., 1., 1.);
52 +        } else {
53 +                rw = intens(rc);
54 +                if (rc != r->rcoef)
55 +                        copycolor(r->rcoef, rc);
56 +        }
57          if ((r->parent = ro) == NULL) {         /* primary ray */
58                  r->rlvl = 0;
59                  r->rweight = rw;
60                  r->crtype = r->rtype = rt;
61                  r->rsrc = -1;
62                  r->clipset = NULL;
63 +                r->revf = raytrace;
64 +                copycolor(r->cext, cextinction);
65 +                copycolor(r->albedo, salbedo);
66 +                r->gecc = seccg;
67 +                r->slights = NULL;
68          } else {                                /* spawned ray */
69 +                if (ro->rot >= FHUGE) {
70 +                        memset(r, 0, sizeof(RAY));
71 +                        return(-1);             /* illegal continuation */
72 +                }
73                  r->rlvl = ro->rlvl;
74                  if (rt & RAYREFL) {
75                          r->rlvl++;
76                          r->rsrc = -1;
77                          r->clipset = ro->clipset;
78 +                        r->rmax = 0.0;
79                  } else {
80                          r->rsrc = ro->rsrc;
81                          r->clipset = ro->newcset;
82 +                        r->rmax = ro->rmax <= FTINY ? 0.0 : ro->rmax - ro->rot;
83                  }
84 <                r->rweight = ro->rweight * rw;
84 >                r->revf = ro->revf;
85 >                copycolor(r->cext, ro->cext);
86 >                copycolor(r->albedo, ro->albedo);
87 >                r->gecc = ro->gecc;
88 >                r->slights = ro->slights;
89                  r->crtype = ro->crtype | (r->rtype = rt);
90                  VCOPY(r->rorg, ro->rop);
91 +                r->rweight = ro->rweight * rw;
92 +                                                /* estimate extinction */
93 +                re = colval(ro->cext,RED) < colval(ro->cext,GRN) ?
94 +                                colval(ro->cext,RED) : colval(ro->cext,GRN);
95 +                if (colval(ro->cext,BLU) < re) re = colval(ro->cext,BLU);
96 +                re *= ro->rot;
97 +                if (re > 0.1) {
98 +                        if (re > 92.) {
99 +                                r->rweight = 0.0;
100 +                        } else {
101 +                                r->rweight *= exp(-re);
102 +                        }
103 +                }
104          }
105 <        r->rno = nrays;
105 >        rayclear(r);
106 >        if (r->rweight <= 0.0)                  /* check for expiration */
107 >                return(-1);
108 >        if (r->crtype & SHADOW)                 /* shadow commitment */
109 >                return(0);
110 >                                                /* ambient in photon map? */
111 >        if (r->crtype & AMBIENT && photonMapping)
112 >                return(-1);
113 >        if (maxdepth <= 0 && rc != NULL) {      /* Russian roulette */
114 >                if (minweight <= 0.0)
115 >                        error(USER, "zero ray weight in Russian roulette");
116 >                if (maxdepth < 0 && r->rlvl > -maxdepth)
117 >                        return(-1);             /* upper reflection limit */
118 >                if (r->rweight >= minweight)
119 >                        return(0);
120 >                if (frandom() > r->rweight/minweight)
121 >                        return(-1);
122 >                rw = minweight/r->rweight;      /* promote survivor */
123 >                scalecolor(r->rcoef, rw);
124 >                r->rweight = minweight;
125 >                return(0);
126 >        }
127 >        return(r->rweight >= minweight && r->rlvl <= abs(maxdepth) ? 0 : -1);
128 > }
129 >
130 >
131 > void
132 > rayclear(                       /* clear a ray for (re)evaluation */
133 >        RAY  *r
134 > )
135 > {
136 >        r->rno = raynum++;
137          r->newcset = r->clipset;
138 +        r->hitf = rayhit;
139 +        r->robj = OVOID;
140          r->ro = NULL;
141 <        r->rot = FHUGE;
142 <        r->rofs = 1.0; setident4(r->rofx);
60 <        r->robs = 1.0; setident4(r->robx);
141 >        r->rox = NULL;
142 >        r->rt = r->rot = FHUGE;
143          r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
144 +        r->uv[0] = r->uv[1] = 0.0;
145          setcolor(r->pcol, 1.0, 1.0, 1.0);
146          setcolor(r->rcol, 0.0, 0.0, 0.0);
64 –        return(r->rlvl <= maxdepth && r->rweight >= minweight ? 0 : -1);
147   }
148  
149  
150 < rayvalue(r)                     /* compute a ray's value */
151 < register RAY  *r;
150 > void
151 > raytrace(                       /* trace a ray and compute its value */
152 >        RAY  *r
153 > )
154   {
71 –        extern int  (*trace)();
72 –
155          if (localhit(r, &thescene))
156 <                if (r->clipset != NULL && inset(r->clipset, r->ro->omod))
157 <                        raytrans(r);            /* object is clipped */
158 <                else
159 <                        rayshade(r, r->ro->omod);
160 <        else if (sourcehit(r))
161 <                rayshade(r, r->ro->omod);
156 >                raycont(r);             /* hit local surface, evaluate */
157 >        else if (r->ro == &Aftplane) {
158 >                r->ro = NULL;           /* hit aft clipping plane */
159 >                r->rot = FHUGE;
160 >        } else if (sourcehit(r))
161 >                rayshade(r, r->ro->omod);       /* distant source */
162  
163          if (trace != NULL)
164                  (*trace)(r);            /* trace execution */
165 +
166 +        rayparticipate(r);              /* for participating medium */
167   }
168  
169  
170 < raytrans(r)                     /* transmit ray as is */
171 < RAY  *r;
170 > void
171 > raycont(                        /* check for clipped object and continue */
172 >        RAY  *r
173 > )
174   {
175 +        if ((r->clipset != NULL && inset(r->clipset, r->ro->omod)) ||
176 +                        !rayshade(r, r->ro->omod))
177 +                raytrans(r);
178 + }
179 +
180 +
181 + void
182 + raytrans(                       /* transmit ray as is */
183 +        RAY  *r
184 + )
185 + {
186          RAY  tr;
187  
188 <        if (rayorigin(&tr, r, TRANS, 1.0) == 0) {
189 <                VCOPY(tr.rdir, r->rdir);
190 <                rayvalue(&tr);
191 <                copycolor(r->rcol, tr.rcol);
192 <        }
188 >        rayorigin(&tr, TRANS, r, NULL);         /* always continue */
189 >        VCOPY(tr.rdir, r->rdir);
190 >        rayvalue(&tr);
191 >        copycolor(r->rcol, tr.rcol);
192 >        r->rt = r->rot + tr.rt;
193   }
194  
195  
196 < rayshade(r, mod)                /* shade ray r with material mod */
197 < register RAY  *r;
198 < int  mod;
196 > int
197 > rayshade(               /* shade ray r with material mod */
198 >        RAY  *r,
199 >        int  mod
200 > )
201   {
202 <        static int  depth = 0;
203 <        register OBJREC  *m;
204 <                                        /* check for infinite loop */
106 <        if (depth++ >= MAXLOOP)
107 <                objerror(r->ro, USER, "material loop");
202 >        OBJREC  *m;
203 >
204 >        r->rt = r->rot;                 /* set effective ray length */
205          for ( ; mod != OVOID; mod = m->omod) {
206                  m = objptr(mod);
207 +                /****** unnecessary test since modifier() is always called
208                  if (!ismodifier(m->otype)) {
209                          sprintf(errmsg, "illegal modifier \"%s\"", m->oname);
210                          error(USER, errmsg);
211                  }
212 <                (*ofun[m->otype].funp)(m, r);   /* execute function */
213 <                m->lastrno = r->rno;
214 <                if (ismaterial(m->otype)) {     /* materials call raytexture */
215 <                        depth--;
216 <                        return;         /* we're done */
212 >                ******/
213 >                                        /* hack for irradiance calculation */
214 >                if (do_irrad && !(r->crtype & ~(PRIMARY|TRANS)) &&
215 >                                m->otype != MAT_CLIP &&
216 >                                (ofun[m->otype].flags & (T_M|T_X))) {
217 >                        if (irr_ignore(m->otype)) {
218 >                                raytrans(r);
219 >                                return(1);
220 >                        }
221 >                        if (!islight(m->otype))
222 >                                m = &Lamb;
223                  }
224 +                if ((*ofun[m->otype].funp)(m, r))
225 +                        return(1);      /* materials call raytexture() */
226          }
227 <        objerror(r->ro, USER, "material not found");
227 >        return(0);                      /* no material! */
228   }
229  
230  
231 < raytexture(r, mod)                      /* get material modifiers */
232 < RAY  *r;
233 < int  mod;
231 > void
232 > rayparticipate(                 /* compute ray medium participation */
233 >        RAY  *r
234 > )
235   {
236 <        static int  depth = 0;
237 <        register OBJREC  *m;
238 <                                        /* check for infinite loop */
239 <        if (depth++ >= MAXLOOP)
240 <                objerror(r->ro, USER, "modifier loop");
236 >        COLOR   ce, ca;
237 >        double  re, ge, be;
238 >
239 >        if (intens(r->cext) <= 1./FHUGE)
240 >                return;                         /* no medium */
241 >        re = r->rot*colval(r->cext,RED);
242 >        ge = r->rot*colval(r->cext,GRN);
243 >        be = r->rot*colval(r->cext,BLU);
244 >        if (r->crtype & SHADOW) {               /* no scattering for sources */
245 >                re *= 1. - colval(r->albedo,RED);
246 >                ge *= 1. - colval(r->albedo,GRN);
247 >                be *= 1. - colval(r->albedo,BLU);
248 >        }
249 >        setcolor(ce,    re<=FTINY ? 1. : re>92. ? 0. : exp(-re),
250 >                        ge<=FTINY ? 1. : ge>92. ? 0. : exp(-ge),
251 >                        be<=FTINY ? 1. : be>92. ? 0. : exp(-be));
252 >        multcolor(r->rcol, ce);                 /* path extinction */
253 >        if (r->crtype & SHADOW || intens(r->albedo) <= FTINY)
254 >                return;                         /* no scattering */
255 >        
256 >        /* PMAP: indirect inscattering accounted for by volume photons? */
257 >        if (!volumePhotonMapping) {
258 >                setcolor(ca,
259 >                        colval(r->albedo,RED)*colval(ambval,RED)*(1.-colval(ce,RED)),
260 >                        colval(r->albedo,GRN)*colval(ambval,GRN)*(1.-colval(ce,GRN)),
261 >                        colval(r->albedo,BLU)*colval(ambval,BLU)*(1.-colval(ce,BLU)));
262 >                addcolor(r->rcol, ca);                  /* ambient in scattering */
263 >        }
264 >        
265 >        srcscatter(r);                          /* source in scattering */
266 > }
267 >
268 >
269 > void
270 > raytexture(                     /* get material modifiers */
271 >        RAY  *r,
272 >        OBJECT  mod
273 > )
274 > {
275 >        OBJREC  *m;
276                                          /* execute textures and patterns */
277          for ( ; mod != OVOID; mod = m->omod) {
278                  m = objptr(mod);
279 <                if (!istexture(m->otype)) {
279 >                /****** unnecessary test since modifier() is always called
280 >                if (!ismodifier(m->otype)) {
281                          sprintf(errmsg, "illegal modifier \"%s\"", m->oname);
282                          error(USER, errmsg);
283                  }
284 <                (*ofun[m->otype].funp)(m, r);
285 <                m->lastrno = r->rno;
284 >                ******/
285 >                if ((*ofun[m->otype].funp)(m, r)) {
286 >                        sprintf(errmsg, "conflicting material \"%s\"",
287 >                                        m->oname);
288 >                        objerror(r->ro, USER, errmsg);
289 >                }
290          }
144 –        depth--;                        /* end here */
291   }
292  
293  
294 < raymixture(r, fore, back, coef)         /* mix modifiers */
295 < register RAY  *r;
296 < OBJECT  fore, back;
297 < double  coef;
294 > int
295 > raymixture(             /* mix modifiers */
296 >        RAY  *r,
297 >        OBJECT  fore,
298 >        OBJECT  back,
299 >        double  coef
300 > )
301   {
302 <        FVECT  curpert, forepert, backpert;
303 <        COLOR  curpcol, forepcol, backpcol;
304 <        register int  i;
305 <                                        /* clip coefficient */
302 >        RAY  fr, br;
303 >        int  foremat, backmat;
304 >        int  i;
305 >                                        /* bound coefficient */
306          if (coef > 1.0)
307                  coef = 1.0;
308          else if (coef < 0.0)
309                  coef = 0.0;
310 <                                        /* save current mods */
311 <        VCOPY(curpert, r->pert);
312 <        copycolor(curpcol, r->pcol);
313 <                                        /* compute new mods */
314 <                                                /* foreground */
315 <        r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
316 <        setcolor(r->pcol, 1.0, 1.0, 1.0);
317 <        if (fore != OVOID && coef > FTINY)
318 <                raytexture(r, fore);
319 <        VCOPY(forepert, r->pert);
320 <        copycolor(forepcol, r->pcol);
321 <                                                /* background */
322 <        r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
323 <        setcolor(r->pcol, 1.0, 1.0, 1.0);
324 <        if (back != OVOID && coef < 1.0-FTINY)
325 <                raytexture(r, back);
326 <        VCOPY(backpert, r->pert);
327 <        copycolor(backpcol, r->pcol);
328 <                                        /* sum perturbations */
310 >                                        /* compute foreground and background */
311 >        foremat = backmat = 0;
312 >                                        /* foreground */
313 >        fr = *r;
314 >        if (coef > FTINY) {
315 >                fr.rweight *= coef;
316 >                scalecolor(fr.rcoef, coef);
317 >                foremat = rayshade(&fr, fore);
318 >        }
319 >                                        /* background */
320 >        br = *r;
321 >        if (coef < 1.0-FTINY) {
322 >                br.rweight *= 1.0-coef;
323 >                scalecolor(br.rcoef, 1.0-coef);
324 >                backmat = rayshade(&br, back);
325 >        }
326 >                                        /* check for transparency */
327 >        if (backmat ^ foremat) {
328 >                if (backmat && coef > FTINY)
329 >                        raytrans(&fr);
330 >                else if (foremat && coef < 1.0-FTINY)
331 >                        raytrans(&br);
332 >        }
333 >                                        /* mix perturbations */
334          for (i = 0; i < 3; i++)
335 <                r->pert[i] = curpert[i] + coef*forepert[i] +
336 <                                (1.0-coef)*backpert[i];
337 <                                        /* multiply colors */
338 <        setcolor(r->pcol, coef*colval(forepcol,RED) +
339 <                                (1.0-coef)*colval(backpcol,RED),
340 <                        coef*colval(forepcol,GRN) +
341 <                                (1.0-coef)*colval(backpcol,GRN),
342 <                        coef*colval(forepcol,BLU) +
343 <                                (1.0-coef)*colval(backpcol,BLU));
344 <        multcolor(r->pcol, curpcol);
335 >                r->pert[i] = coef*fr.pert[i] + (1.0-coef)*br.pert[i];
336 >                                        /* mix pattern colors */
337 >        scalecolor(fr.pcol, coef);
338 >        scalecolor(br.pcol, 1.0-coef);
339 >        copycolor(r->pcol, fr.pcol);
340 >        addcolor(r->pcol, br.pcol);
341 >                                        /* return value tells if material */
342 >        if (!foremat & !backmat)
343 >                return(0);
344 >                                        /* mix returned ray values */
345 >        scalecolor(fr.rcol, coef);
346 >        scalecolor(br.rcol, 1.0-coef);
347 >        copycolor(r->rcol, fr.rcol);
348 >        addcolor(r->rcol, br.rcol);
349 >        r->rt = bright(fr.rcol) > bright(br.rcol) ? fr.rt : br.rt;
350 >        return(1);
351   }
352  
353  
354   double
355 < raynormal(norm, r)              /* compute perturbed normal for ray */
356 < FVECT  norm;
357 < register RAY  *r;
355 > raydist(                /* compute (cumulative) ray distance */
356 >        const RAY  *r,
357 >        int  flags
358 > )
359   {
360 +        double  sum = 0.0;
361 +
362 +        while (r != NULL && r->crtype&flags) {
363 +                sum += r->rot;
364 +                r = r->parent;
365 +        }
366 +        return(sum);
367 + }
368 +
369 +
370 + void
371 + raycontrib(             /* compute (cumulative) ray contribution */
372 +        RREAL  rc[3],
373 +        const RAY  *r,
374 +        int  flags
375 + )
376 + {
377 +        double  eext[3];
378 +        int     i;
379 +
380 +        eext[0] = eext[1] = eext[2] = 0.;
381 +        rc[0] = rc[1] = rc[2] = 1.;
382 +
383 +        while (r != NULL && r->crtype&flags) {
384 +                for (i = 3; i--; ) {
385 +                        rc[i] *= colval(r->rcoef,i);
386 +                        eext[i] += r->rot * colval(r->cext,i);
387 +                }
388 +                r = r->parent;
389 +        }
390 +        for (i = 3; i--; )
391 +                rc[i] *= (eext[i] <= FTINY) ? 1. :
392 +                                (eext[i] > 92.) ? 0. : exp(-eext[i]);
393 + }
394 +
395 +
396 + double
397 + raynormal(              /* compute perturbed normal for ray */
398 +        FVECT  norm,
399 +        RAY  *r
400 + )
401 + {
402          double  newdot;
403 <        register int  i;
403 >        int  i;
404  
405          /*      The perturbation is added to the surface normal to obtain
406           *  the new normal.  If the new normal would affect the surface
# Line 205 | Line 408 | register RAY  *r;
408           *  still fraught with problems since reflected rays and similar
409           *  directions calculated from the surface normal may spawn rays behind
410           *  the surface.  The only solution is to curb textures at high
411 <         *  incidence (Rdot << 1).
411 >         *  incidence (namely, keep DOT(rdir,pert) < Rdot).
412           */
413  
414          for (i = 0; i < 3; i++)
# Line 226 | Line 429 | register RAY  *r;
429   }
430  
431  
432 < flipsurface(r)                  /* reverse surface orientation */
433 < register RAY  *r;
432 > void
433 > newrayxf(                       /* get new tranformation matrix for ray */
434 >        RAY  *r
435 > )
436   {
437 +        static struct xfn {
438 +                struct xfn  *next;
439 +                FULLXF  xf;
440 +        }  xfseed = { &xfseed }, *xflast = &xfseed;
441 +        struct xfn  *xp;
442 +        const RAY  *rp;
443 +
444 +        /*
445 +         * Search for transform in circular list that
446 +         * has no associated ray in the tree.
447 +         */
448 +        xp = xflast;
449 +        for (rp = r->parent; rp != NULL; rp = rp->parent)
450 +                if (rp->rox == &xp->xf) {               /* xp in use */
451 +                        xp = xp->next;                  /* move to next */
452 +                        if (xp == xflast) {             /* need new one */
453 +                                xp = (struct xfn *)bmalloc(sizeof(struct xfn));
454 +                                if (xp == NULL)
455 +                                        error(SYSTEM,
456 +                                                "out of memory in newrayxf");
457 +                                                        /* insert in list */
458 +                                xp->next = xflast->next;
459 +                                xflast->next = xp;
460 +                                break;                  /* we're done */
461 +                        }
462 +                        rp = r;                 /* start check over */
463 +                }
464 +                                        /* got it */
465 +        r->rox = &xp->xf;
466 +        xflast = xp;
467 + }
468 +
469 +
470 + void
471 + flipsurface(                    /* reverse surface orientation */
472 +        RAY  *r
473 + )
474 + {
475          r->rod = -r->rod;
476          r->ron[0] = -r->ron[0];
477          r->ron[1] = -r->ron[1];
# Line 239 | Line 482 | register RAY  *r;
482   }
483  
484  
485 < localhit(r, scene)              /* check for hit in the octree */
486 < register RAY  *r;
487 < register CUBE  *scene;
485 > void
486 > rayhit(                 /* standard ray hit test */
487 >        OBJECT  *oset,
488 >        RAY  *r
489 > )
490   {
491 +        OBJREC  *o;
492 +        int     i;
493 +
494 +        for (i = oset[0]; i > 0; i--) {
495 +                o = objptr(oset[i]);
496 +                if ((*ofun[o->otype].funp)(o, r))
497 +                        r->robj = oset[i];
498 +        }
499 + }
500 +
501 +
502 + int
503 + localhit(               /* check for hit in the octree */
504 +        RAY  *r,
505 +        CUBE  *scene
506 + )
507 + {
508 +        OBJECT  cxset[MAXCSET+1];       /* set of checked objects */
509          FVECT  curpos;                  /* current cube position */
510 <        int  mpos, mneg;                /* sign flags */
510 >        int  sflags;                    /* sign flags */
511          double  t, dt;
512 <        register int  i;
512 >        int  i;
513  
514          nrays++;                        /* increment trace counter */
515 <
253 <        mpos = mneg = 0;
515 >        sflags = 0;
516          for (i = 0; i < 3; i++) {
517                  curpos[i] = r->rorg[i];
518 <                if (r->rdir[i] > FTINY)
519 <                        mpos |= 1 << i;
520 <                else if (r->rdir[i] < -FTINY)
521 <                        mneg |= 1 << i;
518 >                if (r->rdir[i] > 1e-7)
519 >                        sflags |= 1 << i;
520 >                else if (r->rdir[i] < -1e-7)
521 >                        sflags |= 0x10 << i;
522          }
523 +        if (!sflags) {
524 +                error(WARNING, "zero ray direction in localhit");
525 +                return(0);
526 +        }
527 +                                        /* start off assuming nothing hit */
528 +        if (r->rmax > FTINY) {          /* except aft plane if one */
529 +                r->ro = &Aftplane;
530 +                r->rot = r->rmax;
531 +                VSUM(r->rop, r->rorg, r->rdir, r->rot);
532 +        }
533 +                                        /* find global cube entrance point */
534          t = 0.0;
535          if (!incube(scene, curpos)) {
536                                          /* find distance to entry */
537                  for (i = 0; i < 3; i++) {
538                                          /* plane in our direction */
539 <                        if (mpos & 1<<i)
539 >                        if (sflags & 1<<i)
540                                  dt = scene->cuorg[i];
541 <                        else if (mneg & 1<<i)
541 >                        else if (sflags & 0x10<<i)
542                                  dt = scene->cuorg[i] + scene->cusize;
543                          else
544                                  continue;
# Line 275 | Line 548 | register CUBE  *scene;
548                                  t = dt; /* farthest face is the one */
549                  }
550                  t += FTINY;             /* fudge to get inside cube */
551 +                if (t >= r->rot)        /* clipped already */
552 +                        return(0);
553                                          /* advance position */
554 <                for (i = 0; i < 3; i++)
280 <                        curpos[i] += r->rdir[i]*t;
554 >                VSUM(curpos, curpos, r->rdir, t);
555  
556                  if (!incube(scene, curpos))     /* non-intersecting ray */
557                          return(0);
558          }
559 <        return(raymove(curpos, mpos, mneg, r, scene) == RAYHIT);
559 >        cxset[0] = 0;
560 >        raymove(curpos, cxset, sflags, r, scene);
561 >        return((r->ro != NULL) & (r->ro != &Aftplane));
562   }
563  
564  
565   static int
566 < raymove(pos, plus, minus, r, cu)        /* check for hit as we move */
567 < FVECT  pos;                     /* modified */
568 < int  plus, minus;               /* direction indicators to speed tests */
569 < register RAY  *r;
570 < register CUBE  *cu;
566 > raymove(                /* check for hit as we move */
567 >        FVECT  pos,                     /* current position, modified herein */
568 >        OBJECT  *cxs,                   /* checked objects, modified by checkhit */
569 >        int  dirf,                      /* direction indicators to speed tests */
570 >        RAY  *r,
571 >        CUBE  *cu
572 > )
573   {
574          int  ax;
575          double  dt, t;
298 –        register int  sgn;
576  
577          if (istree(cu->cutree)) {               /* recurse on subcubes */
578                  CUBE  cukid;
579 <                register int  br;
579 >                int  br, sgn;
580  
581                  cukid.cusize = cu->cusize * 0.5;        /* find subcube */
582                  VCOPY(cukid.cuorg, cu->cuorg);
# Line 318 | Line 595 | register CUBE  *cu;
595                  }
596                  for ( ; ; ) {
597                          cukid.cutree = octkid(cu->cutree, br);
598 <                        if ((ax = raymove(pos,plus,minus,r,&cukid)) == RAYHIT)
598 >                        if ((ax = raymove(pos,cxs,dirf,r,&cukid)) == RAYHIT)
599                                  return(RAYHIT);
600                          sgn = 1 << ax;
601 <                        if (sgn & minus)                /* negative axis? */
325 <                                if (sgn & br) {
326 <                                        cukid.cuorg[ax] -= cukid.cusize;
327 <                                        br &= ~sgn;
328 <                                } else
329 <                                        return(ax);     /* underflow */
330 <                        else
601 >                        if (sgn & dirf)                 /* positive axis? */
602                                  if (sgn & br)
603                                          return(ax);     /* overflow */
604                                  else {
605                                          cukid.cuorg[ax] += cukid.cusize;
606                                          br |= sgn;
607                                  }
608 +                        else
609 +                                if (sgn & br) {
610 +                                        cukid.cuorg[ax] -= cukid.cusize;
611 +                                        br &= ~sgn;
612 +                                } else
613 +                                        return(ax);     /* underflow */
614                  }
615                  /*NOTREACHED*/
616          }
617 <        if (isfull(cu->cutree) && checkhit(r, cu))
617 >        if (isfull(cu->cutree)) {
618 >                if (checkhit(r, cu, cxs))
619 >                        return(RAYHIT);
620 >        } else if (r->ro == &Aftplane && incube(cu, r->rop))
621                  return(RAYHIT);
622                                          /* advance to next cube */
623 <        sgn = plus | minus;
624 <        if (sgn&1) {
345 <                dt = plus&1 ? cu->cuorg[0] + cu->cusize : cu->cuorg[0];
623 >        if (dirf&0x11) {
624 >                dt = dirf&1 ? cu->cuorg[0] + cu->cusize : cu->cuorg[0];
625                  t = (dt - pos[0])/r->rdir[0];
626                  ax = 0;
627          } else
628                  t = FHUGE;
629 <        if (sgn&2) {
630 <                dt = plus&2 ? cu->cuorg[1] + cu->cusize : cu->cuorg[1];
629 >        if (dirf&0x22) {
630 >                dt = dirf&2 ? cu->cuorg[1] + cu->cusize : cu->cuorg[1];
631                  dt = (dt - pos[1])/r->rdir[1];
632                  if (dt < t) {
633                          t = dt;
634                          ax = 1;
635                  }
636          }
637 <        if (sgn&4) {
638 <                dt = plus&4 ? cu->cuorg[2] + cu->cusize : cu->cuorg[2];
637 >        if (dirf&0x44) {
638 >                dt = dirf&4 ? cu->cuorg[2] + cu->cusize : cu->cuorg[2];
639                  dt = (dt - pos[2])/r->rdir[2];
640                  if (dt < t) {
641                          t = dt;
642                          ax = 2;
643                  }
644          }
645 <        pos[0] += r->rdir[0]*t;
367 <        pos[1] += r->rdir[1]*t;
368 <        pos[2] += r->rdir[2]*t;
645 >        VSUM(pos, pos, r->rdir, t);
646          return(ax);
647   }
648  
649  
650 < static
651 < checkhit(r, cu)                 /* check for hit in full cube */
652 < register RAY  *r;
653 < CUBE  *cu;
650 > static int
651 > checkhit(               /* check for hit in full cube */
652 >        RAY  *r,
653 >        CUBE  *cu,
654 >        OBJECT  *cxs
655 > )
656   {
657          OBJECT  oset[MAXSET+1];
379 –        register OBJREC  *o;
380 –        register int  i;
658  
659          objset(oset, cu->cutree);
660 <        for (i = oset[0]; i > 0; i--) {
661 <                o = objptr(oset[i]);
662 <                if (o->lastrno == r->rno)               /* checked already? */
663 <                        continue;
664 <                (*ofun[o->otype].funp)(o, r);
388 <                o->lastrno = r->rno;
389 <        }
390 <        if (r->ro == NULL)
660 >        checkset(oset, cxs);                    /* avoid double-checking */
661 >
662 >        (*r->hitf)(oset, r);                    /* test for hit in set */
663 >
664 >        if (r->robj == OVOID)
665                  return(0);                      /* no scores yet */
666  
667          return(incube(cu, r->rop));             /* hit OK if in current cube */
668 + }
669 +
670 +
671 + static void
672 + checkset(               /* modify checked set and set to check */
673 +        OBJECT  *os,                    /* os' = os - cs */
674 +        OBJECT  *cs                     /* cs' = cs + os */
675 + )
676 + {
677 +        OBJECT  cset[MAXCSET+MAXSET+1];
678 +        int  i, j;
679 +        int  k;
680 +                                        /* copy os in place, cset <- cs */
681 +        cset[0] = 0;
682 +        k = 0;
683 +        for (i = j = 1; i <= os[0]; i++) {
684 +                while (j <= cs[0] && cs[j] < os[i])
685 +                        cset[++cset[0]] = cs[j++];
686 +                if (j > cs[0] || os[i] != cs[j]) {      /* object to check */
687 +                        os[++k] = os[i];
688 +                        cset[++cset[0]] = os[i];
689 +                }
690 +        }
691 +        if (!(os[0] = k))               /* new "to check" set size */
692 +                return;                 /* special case */
693 +        while (j <= cs[0])              /* get the rest of cs */
694 +                cset[++cset[0]] = cs[j++];
695 +        if (cset[0] > MAXCSET)          /* truncate "checked" set if nec. */
696 +                cset[0] = MAXCSET;
697 +        /* setcopy(cs, cset); */        /* copy cset back to cs */
698 +        os = cset;
699 +        for (i = os[0]; i-- >= 0; )
700 +                *cs++ = *os++;
701   }

Diff Legend

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