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

Comparing ray/src/gen/mkillum2.c (file contents):
Revision 2.12 by schorsch, Sun Nov 16 10:29:38 2003 UTC vs.
Revision 2.18 by greg, Thu Sep 13 06:31:21 2007 UTC

# Line 12 | Line 12 | static const char      RCSid[] = "$Id$";
12   #include  "cone.h"
13   #include  "random.h"
14  
15 – //void o_default(OBJREC *ob, struct illum_args *il, struct rtproc *rt, char *nm);
16 – void o_face(OBJREC *ob, struct illum_args *il, struct rtproc *rt, char *nm);
17 – void o_sphere(OBJREC *ob, struct illum_args *il, struct rtproc *rt, char *nm);
18 – void o_ring(OBJREC *ob, struct illum_args *il, struct rtproc *rt, char *nm);
19 – void raysamp(float res[3], FVECT org, FVECT dir, struct rtproc *rt);
20 – void rayflush(struct rtproc *rt);
21 – void mkaxes(FVECT u, FVECT v, FVECT n);
22 – void rounddir(FVECT dv, double alt, double azi);
23 – void flatdir(FVECT dv, double alt, double azi);
15  
16 + static void mkaxes(FVECT u, FVECT v, FVECT n);
17 + static void rounddir(FVECT dv, double alt, double azi);
18 + static void flatdir(FVECT dv, double alt, double azi);
19  
20 +
21 + static COLORV * distarr = NULL;         /* distribution array */
22 + static int      distsiz = 0;
23 +
24 +
25 + static void
26 + newdist(                        /* allocate & clear distribution array */
27 +        int siz
28 + )
29 + {
30 +        if (siz == 0) {
31 +                if (distsiz > 0)
32 +                        free((void *)distarr);
33 +                distarr = NULL;
34 +                distsiz = 0;
35 +                return;
36 +        }
37 +        if (distsiz < siz) {
38 +                free((void *)distarr);
39 +                distarr = (COLORV *)malloc(sizeof(COLORV)*3*siz);
40 +                if (distarr == NULL)
41 +                        error(SYSTEM, "Out of memory in distalloc");
42 +                distsiz = siz;
43 +        }
44 +        memset(distarr, '\0', sizeof(COLORV)*3*siz);
45 + }
46 +
47 +
48 + static int
49 + process_ray(RAY *r, int rv)
50 + {
51 +        COLORV  *colp;
52 +
53 +        if (rv == 0)
54 +                return(0);
55 +        if (rv < 0)
56 +                error(USER, "Ray tracing process died");
57 +        if (r->rno >= distsiz)
58 +                error(INTERNAL, "Bad returned index in process_ray");
59 +        colp = &distarr[r->rno * 3];
60 +        addcolor(colp, r->rcol);
61 +        return(1);
62 + }
63 +
64 +
65 + static void
66 + raysamp(        /* queue a ray sample */
67 +        int  ndx,
68 +        FVECT  org,
69 +        FVECT  dir
70 + )
71 + {
72 +        RAY     myRay;
73 +        int     rv;
74 +
75 +        if ((ndx < 0) | (ndx >= distsiz))
76 +                error(INTERNAL, "Bad index in raysamp");
77 +        VCOPY(myRay.rorg, org);
78 +        VCOPY(myRay.rdir, dir);
79 +        myRay.rmax = .0;
80 +        rayorigin(&myRay, PRIMARY, NULL, NULL);
81 +        myRay.rno = ndx;
82 +                                        /* queue ray, check result */
83 +        process_ray(&myRay, ray_pqueue(&myRay));
84 + }
85 +
86 +
87 + static void
88 + rayclean()                      /* finish all pending rays */
89 + {
90 +        RAY     myRay;
91 +
92 +        while (process_ray(&myRay, ray_presult(&myRay, 0)))
93 +                ;
94 + }
95 +
96 +
97   int /* XXX type conflict with otypes.h */
98 < o_default(      /* default illum action */
98 > my_default(     /* default illum action */
99          OBJREC  *ob,
100          struct illum_args  *il,
30 –        struct rtproc  *rt,
101          char  *nm
102   )
103   {
# Line 35 | Line 105 | o_default(     /* default illum action */
105                          nm, ofun[ob->otype].funame, ob->oname);
106          error(WARNING, errmsg);
107          printobj(il->altmat, ob);
108 +        return(1);
109   }
110  
111  
112 < void
113 < o_face(         /* make an illum face */
112 > int
113 > my_face(                /* make an illum face */
114          OBJREC  *ob,
115          struct illum_args  *il,
45 –        struct rtproc  *rt,
116          char  *nm
117   )
118   {
119   #define MAXMISS         (5*n*il->nsamps)
120          int  dim[3];
121          int  n, nalt, nazi, h;
52 –        float  *distarr;
122          double  sp[2], r1, r2;
123          FVECT  dn, org, dir;
124          FVECT  u, v;
# Line 61 | Line 130 | o_face(                /* make an illum face */
130          fa = getface(ob);
131          if (fa->area == 0.0) {
132                  freeface(ob);
133 <                o_default(ob, il, rt, nm);
65 <                return;
133 >                return(o_default(ob, il, nm));
134          }
135                                  /* set up sampling */
136          if (il->sampdens <= 0)
# Line 73 | Line 141 | o_face(                /* make an illum face */
141                  nazi = PI*nalt + .5;
142          }
143          n = nalt*nazi;
144 <        distarr = (float *)calloc(n, 3*sizeof(float));
77 <        if (distarr == NULL)
78 <                error(SYSTEM, "out of memory in o_face");
144 >        newdist(n);
145                                  /* take first edge longer than sqrt(area) */
146          for (j = fa->nv-1, i = 0; i < fa->nv; j = i++) {
147                  u[0] = VERTEX(fa,i)[0] - VERTEX(fa,j)[0];
# Line 126 | Line 192 | o_face(                /* make an illum face */
192                      } while (!inface(org, fa) && nmisses++ < MAXMISS);
193                      if (nmisses > MAXMISS) {
194                          objerror(ob, WARNING, "bad aspect");
195 <                        rt->nrays = 0;
195 >                        rayclean();
196                          freeface(ob);
197                          free((void *)distarr);
198 <                        o_default(ob, il, rt, nm);
133 <                        return;
198 >                        return(o_default(ob, il, nm));
199                      }
200                      for (j = 0; j < 3; j++)
201                          org[j] += .001*fa->norm[j];
202                                          /* send sample */
203 <                    raysamp(distarr+3*(dim[1]*nazi+dim[2]), org, dir, rt);
203 >                    raysamp(dim[1]*nazi+dim[2], org, dir);
204                  }
205 <        rayflush(rt);
205 >        rayclean();
206                                  /* write out the face and its distribution */
207          if (average(il, distarr, nalt*nazi)) {
208                  if (il->sampdens > 0)
# Line 147 | Line 212 | o_face(                /* make an illum face */
212                  printobj(il->altmat, ob);
213                                  /* clean up */
214          freeface(ob);
215 <        free((void *)distarr);
215 >        return(0);
216   #undef MAXMISS
217   }
218  
219  
220 < void
221 < o_sphere(       /* make an illum sphere */
220 > int
221 > my_sphere(      /* make an illum sphere */
222          register OBJREC  *ob,
223          struct illum_args  *il,
159 –        struct rtproc  *rt,
224          char  *nm
225   )
226   {
227          int  dim[3];
228          int  n, nalt, nazi;
165 –        float  *distarr;
229          double  sp[4], r1, r2, r3;
230          FVECT  org, dir;
231          FVECT  u, v;
# Line 179 | Line 242 | o_sphere(      /* make an illum sphere */
242                  nazi = PI/2.*nalt + .5;
243          }
244          n = nalt*nazi;
245 <        distarr = (float *)calloc(n, 3*sizeof(float));
183 <        if (distarr == NULL)
184 <                error(SYSTEM, "out of memory in o_sphere");
245 >        newdist(n);
246          dim[0] = random();
247                                  /* sample sphere */
248          for (dim[1] = 0; dim[1] < nalt; dim[1]++)
# Line 206 | Line 267 | o_sphere(      /* make an illum sphere */
267                          dir[j] = -dir[j];
268                      }
269                                          /* send sample */
270 <                    raysamp(distarr+3*(dim[1]*nazi+dim[2]), org, dir, rt);
270 >                    raysamp(dim[1]*nazi+dim[2], org, dir);
271                  }
272 <        rayflush(rt);
272 >        rayclean();
273                                  /* write out the sphere and its distribution */
274          if (average(il, distarr, nalt*nazi)) {
275                  if (il->sampdens > 0)
# Line 219 | Line 280 | o_sphere(      /* make an illum sphere */
280          } else
281                  printobj(il->altmat, ob);
282                                  /* clean up */
283 <        free((void *)distarr);
283 >        return(1);
284   }
285  
286  
287 < void
288 < o_ring(         /* make an illum ring */
287 > int
288 > my_ring(                /* make an illum ring */
289          OBJREC  *ob,
290          struct illum_args  *il,
230 –        struct rtproc  *rt,
291          char  *nm
292   )
293   {
294          int  dim[3];
295          int  n, nalt, nazi;
236 –        float  *distarr;
296          double  sp[4], r1, r2, r3;
297          FVECT  dn, org, dir;
298          FVECT  u, v;
# Line 250 | Line 309 | o_ring(                /* make an illum ring */
309                  nazi = PI*nalt + .5;
310          }
311          n = nalt*nazi;
312 <        distarr = (float *)calloc(n, 3*sizeof(float));
254 <        if (distarr == NULL)
255 <                error(SYSTEM, "out of memory in o_ring");
312 >        newdist(n);
313          mkaxes(u, v, co->ad);
314          dim[0] = random();
315                                  /* sample disk */
# Line 278 | Line 335 | o_ring(                /* make an illum ring */
335                                          .001*co->ad[j];
336  
337                                          /* send sample */
338 <                    raysamp(distarr+3*(dim[1]*nazi+dim[2]), org, dir, rt);
338 >                    raysamp(dim[1]*nazi+dim[2], org, dir);
339                  }
340 <        rayflush(rt);
340 >        rayclean();
341                                  /* write out the ring and its distribution */
342          if (average(il, distarr, nalt*nazi)) {
343                  if (il->sampdens > 0)
# Line 290 | Line 347 | o_ring(                /* make an illum ring */
347                  printobj(il->altmat, ob);
348                                  /* clean up */
349          freecone(ob);
350 <        free((void *)distarr);
350 >        return(1);
351   }
352  
353  
354 < void
298 < raysamp(        /* compute a ray sample */
299 <        float  res[3],
300 <        FVECT  org,
301 <        FVECT  dir,
302 <        register struct rtproc  *rt
303 < )
304 < {
305 <        register float  *fp;
306 <
307 <        if (rt->nrays == rt->bsiz)
308 <                rayflush(rt);
309 <        rt->dest[rt->nrays] = res;
310 <        fp = rt->buf + 6*rt->nrays++;
311 <        *fp++ = org[0]; *fp++ = org[1]; *fp++ = org[2];
312 <        *fp++ = dir[0]; *fp++ = dir[1]; *fp = dir[2];
313 < }
314 <
315 <
316 < void
317 < rayflush(                       /* flush buffered rays */
318 <        register struct rtproc  *rt
319 < )
320 < {
321 <        register int  i;
322 <
323 <        if (rt->nrays <= 0)
324 <                return;
325 <        memset(rt->buf+6*rt->nrays, '\0', 6*sizeof(float));
326 <        errno = 0;
327 <        if ( process(&(rt->pd), (char *)rt->buf, (char *)rt->buf,
328 <                        3*sizeof(float)*(rt->nrays+1),
329 <                        6*sizeof(float)*(rt->nrays+1)) <
330 <                        3*sizeof(float)*(rt->nrays+1) )
331 <                error(SYSTEM, "error reading from rtrace process");
332 <        i = rt->nrays;
333 <        while (i--) {
334 <                rt->dest[i][0] += rt->buf[3*i];
335 <                rt->dest[i][1] += rt->buf[3*i+1];
336 <                rt->dest[i][2] += rt->buf[3*i+2];
337 <        }
338 <        rt->nrays = 0;
339 < }
340 <
341 <
342 < void
354 > static void
355   mkaxes(                 /* compute u and v to go with n */
356          FVECT  u,
357          FVECT  v,
# Line 359 | Line 371 | mkaxes(                        /* compute u and v to go with n */
371   }
372  
373  
374 < void
374 > static void
375   rounddir(               /* compute uniform spherical direction */
376          register FVECT  dv,
377          double  alt,
# Line 376 | Line 388 | rounddir(              /* compute uniform spherical direction */
388   }
389  
390  
391 < void
391 > static void
392   flatdir(                /* compute uniform hemispherical direction */
393          register FVECT  dv,
394          double  alt,

Diff Legend

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