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

Comparing ray/src/common/bsdf.h (file contents):
Revision 2.8 by greg, Mon Feb 21 22:50:37 2011 UTC vs.
Revision 2.17 by greg, Sun Mar 4 20:11:10 2012 UTC

# Line 14 | Line 14
14   *      in the +Z direction, towards the interior of the space rather
15   *      than the exterior.
16   *
17 < *  BSDF vectors always oriented away from surface, even when "incident."
17 > *  BSDF incident & exiting vectors are always oriented away from surface.
18   *
19   *  Created by Greg Ward on 1/10/11.
20   *
# Line 30 | Line 30
30   extern "C" {
31   #endif
32  
33 + #ifdef _WIN32
34 + #define strcasecmp      stricmp
35 + #endif
36 +
37   #define SDnameLn        128             /* maximum BSDF name length */
38   #define SDmaxCh         3               /* maximum # spectral channels */
39  
40 < /* Component flags for SDsampBSDF() and SDhemiScatter() */
40 > /* Component flags for SDsampBSDF() and SDdirectHemi() */
41   #define SDsampR         0x1             /* include reflection */
42   #define SDsampT         0x2             /* include transmission */
43   #define SDsampS         0x3             /* include scattering (R+T) */
# Line 44 | Line 48 | extern "C" {
48   #define SDsampSpS       0x7             /* include non-diffuse scattering */
49   #define SDsampAll       0xF             /* include everything */
50  
51 < /* Projected solid angle query flags fos SDsizeBSDF() */
51 > /* Projected solid angle query flags for SDsizeBSDF() */
52   #define SDqueryVal      0x0             /* query single value */
53   #define SDqueryMin      0x1             /* query minimum proj. solid angle */
54   #define SDqueryMax      0x2             /* query maximum proj. solid angle */
# Line 67 | Line 71 | typedef struct {
71   } SDValue;
72  
73   /* Cached, encoded, cumulative distribution for one incident (solid) angle */
74 < #define SD_CDIST_BASE   double          cTotal; \
75 <                        struct SDCDst_s *next
74 > #define SD_CDIST_BASE(styp)     double          cTotal; \
75 >                                struct styp     *next
76   typedef struct SDCDst_s {
77 <        SD_CDIST_BASE;                  /* base fields first */
77 >        SD_CDIST_BASE(SDCDst_s);        /* base fields first */
78          /* ...encoded distribution extends struct */
79   } SDCDst;
80  
# Line 81 | Line 85 | typedef struct SDComp_s        SDComponent;
85   typedef const struct {
86                                          /* return non-diffuse BSDF */
87          int             (*getBSDFs)(float coef[SDmaxCh], const FVECT outVec,
88 <                                    const FVECT inVec, const void *dist);
88 >                                    const FVECT inVec, SDComponent *sdc);
89                                          /* query non-diffuse PSA for vector */
90 <        SDError         (*queryProjSA)(double *psa, const FVECT vec,
91 <                                                int qflags, const void *dist);
90 >        SDError         (*queryProjSA)(double *psa, const FVECT v1,
91 >                                                const RREAL *v2, int qflags,
92 >                                                SDComponent *sdc);
93                                          /* get cumulative distribution */
94          const SDCDst    *(*getCDist)(const FVECT inVec, SDComponent *sdc);
95                                          /* sample cumulative distribution */
96 <        SDError         (*sampCDist)(FVECT outVec, double randX,
96 >        SDError         (*sampCDist)(FVECT ioVec, double randX,
97                                                  const SDCDst *cdp);
98                                          /* free a spectral BSDF component */
99          void            (*freeSC)(void *dist);
# Line 112 | Line 117 | typedef struct {
117  
118   /* Loaded BSDF data */
119   typedef struct {
120 <        char            name[SDnameLn]; /* BSDF name (derived from file) */
120 >        char            name[SDnameLn]; /* BSDF name (usu. derived from file) */
121          char            *mgf;           /* geometric description (if any) */
122          float           dim[3];         /* width, height, thickness (meters) */
123          SDValue         rLambFront;     /* diffuse front reflectance */
# Line 129 | Line 134 | extern struct SDCache_s {
134                          *next;
135   } *SDcacheList;         /* Global BSDF cache */
136  
137 < /* BSDF cache retention preference */
138 < #define SDretainNone    0               /* free unreferenced data (default) */
139 < #define SDretainBSDFs   1               /* keep loaded BSDFs in cache */
137 > /* BSDF cache retention policies */
138 > #define SDretainNone    0               /* free unreferenced BSDF data */
139 > #define SDretainBSDFs   1               /* keep loaded BSDFs in memory */
140   #define SDretainAll     2               /* also keep cumulative cache data */
141  
142 < extern int              SDretainSet;    /* set to SDretainNone by default */
142 > extern int              SDretainSet;    /* =SDretainNone by default */
143  
144   /*****************************************************************
145   * The following routines are less commonly used by applications.
# Line 151 | Line 156 | extern void            SDclipName(char res[SDnameLn], const char
156   /* Allocate new spectral distribution function */
157   extern SDSpectralDF     *SDnewSpectralDF(int nc);
158  
159 + /* Add component(s) to spectral distribution function */
160 + extern SDSpectralDF     *SDaddComponent(SDSpectralDF *odf, int nadd);
161 +
162   /* Free a spectral distribution function */
163   extern void             SDfreeSpectralDF(SDSpectralDF *df);
164  
165 < /* Initialize an unused BSDF struct (clears to zeroes) */
166 < extern void             SDclearBSDF(SDData *sd);
165 > /* Initialize an unused BSDF struct and assign name (calls SDclipName) */
166 > extern void             SDclearBSDF(SDData *sd, const char *fname);
167  
168   /* Load a BSDF struct from the given file (keeps name unchanged) */
169   extern SDError          SDloadFile(SDData *sd, const char *fname);
# Line 170 | Line 178 | extern SDData          *SDgetCache(const char *bname);
178   extern void             SDfreeCumulativeCache(SDSpectralDF *df);
179  
180   /* Sample an individual BSDF component */
181 < extern SDError          SDsampComponent(SDValue *sv, FVECT outVec,
182 <                                        const FVECT inVec, double randX,
175 <                                        SDComponent *sdc);
181 > extern SDError          SDsampComponent(SDValue *sv, FVECT ioVec,
182 >                                        double randX, SDComponent *sdc);
183  
184   /* Convert 1-dimensional random variable to N-dimensional */
185   extern void             SDmultiSamp(double t[], int n, double randX);
# Line 189 | Line 196 | void                   SDdisk2square(double sq[2], double diskx, doubl
196   */
197  
198   /* Get BSDF from cache (or load and cache it on first call) */
199 < /* Report any problems to stderr and return NULL on failure */
199 > /* Report any problems to stderr (in English), return NULL on failure */
200   extern const SDData     *SDcacheFile(const char *fname);
201  
202 < /* Free a BSDF from our cache (clear all if NULL) */
202 > /* Free a BSDF from our cache (clear all if sd==NULL) */
203   extern void             SDfreeCache(const SDData *sd);
204  
205 < /* Query projected solid angle resolution for non-diffuse BSDF direction */
206 < extern SDError          SDsizeBSDF(double *projSA, const FVECT vec,
207 <                                        int qflags, const SDData *sd);
205 > /* Query projected solid angle resolution for non-diffuse BSDF direction(s) */
206 > extern SDError          SDsizeBSDF(double *projSA, const FVECT v1,
207 >                                        const RREAL *v2, int qflags,
208 >                                        const SDData *sd);
209  
210   /* Return BSDF for the given incident and scattered ray vectors */
211   extern SDError          SDevalBSDF(SDValue *sv, const FVECT outVec,
# Line 208 | Line 216 | extern double          SDdirectHemi(const FVECT inVec,
216                                          int sflags, const SDData *sd);
217  
218   /* Sample BSDF direction based on the given random variable */
219 < extern SDError          SDsampBSDF(SDValue *sv, FVECT outVec,
212 <                                        const FVECT inVec, double randX,
219 > extern SDError          SDsampBSDF(SDValue *sv, FVECT ioVec, double randX,
220                                          int sflags, const SDData *sd);
221  
222   /*****************************************************************
# Line 217 | Line 224 | extern SDError         SDsampBSDF(SDValue *sv, FVECT outVec,
224   * Directions may be passed unnormalized to these routines.
225   */
226  
227 < /* Compute World->BSDF transform from surface normal and up (Y) vector */
227 > /* Compute World->BSDF transform from surface normal and BSDF up vector */
228   extern SDError          SDcompXform(RREAL vMtx[3][3], const FVECT sNrm,
229                                          const FVECT uVec);
230  
# Line 228 | Line 235 | extern SDError         SDinvXform(RREAL iMtx[3][3], RREAL vMt
235   extern SDError          SDmapDir(FVECT resVec, RREAL vMtx[3][3],
236                                          const FVECT inpVec);
237  
238 < /* System-specific BSDF loading routine (not part of our library) */
238 > /* Application-specific BSDF loading routine (not part of our library) */
239   extern SDData           *loadBSDF(char *name);
240  
241 < /* System-specific BSDF error translator (not part of our library) */
241 > /* Application-specific BSDF error translator (not part of our library) */
242   extern char             *transSDError(SDError ec);
243  
244   /*################################################################*/

Diff Legend

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