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

Comparing ray/src/rt/srcobstr.c (file contents):
Revision 2.7 by greg, Wed Sep 8 06:07:52 2004 UTC vs.
Revision 2.16 by greg, Mon Feb 14 20:13:38 2011 UTC

# Line 11 | Line 11 | static const char RCSid[] = "$Id$";
11  
12   #include  "otspecial.h"
13  
14 + #include  "rtotypes.h"
15 +
16   #include  "source.h"
17  
18   #define ABS(x)  ((x)>0 ? (x) : -(x))
# Line 19 | Line 21 | static const char RCSid[] = "$Id$";
21   #if  SHADCACHE                  /* preemptive shadow checking */
22  
23  
24 + OBJECT *        antimodlist = NULL;     /* set of clipped materials */
25 +
26 +
27   static int                              /* cast source ray to first blocker */
28   castshadow(int sn, FVECT rorg, FVECT rdir)
29   {
# Line 27 | Line 32 | castshadow(int sn, FVECT rorg, FVECT rdir)
32          VCOPY(rt.rorg, rorg);
33          VCOPY(rt.rdir, rdir);
34          rt.rmax = 0;
35 <        rayorigin(&rt, NULL, PRIMARY, 1.0);
35 >        rayorigin(&rt, PRIMARY, NULL, NULL);
36                                          /* check for intersection */
37          while (localhit(&rt, &thescene)) {
38                  RAY     rt1 = rt;       /* pretend we were aimed at source */
# Line 50 | Line 55 | castshadow(int sn, FVECT rorg, FVECT rdir)
55   }
56  
57  
58 < static void                             /* initialize occlusion cache */
58 > void                                    /* initialize occlusion cache */
59   initobscache(int sn)
60   {
61          register SRCREC *srcp = &source[sn];
# Line 60 | Line 65 | initobscache(int sn)
65          int             i, j, k;
66          int             ax, ax1, ax2;
67  
68 +        if (srcp->sflags & (SSKIP|SPROX|SSPOT|SVIRTUAL))
69 +                return;                 /* don't cache these */
70          if (srcp->sflags & SDISTANT)
71                  cachelen = 4*SHADCACHE*SHADCACHE;
72          else if (srcp->sflags & SFLAT)
# Line 67 | Line 74 | initobscache(int sn)
74          else /* spherical distribution */
75                  cachelen = SHADCACHE*SHADCACHE*6;
76                                          /* allocate cache */
70 –        DCHECK(srcp->obscache != NULL,
71 –                        CONSISTENCY, "initobscache() called twice");
77          srcp->obscache = (OBSCACHE *)malloc(sizeof(OBSCACHE) +
78                                                  sizeof(OBJECT)*(cachelen-1));
79          if (srcp->obscache == NULL)
# Line 175 | Line 180 | initobscache(int sn)
180   static OBJECT *                 /* return occluder cache entry */
181   srcobstructp(register RAY *r)
182   {
183 <        static unsigned long    lastrno = ~0;
183 >        static RNUMBER  lastrno = ~0;
184          static OBJECT   noobs;
185          static OBJECT   *lastobjp;
186          SRCREC          *srcp;
# Line 290 | Line 295 | srcblocker(register RAY *r)
295          if (r->robj == OVOID || objptr(r->robj) != r->ro ||
296                          isvolume(r->ro->otype))
297                  return(0);              /* don't record complex blockers */
298 +        if (r->rsrc < 0 || source[r->rsrc].so == r->ro)
299 +                return(0);              /* just a mistake, that's all */
300 +        if (antimodlist != NULL && inset(antimodlist, r->ro->omod))
301 +                return(0);              /* could be clipped */
302          m = findmaterial(r->ro);
303          if (m == NULL)
304                  return(0);              /* no material?! */
# Line 308 | Line 317 | srcblocked(RAY *r)
317  
318          if (obs == OVOID)
319                  return(0);
320 <        op = objptr(obs);               /* check for intersection */
321 <        return((*ofun[op->otype].funp)(op, r));
320 >        op = objptr(obs);               /* check blocker intersection */
321 >        if (!(*ofun[op->otype].funp)(op, r))
322 >                return(0);
323 >        if (source[r->rsrc].sflags & SDISTANT)
324 >                return(1);
325 >        op = source[r->rsrc].so;        /* check source intersection */
326 >        if (!(*ofun[op->otype].funp)(op, r))
327 >                return(1);
328 >        rayclear(r);
329 >        return(0);                      /* source in front */
330 > }
331 >
332 >
333 > void                            /* record potentially clipped materials */
334 > markclip(OBJREC *m)
335 > {
336 >        OBJECT  *set2add, *oldset;
337 >
338 >        if (m == NULL) {                /* starting over */
339 >                if (antimodlist != NULL)
340 >                        free((void *)antimodlist);
341 >                antimodlist = NULL;
342 >                return;
343 >        }
344 >        m_clip(m, NULL);                /* initialize modifier list */
345 >        if ((set2add = (OBJECT *)m->os) == NULL || !set2add[0])
346 >                return;
347 >
348 >        if (antimodlist == NULL) {      /* start of list */
349 >                antimodlist = setsave(set2add);
350 >                return;
351 >        }
352 >                                        /* else add to previous list */
353 >        oldset = antimodlist;
354 >        antimodlist = (OBJECT *)malloc((oldset[0]+set2add[0]+1)*sizeof(OBJECT));
355 >        if (antimodlist == NULL)
356 >                error(SYSTEM, "out of memory in markclip");
357 >        setunion(antimodlist, oldset, set2add);
358 >        free((void *)oldset);
359 > }
360 >
361 >
362 > #else   /* SHADCACHE */
363 >
364 >
365 > void                            /* no-op also avoids linker warning */
366 > markclip(OBJREC *m)
367 > {
368 >        (void)m;
369   }
370  
371  

Diff Legend

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