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.11 by greg, Tue Apr 19 21:31:22 2011 UTC vs.
Revision 2.22 by greg, Sun Apr 21 21:36:23 2013 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  
# Line 54 | Line 58 | extern "C" {
58   typedef enum {SDEnone=0, SDEmemory, SDEfile, SDEformat, SDEargument,
59                  SDEdata, SDEsupport, SDEinternal, SDEunknown} SDError;
60  
61 < /* English ASCII strings corresponding to ennumerated errors */
61 > /* English strings corresponding to ennumerated errors */
62   extern const char       *SDerrorEnglish[];
63  
64 < /* Additional information on last error (ASCII English) */
64 > /* Pointer to error list in preferred language */
65 > extern const char       **SDerrorList;
66 >
67 > /* Additional information on last error (generally in English) */
68   extern char             SDerrorDetail[];
69  
70   /* Holder for BSDF value and spectral color */
# Line 67 | Line 74 | typedef struct {
74   } SDValue;
75  
76   /* Cached, encoded, cumulative distribution for one incident (solid) angle */
77 < #define SD_CDIST_BASE   double          cTotal; \
78 <                        struct SDCDst_s *next
77 > #define SD_CDIST_BASE(styp)     double          cTotal; \
78 >                                struct styp     *next
79   typedef struct SDCDst_s {
80 <        SD_CDIST_BASE;                  /* base fields first */
80 >        SD_CDIST_BASE(SDCDst_s);        /* base fields first */
81          /* ...encoded distribution extends struct */
82   } SDCDst;
83  
84 + extern const SDCDst     SDemptyCD;      /* empty distribution */
85 +
86   /* Forward declaration of BSDF component */
87   typedef struct SDComp_s SDComponent;
88  
# Line 81 | Line 90 | typedef struct SDComp_s        SDComponent;
90   typedef const struct {
91                                          /* return non-diffuse BSDF */
92          int             (*getBSDFs)(float coef[SDmaxCh], const FVECT outVec,
93 <                                    const FVECT inVec, const void *dist);
93 >                                    const FVECT inVec, SDComponent *sdc);
94                                          /* query non-diffuse PSA for vector */
95          SDError         (*queryProjSA)(double *psa, const FVECT v1,
96                                                  const RREAL *v2, int qflags,
97 <                                                const void *dist);
97 >                                                SDComponent *sdc);
98                                          /* get cumulative distribution */
99          const SDCDst    *(*getCDist)(const FVECT inVec, SDComponent *sdc);
100                                          /* sample cumulative distribution */
101 <        SDError         (*sampCDist)(FVECT outVec, double randX,
101 >        SDError         (*sampCDist)(FVECT ioVec, double randX,
102                                                  const SDCDst *cdp);
103                                          /* free a spectral BSDF component */
104          void            (*freeSC)(void *dist);
# Line 113 | Line 122 | typedef struct {
122  
123   /* Loaded BSDF data */
124   typedef struct {
125 <        char            name[SDnameLn]; /* BSDF name (derived from file) */
125 >        char            name[SDnameLn]; /* BSDF name (usu. derived from file) */
126 >        char            matn[SDnameLn]; /* material name */
127 >        char            makr[SDnameLn]; /* manufacturer */
128          char            *mgf;           /* geometric description (if any) */
129          float           dim[3];         /* width, height, thickness (meters) */
130          SDValue         rLambFront;     /* diffuse front reflectance */
131          SDValue         rLambBack;      /* diffuse rear reflectance */
132          SDValue         tLamb;          /* diffuse transmission */
133 <        SDSpectralDF    *rf, *rb, *tf;  /* non-diffuse BSDF components */
133 >        SDSpectralDF    *rf, *rb;       /* non-diffuse BRDF components */
134 >        SDSpectralDF    *tf, *tb;       /* non-diffuse BTDF components */
135   } SDData;
136  
137   /* List of loaded BSDFs */
# Line 130 | Line 142 | extern struct SDCache_s {
142                          *next;
143   } *SDcacheList;         /* Global BSDF cache */
144  
145 < /* BSDF cache retention preference */
146 < #define SDretainNone    0               /* free unreferenced data (default) */
147 < #define SDretainBSDFs   1               /* keep loaded BSDFs in cache */
145 > /* BSDF cache retention policies */
146 > #define SDretainNone    0               /* free unreferenced BSDF data */
147 > #define SDretainBSDFs   1               /* keep loaded BSDFs in memory */
148   #define SDretainAll     2               /* also keep cumulative cache data */
149  
150 < extern int              SDretainSet;    /* set to SDretainNone by default */
150 > extern int              SDretainSet;    /* =SDretainNone by default */
151  
152   /*****************************************************************
153   * The following routines are less commonly used by applications.
# Line 143 | Line 155 | extern int             SDretainSet;    /* set to SDretainNone by def
155  
156   #define SDisLoaded(sd)  ((sd)->rLambFront.spec.flags != 0)
157  
158 < /* Report an error to the indicated stream (in English) */
159 < extern SDError          SDreportEnglish(SDError ec, FILE *fp);
158 > /* Report an error to the indicated stream */
159 > extern SDError          SDreportError(SDError ec, FILE *fp);
160  
161   /* Shorten file path to useable BSDF name, removing suffix */
162   extern void             SDclipName(char res[SDnameLn], const char *fname);
# Line 152 | Line 164 | extern void            SDclipName(char res[SDnameLn], const char
164   /* Allocate new spectral distribution function */
165   extern SDSpectralDF     *SDnewSpectralDF(int nc);
166  
167 + /* Add component(s) to spectral distribution function */
168 + extern SDSpectralDF     *SDaddComponent(SDSpectralDF *odf, int nadd);
169 +
170   /* Free a spectral distribution function */
171   extern void             SDfreeSpectralDF(SDSpectralDF *df);
172  
# Line 171 | Line 186 | extern SDData          *SDgetCache(const char *bname);
186   extern void             SDfreeCumulativeCache(SDSpectralDF *df);
187  
188   /* Sample an individual BSDF component */
189 < extern SDError          SDsampComponent(SDValue *sv, FVECT outVec,
190 <                                        const FVECT inVec, double randX,
176 <                                        SDComponent *sdc);
189 > extern SDError          SDsampComponent(SDValue *sv, FVECT ioVec,
190 >                                        double randX, SDComponent *sdc);
191  
192   /* Convert 1-dimensional random variable to N-dimensional */
193   extern void             SDmultiSamp(double t[], int n, double randX);
194  
195   /* Map a [0,1]^2 square to a unit radius disk */
196 < void                    SDsquare2disk(double ds[2], double seedx, double seedy);
196 > extern void             SDsquare2disk(double ds[2], double seedx, double seedy);
197  
198   /* Map point on unit disk to a unit square in [0,1]^2 range */
199 < void                    SDdisk2square(double sq[2], double diskx, double disky);
199 > extern void             SDdisk2square(double sq[2], double diskx, double disky);
200  
201   /*****************************************************************
202   * The calls below are the ones most applications require.
# Line 190 | Line 204 | void                   SDdisk2square(double sq[2], double diskx, doubl
204   */
205  
206   /* Get BSDF from cache (or load and cache it on first call) */
207 < /* Report any problems to stderr and return NULL on failure */
207 > /* Report any problems to stderr, return NULL on failure */
208   extern const SDData     *SDcacheFile(const char *fname);
209  
210 < /* Free a BSDF from our cache (clear all if NULL) */
210 > /* Free a BSDF from our cache (clear all if sd==NULL) */
211   extern void             SDfreeCache(const SDData *sd);
212  
213   /* Query projected solid angle resolution for non-diffuse BSDF direction(s) */
# Line 210 | Line 224 | extern double          SDdirectHemi(const FVECT inVec,
224                                          int sflags, const SDData *sd);
225  
226   /* Sample BSDF direction based on the given random variable */
227 < extern SDError          SDsampBSDF(SDValue *sv, FVECT outVec,
214 <                                        const FVECT inVec, double randX,
227 > extern SDError          SDsampBSDF(SDValue *sv, FVECT ioVec, double randX,
228                                          int sflags, const SDData *sd);
229  
230   /*****************************************************************
# Line 219 | Line 232 | extern SDError         SDsampBSDF(SDValue *sv, FVECT outVec,
232   * Directions may be passed unnormalized to these routines.
233   */
234  
235 < /* Compute World->BSDF transform from surface normal and up (Y) vector */
235 > /* Compute World->BSDF transform from surface normal and BSDF up vector */
236   extern SDError          SDcompXform(RREAL vMtx[3][3], const FVECT sNrm,
237                                          const FVECT uVec);
238  
# Line 230 | Line 243 | extern SDError         SDinvXform(RREAL iMtx[3][3], RREAL vMt
243   extern SDError          SDmapDir(FVECT resVec, RREAL vMtx[3][3],
244                                          const FVECT inpVec);
245  
246 < /* System-specific BSDF loading routine (not part of our library) */
246 > /* Application-specific BSDF loading routine (not part of our library) */
247   extern SDData           *loadBSDF(char *name);
248  
249 < /* System-specific BSDF error translator (not part of our library) */
249 > /* Application-specific BSDF error translator (not part of our library) */
250   extern char             *transSDError(SDError ec);
238 –
239 – /*################################################################*/
240 – /*######### DEPRECATED DEFINITIONS AWAITING PERMANENT REMOVAL #######*/
241 – /*
242 – * Header for BSDF i/o and access routines
243 – */
244 –
245 – #include "mat4.h"
246 –                                /* up directions */
247 – typedef enum {
248 –        UDzneg=-3,
249 –        UDyneg=-2,
250 –        UDxneg=-1,
251 –        UDunknown=0,
252 –        UDxpos=1,
253 –        UDypos=2,
254 –        UDzpos=3
255 – } UpDir;
256 –                                /* BSDF coordinate calculation routines */
257 –                                /* vectors always point away from surface */
258 –
259 – typedef int     b_vecf2(FVECT v, int n, void *cd);
260 – typedef int     b_ndxf2(FVECT v, void *cd);
261 – typedef double  b_radf2(int n, void *cd);
262 –
263 – /* Bidirectional Scattering Distribution Function */
264 – struct BSDF_data {
265 –        int     ninc;                   /* number of incoming directions */
266 –        int     nout;                   /* number of outgoing directions */
267 –        float   dim[3];                 /* width, height, thickness (meters) */
268 –        char    *mgf;                   /* geometric description (if any) */
269 –        void    *ib_priv;               /* input basis private data */
270 –        b_vecf2 *ib_vec;                /* get input vector from index */
271 –        b_ndxf2 *ib_ndx;                /* get input index from vector */
272 –        b_radf2 *ib_ohm;                /* get input radius for index */
273 –        void    *ob_priv;               /* output basis private data */
274 –        b_vecf2 *ob_vec;                /* get output vector from index */
275 –        b_ndxf2 *ob_ndx;                /* get output index from vector */
276 –        b_radf2 *ob_ohm;                /* get output radius for index */
277 –        float   *bsdf;                  /* scattering distribution data */
278 – };                              /* bidirectional scattering distrib. func. */
279 –
280 – #define getBSDF_incvec(v,b,i)   (*(b)->ib_vec)(v,i,(b)->ib_priv)
281 – #define getBSDF_incndx(b,v)     (*(b)->ib_ndx)(v,(b)->ib_priv)
282 – #define getBSDF_incohm(b,i)     (*(b)->ib_ohm)(i,(b)->ib_priv)
283 – #define getBSDF_outvec(v,b,o)   (*(b)->ob_vec)(v,o,(b)->ob_priv)
284 – #define getBSDF_outndx(b,v)     (*(b)->ob_ndx)(v,(b)->ob_priv)
285 – #define getBSDF_outohm(b,o)     (*(b)->ob_ohm)(o,(b)->ob_priv)
286 – #define BSDF_value(b,i,o)       (b)->bsdf[(o)*(b)->ninc + (i)]
287 –
288 – extern struct BSDF_data *load_BSDF(char *fname);
289 – extern void free_BSDF(struct BSDF_data *b);
290 – extern int r_BSDF_incvec(FVECT v, struct BSDF_data *b, int i,
291 –                                double rv, MAT4 xm);
292 – extern int r_BSDF_outvec(FVECT v, struct BSDF_data *b, int o,
293 –                                double rv, MAT4 xm);
294 – extern int getBSDF_xfm(MAT4 xm, FVECT nrm, UpDir ud, char *xfbuf);
295 –
296 – /*######### END DEPRECATED DEFINITIONS #######*/
297 – /*################################################################*/
251  
252   #ifdef __cplusplus
253   }

Diff Legend

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