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.4 by greg, Fri Feb 18 00:40:25 2011 UTC vs.
Revision 2.25 by schorsch, Fri Jan 5 20:15:50 2018 UTC

# Line 9 | Line 9
9   *      in the surface plane pointed to the right as seen from the front.
10   *      This means the Y-axis is "up" and the Z-axis is the surface normal.
11   *
12 < *  BSDF vectors always oriented away from surface, even when "incident."
12 > *  Note that we reverse the identification of "front" and "back" from
13 > *      the conventions used in WINDOW 6.  "Front" in our library points
14 > *      in the +Z direction, towards the interior of the space rather
15 > *      than the exterior.
16   *
17 + *  BSDF incident & exiting vectors are always oriented away from surface.
18 + *
19   *  Created by Greg Ward on 1/10/11.
20   *
21   */
# Line 20 | Line 25
25  
26   #include "fvect.h"
27   #include "ccolor.h"
28 + #include "platform.h"
29  
30   #ifdef __cplusplus
31   extern "C" {
# Line 28 | Line 34 | extern "C" {
34   #define SDnameLn        128             /* maximum BSDF name length */
35   #define SDmaxCh         3               /* maximum # spectral channels */
36  
37 < /* Component flags for SDsampBSDF() and SDhemiScatter() */
37 > /* Component flags for SDsampBSDF() and SDdirectHemi() */
38   #define SDsampR         0x1             /* include reflection */
39   #define SDsampT         0x2             /* include transmission */
40   #define SDsampS         0x3             /* include scattering (R+T) */
# Line 39 | Line 45 | extern "C" {
45   #define SDsampSpS       0x7             /* include non-diffuse scattering */
46   #define SDsampAll       0xF             /* include everything */
47  
48 < /* Projected solid angle query flags fos SDsizeBSDF() */
49 < #define SDqueryInc      0x1             /* query incoming vector */
50 < #define SDqueryOut      0x2             /* query outgoing vector */
51 < #define SDqueryMin      0x4             /* query minimum proj. solid angle */
46 < #define SDqueryMax      0x8             /* query maximum proj. solid angle */
48 > /* Projected solid angle query flags for SDsizeBSDF() */
49 > #define SDqueryVal      0x0             /* query single value */
50 > #define SDqueryMin      0x1             /* query minimum proj. solid angle */
51 > #define SDqueryMax      0x2             /* query maximum proj. solid angle */
52  
53   /* Error codes: normal return, out of memory, file i/o, file format, bad argument,
54                   bad data, unsupported feature, internal error, unknown error */
55   typedef enum {SDEnone=0, SDEmemory, SDEfile, SDEformat, SDEargument,
56                  SDEdata, SDEsupport, SDEinternal, SDEunknown} SDError;
57  
58 < /* English ASCII strings corresponding to ennumerated errors */
58 > /* English strings corresponding to ennumerated errors */
59   extern const char       *SDerrorEnglish[];
60  
61 < /* Additional information on last error (ASCII English) */
61 > /* Pointer to error list in preferred language */
62 > extern const char       **SDerrorList;
63 >
64 > /* Additional information on last error (generally in English) */
65   extern char             SDerrorDetail[];
66  
67   /* Holder for BSDF value and spectral color */
# Line 63 | 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  
81 + extern const SDCDst     SDemptyCD;      /* empty distribution */
82 +
83   /* Forward declaration of BSDF component */
84   typedef struct SDComp_s SDComponent;
85  
86   /* Methods needed to handle BSDF components (nothing is optional) */
87 + #ifdef __cplusplus
88 + /* in C++, the const puts the type into the local anonymous namespace,
89 +   making it a private (and different) type for each file using this header.
90 + */
91 + typedef struct {
92 + #else
93   typedef const struct {
94 + #endif
95                                          /* return non-diffuse BSDF */
96          int             (*getBSDFs)(float coef[SDmaxCh], const FVECT outVec,
97 <                                    const FVECT inVec, const void *dist);
97 >                                    const FVECT inVec, SDComponent *sdc);
98                                          /* query non-diffuse PSA for vector */
99 <        SDError         (*queryProjSA)(double *psa, const FVECT vec,
100 <                                                int qflags, const void *dist);
99 >        SDError         (*queryProjSA)(double *psa, const FVECT v1,
100 >                                                const RREAL *v2, int qflags,
101 >                                                SDComponent *sdc);
102                                          /* get cumulative distribution */
103          const SDCDst    *(*getCDist)(const FVECT inVec, SDComponent *sdc);
104                                          /* sample cumulative distribution */
105 <        SDError         (*sampCDist)(FVECT outVec, double randX,
105 >        SDError         (*sampCDist)(FVECT ioVec, double randX,
106                                                  const SDCDst *cdp);
107                                          /* free a spectral BSDF component */
108          void            (*freeSC)(void *dist);
# Line 108 | Line 126 | typedef struct {
126  
127   /* Loaded BSDF data */
128   typedef struct {
129 <        char            name[SDnameLn]; /* BSDF name (derived from file) */
129 >        char            name[SDnameLn]; /* BSDF name (usu. derived from file) */
130 >        char            matn[SDnameLn]; /* material name */
131 >        char            makr[SDnameLn]; /* manufacturer */
132          char            *mgf;           /* geometric description (if any) */
133 <        float           dim[3];         /* width, height, thickness (meters) */
133 >        double          dim[3];         /* width, height, thickness (meters) */
134          SDValue         rLambFront;     /* diffuse front reflectance */
135          SDValue         rLambBack;      /* diffuse rear reflectance */
136          SDValue         tLamb;          /* diffuse transmission */
137 <        SDSpectralDF    *rf, *rb, *tf;  /* non-diffuse BSDF components */
137 >        SDSpectralDF    *rf, *rb;       /* non-diffuse BRDF components */
138 >        SDSpectralDF    *tf, *tb;       /* non-diffuse BTDF components */
139   } SDData;
140  
141   /* List of loaded BSDFs */
# Line 125 | Line 146 | extern struct SDCache_s {
146                          *next;
147   } *SDcacheList;         /* Global BSDF cache */
148  
149 < /* BSDF cache retention preference */
150 < #define SDretainNone    0               /* free unreferenced data (default) */
151 < #define SDretainBSDFs   1               /* keep loaded BSDFs in cache */
149 > /* BSDF cache retention policies */
150 > #define SDretainNone    0               /* free unreferenced BSDF data */
151 > #define SDretainBSDFs   1               /* keep loaded BSDFs in memory */
152   #define SDretainAll     2               /* also keep cumulative cache data */
153  
154 < extern int              SDretainSet;    /* set to SDretainNone by default */
154 > extern int              SDretainSet;    /* =SDretainNone by default */
155  
156   /*****************************************************************
157   * The following routines are less commonly used by applications.
158   */
159  
160 < #define SDisLoaded(sd)  ((sd)->rLambFront.spec.clock != 0)
160 > #define SDisLoaded(sd)  ((sd)->rLambFront.spec.flags != 0)
161  
162 < /* Report an error to the indicated stream (in English) */
163 < extern SDError          SDreportEnglish(SDError ec, FILE *fp);
162 > /* Report an error to the indicated stream */
163 > extern SDError          SDreportError(SDError ec, FILE *fp);
164  
165   /* Shorten file path to useable BSDF name, removing suffix */
166   extern void             SDclipName(char res[SDnameLn], const char *fname);
# Line 147 | Line 168 | extern void            SDclipName(char res[SDnameLn], const char
168   /* Allocate new spectral distribution function */
169   extern SDSpectralDF     *SDnewSpectralDF(int nc);
170  
171 + /* Add component(s) to spectral distribution function */
172 + extern SDSpectralDF     *SDaddComponent(SDSpectralDF *odf, int nadd);
173 +
174   /* Free a spectral distribution function */
175   extern void             SDfreeSpectralDF(SDSpectralDF *df);
176  
177 < /* Initialize an unused BSDF struct (clears to zeroes) */
178 < extern void             SDclearBSDF(SDData *sd);
177 > /* Initialize an unused BSDF struct and assign name (calls SDclipName) */
178 > extern void             SDclearBSDF(SDData *sd, const char *fname);
179  
180   /* Load a BSDF struct from the given file (keeps name unchanged) */
181   extern SDError          SDloadFile(SDData *sd, const char *fname);
# Line 166 | Line 190 | extern SDData          *SDgetCache(const char *bname);
190   extern void             SDfreeCumulativeCache(SDSpectralDF *df);
191  
192   /* Sample an individual BSDF component */
193 < extern SDError          SDsampComponent(SDValue *sv, FVECT outVec,
194 <                                        const FVECT inVec, double randX,
171 <                                        SDComponent *sdc);
193 > extern SDError          SDsampComponent(SDValue *sv, FVECT ioVec,
194 >                                        double randX, SDComponent *sdc);
195  
196   /* Convert 1-dimensional random variable to N-dimensional */
197   extern void             SDmultiSamp(double t[], int n, double randX);
198  
199   /* Map a [0,1]^2 square to a unit radius disk */
200 < void                    SDsquare2disk(double ds[2], double seedx, double seedy);
200 > extern void             SDsquare2disk(double ds[2], double seedx, double seedy);
201  
202   /* Map point on unit disk to a unit square in [0,1]^2 range */
203 < void                    SDdisk2square(double sq[2], double diskx, double disky);
203 > extern void             SDdisk2square(double sq[2], double diskx, double disky);
204  
205   /*****************************************************************
206   * The calls below are the ones most applications require.
# Line 185 | Line 208 | void                   SDdisk2square(double sq[2], double diskx, doubl
208   */
209  
210   /* Get BSDF from cache (or load and cache it on first call) */
211 < /* Report any problems to stderr and return NULL on failure */
211 > /* Report any problems to stderr, return NULL on failure */
212   extern const SDData     *SDcacheFile(const char *fname);
213  
214 < /* Free a BSDF from our cache (clear all if NULL) */
214 > /* Free a BSDF from our cache (clear all if sd==NULL) */
215   extern void             SDfreeCache(const SDData *sd);
216  
217 < /* Query projected solid angle resolution for non-diffuse BSDF direction */
218 < extern SDError          SDsizeBSDF(double *projSA, const FVECT vec,
219 <                                        int qflags, const SDData *sd);
217 > /* Query projected solid angle resolution for non-diffuse BSDF direction(s) */
218 > extern SDError          SDsizeBSDF(double *projSA, const FVECT v1,
219 >                                        const RREAL *v2, int qflags,
220 >                                        const SDData *sd);
221  
222   /* Return BSDF for the given incident and scattered ray vectors */
223   extern SDError          SDevalBSDF(SDValue *sv, const FVECT outVec,
# Line 204 | Line 228 | extern double          SDdirectHemi(const FVECT inVec,
228                                          int sflags, const SDData *sd);
229  
230   /* Sample BSDF direction based on the given random variable */
231 < extern SDError          SDsampBSDF(SDValue *sv, FVECT outVec,
208 <                                        const FVECT inVec, double randX,
231 > extern SDError          SDsampBSDF(SDValue *sv, FVECT ioVec, double randX,
232                                          int sflags, const SDData *sd);
233  
234   /*****************************************************************
# Line 213 | Line 236 | extern SDError         SDsampBSDF(SDValue *sv, FVECT outVec,
236   * Directions may be passed unnormalized to these routines.
237   */
238  
239 < /* Compute World->BSDF transform from surface normal and up (Y) vector */
239 > /* Compute World->BSDF transform from surface normal and BSDF up vector */
240   extern SDError          SDcompXform(RREAL vMtx[3][3], const FVECT sNrm,
241                                          const FVECT uVec);
242  
# Line 224 | Line 247 | extern SDError         SDinvXform(RREAL iMtx[3][3], RREAL vMt
247   extern SDError          SDmapDir(FVECT resVec, RREAL vMtx[3][3],
248                                          const FVECT inpVec);
249  
250 < /*################################################################*/
251 < /*######### DEPRECATED DEFINITIONS AWAITING PERMANENT REMOVAL #######*/
229 < /*
230 < * Header for BSDF i/o and access routines
231 < */
250 > /* Application-specific BSDF loading routine (not part of our library) */
251 > extern SDData           *loadBSDF(char *name);
252  
253 < #include "mat4.h"
254 <                                /* up directions */
235 < typedef enum {
236 <        UDzneg=-3,
237 <        UDyneg=-2,
238 <        UDxneg=-1,
239 <        UDunknown=0,
240 <        UDxpos=1,
241 <        UDypos=2,
242 <        UDzpos=3
243 < } UpDir;
244 <                                /* BSDF coordinate calculation routines */
245 <                                /* vectors always point away from surface */
246 <
247 < typedef int     b_vecf2(FVECT v, int n, void *cd);
248 < typedef int     b_ndxf2(FVECT v, void *cd);
249 < typedef double  b_radf2(int n, void *cd);
250 <
251 < /* Bidirectional Scattering Distribution Function */
252 < struct BSDF_data {
253 <        int     ninc;                   /* number of incoming directions */
254 <        int     nout;                   /* number of outgoing directions */
255 <        float   dim[3];                 /* width, height, thickness (meters) */
256 <        char    *mgf;                   /* geometric description (if any) */
257 <        void    *ib_priv;               /* input basis private data */
258 <        b_vecf2 *ib_vec;                /* get input vector from index */
259 <        b_ndxf2 *ib_ndx;                /* get input index from vector */
260 <        b_radf2 *ib_ohm;                /* get input radius for index */
261 <        void    *ob_priv;               /* output basis private data */
262 <        b_vecf2 *ob_vec;                /* get output vector from index */
263 <        b_ndxf2 *ob_ndx;                /* get output index from vector */
264 <        b_radf2 *ob_ohm;                /* get output radius for index */
265 <        float   *bsdf;                  /* scattering distribution data */
266 < };                              /* bidirectional scattering distrib. func. */
267 <
268 < #define getBSDF_incvec(v,b,i)   (*(b)->ib_vec)(v,i,(b)->ib_priv)
269 < #define getBSDF_incndx(b,v)     (*(b)->ib_ndx)(v,(b)->ib_priv)
270 < #define getBSDF_incohm(b,i)     (*(b)->ib_ohm)(i,(b)->ib_priv)
271 < #define getBSDF_outvec(v,b,o)   (*(b)->ob_vec)(v,o,(b)->ob_priv)
272 < #define getBSDF_outndx(b,v)     (*(b)->ob_ndx)(v,(b)->ob_priv)
273 < #define getBSDF_outohm(b,o)     (*(b)->ob_ohm)(o,(b)->ob_priv)
274 < #define BSDF_value(b,i,o)       (b)->bsdf[(o)*(b)->ninc + (i)]
275 <
276 < extern struct BSDF_data *load_BSDF(char *fname);
277 < extern void free_BSDF(struct BSDF_data *b);
278 < extern int r_BSDF_incvec(FVECT v, struct BSDF_data *b, int i,
279 <                                double rv, MAT4 xm);
280 < extern int r_BSDF_outvec(FVECT v, struct BSDF_data *b, int o,
281 <                                double rv, MAT4 xm);
282 < extern int getBSDF_xfm(MAT4 xm, FVECT nrm, UpDir ud, char *xfbuf);
283 <
284 < /*######### END DEPRECATED DEFINITIONS #######*/
285 < /*################################################################*/
253 > /* Application-specific BSDF error translator (not part of our library) */
254 > extern char             *transSDError(SDError ec);
255  
256   #ifdef __cplusplus
257   }

Diff Legend

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