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

Comparing ray/src/rt/ray.h (file contents):
Revision 2.12 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.60 by greg, Fri Jun 20 16:34:23 2025 UTC

# Line 1 | Line 1
1 < /* RCSid: $Id$ */
1 > /* RCSid $Id$ */
2   /*
3   *  ray.h - header file for routines using rays.
4   */
5 + #ifndef _RAD_RAY_H_
6 + #define _RAD_RAY_H_
7  
6 – /* ====================================================================
7 – * The Radiance Software License, Version 1.0
8 – *
9 – * Copyright (c) 1990 - 2002 The Regents of the University of California,
10 – * through Lawrence Berkeley National Laboratory.   All rights reserved.
11 – *
12 – * Redistribution and use in source and binary forms, with or without
13 – * modification, are permitted provided that the following conditions
14 – * are met:
15 – *
16 – * 1. Redistributions of source code must retain the above copyright
17 – *         notice, this list of conditions and the following disclaimer.
18 – *
19 – * 2. Redistributions in binary form must reproduce the above copyright
20 – *       notice, this list of conditions and the following disclaimer in
21 – *       the documentation and/or other materials provided with the
22 – *       distribution.
23 – *
24 – * 3. The end-user documentation included with the redistribution,
25 – *           if any, must include the following acknowledgment:
26 – *             "This product includes Radiance software
27 – *                 (http://radsite.lbl.gov/)
28 – *                 developed by the Lawrence Berkeley National Laboratory
29 – *               (http://www.lbl.gov/)."
30 – *       Alternately, this acknowledgment may appear in the software itself,
31 – *       if and wherever such third-party acknowledgments normally appear.
32 – *
33 – * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
34 – *       and "The Regents of the University of California" must
35 – *       not be used to endorse or promote products derived from this
36 – *       software without prior written permission. For written
37 – *       permission, please contact [email protected].
38 – *
39 – * 5. Products derived from this software may not be called "Radiance",
40 – *       nor may "Radiance" appear in their name, without prior written
41 – *       permission of Lawrence Berkeley National Laboratory.
42 – *
43 – * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
44 – * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
45 – * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
46 – * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
47 – * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 – * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 – * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
50 – * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
51 – * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
52 – * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
53 – * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54 – * SUCH DAMAGE.
55 – * ====================================================================
56 – *
57 – * This software consists of voluntary contributions made by many
58 – * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
59 – * information on Lawrence Berkeley National Laboratory, please see
60 – * <http://www.lbl.gov/>.
61 – */
62 –
8   #include  "standard.h"
64 –
9   #include  "octree.h"
66 –
10   #include  "object.h"
68 –
11   #include  "color.h"
12 + #include  "pmapparm.h"
13  
14 < #define  MAXDIM         32      /* maximum number of dimensions */
14 > #ifdef __cplusplus
15 > extern "C" {
16 > #endif
17  
18 + #ifndef RNUMBER
19 + #define RNUMBER         size_t          /* ray counter (>= sizeof pointer) */
20 + #endif
21 +
22 + #define  MAXDIM         36      /* maximum number of sampling dimensions */
23 + #define  XTRADIM        3       /* #spare dimensions */
24 + #define  ndims_inc      (ndims -= ndims>=MAXDIM-XTRADIM, ndims++)
25 +
26                                  /* ray type flags */
27   #define  PRIMARY        01              /* original ray */
28 < #define  SHADOW         02              /* ray to light source */
28 > #define  RSHADOW        02              /* reflected ray to light source */
29   #define  REFLECTED      04              /* reflected ray */
30   #define  REFRACTED      010             /* refracted (bent) ray */
31   #define  TRANS          020             /* transmitted/transferred ray */
32 < #define  AMBIENT        040             /* ray scattered for interreflection */
33 < #define  SPECULAR       0100            /* ray scattered for specular */
32 > #define  RAMBIENT       040             /* reflected diffuse interreflection */
33 > #define  RSPECULAR      0100            /* reflected specular */
34 > #define  TSHADOW        0200            /* transmitted shadow */
35 > #define  TAMBIENT       0400            /* transmitted ambient */
36 > #define  TSPECULAR      01000           /* transmitted specular */
37 > #define  SHADOW         (RSHADOW|TSHADOW)
38 > #define  AMBIENT        (RAMBIENT|TAMBIENT)
39 > #define  SPECULAR       (RSPECULAR|TSPECULAR)
40  
41                                  /* reflected ray types */
42 < #define  RAYREFL        (SHADOW|REFLECTED|AMBIENT|SPECULAR)
42 > #define  RAYREFL        (RSHADOW|REFLECTED|RAMBIENT|RSPECULAR)
43  
44 + /* Arrange so double's come first for optimal alignment */
45 + /* Pointers and long's come second for 64-bit mode */
46 + /* Int's next (unknown length), then floats, followed by short's & char's */
47   typedef struct ray {
86 –        unsigned long  rno;     /* unique ray number */
87 –        int     rlvl;           /* number of reflections for this ray */
88 –        float   rweight;        /* cumulative weight of this ray */
89 –        short   rtype;          /* ray type */
90 –        short   crtype;         /* cumulative ray type */
91 –        struct ray  *parent;    /* ray this originated from */
48          FVECT   rorg;           /* origin of ray */
49          FVECT   rdir;           /* normalized direction of ray */
50 <        double  rmax;           /* maximum distance (aft clipping plane) */
51 <        int     rsrc;           /* source we're aiming for */
50 >        RREAL   rmax;           /* maximum distance (aft clipping plane) */
51 >        RREAL   rot;            /* distance to object */
52 >        FVECT   rop;            /* intersection point */
53 >        FVECT   ron;            /* intersection surface normal */
54 >        RREAL   rod;            /* -DOT(rdir, ron) */
55 >        RREAL   uv[2];          /* local coordinates */
56 >        FVECT   pert;           /* surface normal perturbation */
57 >        RREAL   rmt;            /* returned mirrored ray length */
58 >        RREAL   rxt;            /* returned unmirrored ray length */
59 >        const struct ray  *parent;      /* ray this originated from */
60          OBJECT  *clipset;       /* set of objects currently clipped */
61          OBJECT  *newcset;       /* next clipset, used for transmission */
62 <        void    (*revf)();      /* evaluation function for this ray */
63 <        OBJECT  robj;           /* intersected object number */
62 >        void    (*revf)(struct ray *);  /* ray evaluation function */
63 >        void    (*hitf)(OBJECT *, struct ray *);        /* custom hit test */
64          OBJREC  *ro;            /* intersected object (one with material) */
101 –        double  rot;            /* distance to object */
102 –        FVECT   rop;            /* intersection point */
103 –        FVECT   ron;            /* intersection surface normal */
104 –        double  rod;            /* -DOT(rdir, ron) */
65          FULLXF  *rox;           /* object transformation */
66 <        FVECT   pert;           /* surface normal perturbation */
67 <        COLOR   pcol;           /* pattern color */
68 <        COLOR   rcol;           /* returned ray value */
69 <        double  rt;             /* returned effective ray length */
66 >        int     *slights;       /* list of lights to test for scattering */
67 >        RNUMBER rno;            /* unique ray number */
68 >        OBJECT  robj;           /* intersected object number */
69 >        int     rsrc;           /* source we're aiming for (or ones to skip) */
70 >        float   rweight;        /* cumulative weight (for termination) */
71 >        float   gecc;           /* scattering eccentricity coefficient */
72 >        SCOLOR  rcoef;          /* contribution coefficient w.r.t. parent */
73 >        SCOLOR  pcol;           /* pattern color */
74 >        SCOLOR  mcol;           /* mirrored color contribution */
75 >        SCOLOR  rcol;           /* returned radiance value */
76          COLOR   cext;           /* medium extinction coefficient */
77          COLOR   albedo;         /* medium scattering albedo */
78 <        float   gecc;           /* scattering eccentricity coefficient */
79 <        int     *slights;       /* list of lights to test for scattering */
78 >        short   rflips;         /* surface orientation has been reversed */
79 >        short   rlvl;           /* number of reflections for this ray */
80 >        short   rtype;          /* ray type */
81 >        short   crtype;         /* cumulative ray type */
82   }  RAY;
83  
84   #define  rayvalue(r)    (*(r)->revf)(r)
85  
86 < extern char  VersionID[];       /* Radiance version ID string */
86 > #define  thrudir(r,v)   ((r)->rod > 0 ^ DOT((r)->ron,v) > 0)
87  
88 + #define  raydistance(r) (pbright((r)->mcol) > 0.5*pbright((r)->rcol) ? \
89 +                                (r)->rmt : (r)->rxt)
90 +
91 + #define  rayreorient(r) if ((r)->rflips & 1) flipsurface(r); else
92 +
93 + extern char     VersionID[];    /* Radiance version ID string */
94 + extern char     RFeatureList[]; /* newline-separated feature list */
95 +
96   extern CUBE     thescene;       /* our scene */
97   extern OBJECT   nsceneobjs;     /* number of objects in our scene */
98  
99 < extern unsigned long    raynum; /* next ray ID */
100 < extern unsigned long    nrays;  /* total rays traced so far */
99 > extern RNUMBER  raynum;         /* next ray ID */
100 > extern RNUMBER  nrays;          /* total rays traced so far */
101  
102   extern OBJREC  Lamb;            /* a Lambertian surface */
103   extern OBJREC  Aftplane;        /* aft clipping object */
104  
105 < extern void     (*trace)();     /* global trace reporting callback */
105 > extern void     (*trace)(RAY*); /* global trace reporting callback */
106  
107   extern int      dimlist[];      /* dimension list for distribution */
108   extern int      ndims;          /* number of dimensions so far */
109 < extern int      samplendx;      /* index for this sample */
109 > extern unsigned long
110 >                samplendx;      /* index for this sample */
111  
135 – extern int      ray_savesiz;    /* size of parameter save buffer */
136 –
112   extern int      do_irrad;       /* compute irradiance? */
113  
114 + extern int      rand_samp;      /* pure Monte Carlo sampling? */
115 +
116   extern double   dstrsrc;        /* square source distribution */
117   extern double   shadthresh;     /* shadow threshold */
118   extern double   shadcert;       /* shadow testing certainty */
# Line 171 | Line 148 | extern int     ambincl;        /* include == 1, exclude == 0 */
148   extern int      ray_pnprocs;    /* number of child processes */
149   extern int      ray_pnidle;     /* number of idle processes */
150  
151 < #define AMBLLEN         128     /* max. ambient list length */
152 < #define AMBWORD         8       /* average word length */
151 > #ifndef AMBLLEN
152 > #define AMBLLEN         512     /* max. ambient list length */
153 > #endif
154 > #define AMBWORD         12      /* average word length */
155  
156   typedef struct {                /* rendering parameter holder */
157          int     do_irrad;
158 +        int     rand_samp;
159          double  dstrsrc;
160          double  shadthresh;
161          double  shadcert;
# Line 203 | Line 183 | typedef struct {               /* rendering parameter holder */
183          int     ambincl;
184          short   amblndx[AMBLLEN+1];
185          char    amblval[AMBLLEN*AMBWORD];
186 +        
187 +        /* PMAP: photon mapping parameters */
188 +        PhotonMapParams pmapParams [NUM_PMAP_TYPES];
189   } RAYPARAMS;
190  
191   #define rpambmod(p,i)   ( (i)>=AMBLLEN||(p)->amblndx[i]<0 ? \
192                            (char *)NULL : (p)->amblval+(p)->amblndx[i] )
193  
211 – #ifdef NOPROTO
212 –
213 – extern void     headclean();
214 – extern void     openheader();
215 – extern void     dupheader();
216 – extern void     pfdetach();
217 – extern void     pfclean();
218 – extern void     pflock();
219 – extern void     pfhold();
220 – extern void     io_process();
221 – extern int      free_objs();
222 – extern void     free_objmem();
223 – extern int      load_os();
224 – extern void     preload_objs();
225 – extern void     ray_init();
226 – extern void     ray_trace();
227 – extern void     ray_done();
228 – extern void     ray_save();
229 – extern void     ray_restore();
230 – extern void     ray_defaults();
231 – extern void     ray_pinit();
232 – extern void     ray_psend();
233 – extern int      ray_pqueue();
234 – extern int      ray_presult();
235 – extern void     ray_pdone();
236 – extern void     ray_popen();
237 – extern void     ray_pclose();
238 – extern int      rayorigin();
239 – extern void     rayclear();
240 – extern void     raytrace();
241 – extern void     raycont();
242 – extern void     raytrans();
243 – extern int      rayshade();
244 – extern void     rayparticipate();
245 – extern int      raymixture();
246 – extern double   raydist();
247 – extern double   raynormal();
248 – extern void     newrayxf();
249 – extern void     flipsurface();
250 – extern int      localhit();
251 – extern int      getrenderopt();
252 – extern void     print_rdefaults();
253 – extern void     drawsources();
254 – extern void     rtrace();
255 – extern void     rview();
256 – extern void     rpict();
257 –
258 – #else
194                                          /* defined in duphead.c */
195   extern void     headclean(void);
196   extern void     openheader(void);
197   extern void     dupheader(void);
198 +                                        /* defined in persist.c */
199 + extern void     persistfile(char *pfn);
200   extern void     pfdetach(void);
201   extern void     pfclean(void);
202   extern void     pflock(int lf);
# Line 271 | Line 208 | extern void    free_objmem(void);
208                                          /* defined in preload.c */
209   extern int      load_os(OBJREC *op);
210   extern void     preload_objs(void);
211 + extern char     *shm_boundary;
212 + extern void     cow_memshare(void);
213 + extern void     cow_doneshare(void);
214                                          /* defined in raycalls.c */
215   extern void     ray_init(char *otnm);
216   extern void     ray_trace(RAY *r);
# Line 278 | Line 218 | extern void    ray_done(int freall);
218   extern void     ray_save(RAYPARAMS *rp);
219   extern void     ray_restore(RAYPARAMS *rp);
220   extern void     ray_defaults(RAYPARAMS *rp);
221 + extern void     reset_random(void);
222                                          /* defined in raypcalls.c */
223   extern void     ray_pinit(char *otnm, int nproc);
224 < extern void     ray_psend(RAY *r);
224 > extern int      ray_psend(RAY *r);
225   extern int      ray_pqueue(RAY *r);
226   extern int      ray_presult(RAY *r, int poll);
227   extern void     ray_pdone(int freall);
228   extern void     ray_popen(int nadd);
229   extern void     ray_pclose(int nsub);
230 +                                        /* defined in ray_fifo.c */
231 + extern int      (*ray_fifo_out)(RAY *r);
232 + extern int      ray_fifo_in(RAY *r);
233 + extern int      ray_fifo_flush(void);
234                                          /* defined in raytrace.c */
235 < extern int      rayorigin(RAY *r, RAY *ro, int rt, double rw);
235 > extern int      rayorigin(RAY *r, int rt, const RAY *ro, const SCOLOR rc);
236   extern void     rayclear(RAY *r);
237   extern void     raytrace(RAY *r);
238 + extern int      rayreject(OBJREC *o, RAY *r, double t, double rod);
239 + extern void     rayhit(OBJECT *oset, RAY *r);
240   extern void     raycont(RAY *r);
241   extern void     raytrans(RAY *r);
242 + extern int      raytirrad(OBJREC *m, RAY *r);
243   extern int      rayshade(RAY *r, int mod);
244   extern void     rayparticipate(RAY *r);
245 + extern void     raytexture(RAY *r, OBJECT mod);
246   extern int      raymixture(RAY *r, OBJECT fore, OBJECT back, double coef);
247 < extern double   raydist(RAY *r, int flags);
247 > extern void     raycontrib(SCOLOR rc, const RAY *r, int flags);
248 > extern double   raydist(const RAY *r, int flags);
249   extern double   raynormal(FVECT norm, RAY *r);
250   extern void     newrayxf(RAY *r);
251   extern void     flipsurface(RAY *r);
252   extern int      localhit(RAY *r, CUBE *scene);
253                                          /* defined in renderopts.c */
254 + extern int      feature_status(int ac, char *av[]);
255   extern int      getrenderopt(int ac, char *av[]);
256   extern void     print_rdefaults(void);
257                                          /* defined in srcdraw.c */
258 < extern void     drawsources(COLOR *pic[], float *zbf[],
258 > extern void     init_drawsources(int rad);
259 > extern void     drawsources(COLORV *pic[], RGBPRIMP primp, float *zbf[],
260                          int x0, int xsiz, int y0, int ysiz);
261 +                                        /* defined in rt/initotypes.c */
262 + extern void     initotypes(void);
263                                          /* module main procedures */
264 < extern void     rtrace(char *fname);
264 > extern void     rtrace(char *fname, int nproc);
265 > extern const char       *formstr(int  f);
266   extern void     rview(void);
267   extern void     rpict(int seq, char *pout, char *zout, char *prvr);
268  
269 + #ifdef __FAST_MATH__
270 + #define checknorm(vn)   (void)normalize(vn)
271 + #else
272 + #define checknorm(vn)
273   #endif
274 +
275 + #ifdef __cplusplus
276 + }
277 + #endif
278 + #endif /* _RAD_RAY_H_ */
279 +

Diff Legend

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