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.7 by greg, Sat Feb 19 23:42:09 2011 UTC vs.
Revision 2.31 by greg, Sat Jun 7 05:09:45 2025 UTC

# Line 3 | Line 3
3   *  bsdf.h
4   *  
5   *  Declarations for bidirectional scattering distribution functions.
6 – *  Assumes <stdio.h> already included.
6   *
7   *  A material is oriented in right-hand coordinate system with X-axis
8   *      in the surface plane pointed to the right as seen from the front.
9   *      This means the Y-axis is "up" and the Z-axis is the surface normal.
10   *
11 < *  BSDF vectors always oriented away from surface, even when "incident."
11 > *  Note that we reverse the identification of "front" and "back" from
12 > *      the conventions used in WINDOW 6.  "Front" in our library points
13 > *      in the +Z direction, towards the interior of the space rather
14 > *      than the exterior.
15   *
16 + *  BSDF incident & exiting vectors are always oriented away from surface.
17 + *
18   *  Created by Greg Ward on 1/10/11.
19   *
20   */
# Line 18 | Line 22
22   #ifndef _BSDF_H_
23   #define _BSDF_H_
24  
25 + #include "platform.h"
26   #include "fvect.h"
27   #include "ccolor.h"
28  
# Line 28 | Line 33 | extern "C" {
33   #define SDnameLn        128             /* maximum BSDF name length */
34   #define SDmaxCh         3               /* maximum # spectral channels */
35  
36 < /* Component flags for SDsampBSDF() and SDhemiScatter() */
36 > /* Component flags for SDsampBSDF() and SDdirectHemi() */
37   #define SDsampR         0x1             /* include reflection */
38   #define SDsampT         0x2             /* include transmission */
39   #define SDsampS         0x3             /* include scattering (R+T) */
# Line 39 | Line 44 | extern "C" {
44   #define SDsampSpS       0x7             /* include non-diffuse scattering */
45   #define SDsampAll       0xF             /* include everything */
46  
47 < /* Projected solid angle query flags fos SDsizeBSDF() */
47 > /* Projected solid angle query flags for SDsizeBSDF() */
48   #define SDqueryVal      0x0             /* query single value */
49   #define SDqueryMin      0x1             /* query minimum proj. solid angle */
50   #define SDqueryMax      0x2             /* query maximum proj. solid angle */
# Line 49 | Line 54 | extern "C" {
54   typedef enum {SDEnone=0, SDEmemory, SDEfile, SDEformat, SDEargument,
55                  SDEdata, SDEsupport, SDEinternal, SDEunknown} SDError;
56  
57 < /* English ASCII strings corresponding to ennumerated errors */
57 > /* English strings corresponding to ennumerated errors */
58   extern const char       *SDerrorEnglish[];
59  
60 < /* Additional information on last error (ASCII English) */
60 > /* Pointer to error list in preferred language */
61 > extern const char       **SDerrorList;
62 >
63 > /* Additional information on last error (generally in English) */
64   extern char             SDerrorDetail[];
65  
66   /* Holder for BSDF value and spectral color */
# Line 62 | Line 70 | typedef struct {
70   } SDValue;
71  
72   /* Cached, encoded, cumulative distribution for one incident (solid) angle */
73 < #define SD_CDIST_BASE   double          cTotal; \
74 <                        struct SDCDst_s *next
73 > #define SD_CDIST_BASE(styp)     double          cTotal; \
74 >                                struct styp     *next
75   typedef struct SDCDst_s {
76 <        SD_CDIST_BASE;                  /* base fields first */
76 >        SD_CDIST_BASE(SDCDst_s);        /* base fields first */
77          /* ...encoded distribution extends struct */
78   } SDCDst;
79  
80 + extern const SDCDst     SDemptyCD;      /* empty distribution */
81 +
82   /* Forward declaration of BSDF component */
83   typedef struct SDComp_s SDComponent;
84  
85   /* Methods needed to handle BSDF components (nothing is optional) */
86 < typedef const struct {
86 > typedef struct {
87                                          /* return non-diffuse BSDF */
88 <        int             (*getBSDFs)(float coef[SDmaxCh], const FVECT outVec,
89 <                                    const FVECT inVec, const void *dist);
88 >        int             (*getBSDFs)(float coef[SDmaxCh], const FVECT inVec,
89 >                                    const FVECT outVec, SDComponent *sdc);
90                                          /* query non-diffuse PSA for vector */
91 <        SDError         (*queryProjSA)(double *psa, const FVECT vec,
92 <                                                int qflags, const void *dist);
91 >        SDError         (*queryProjSA)(double *psa, const FVECT v1,
92 >                                                const RREAL *v2, int qflags,
93 >                                                SDComponent *sdc);
94                                          /* get cumulative distribution */
95          const SDCDst    *(*getCDist)(const FVECT inVec, SDComponent *sdc);
96                                          /* sample cumulative distribution */
97 <        SDError         (*sampCDist)(FVECT outVec, double randX,
97 >        SDError         (*sampCDist)(FVECT ioVec, double randX,
98                                                  const SDCDst *cdp);
99                                          /* free a spectral BSDF component */
100          void            (*freeSC)(void *dist);
# Line 92 | Line 103 | typedef const struct {
103   /* Structure to hold a spectral BSDF component (typedef SDComponent above) */
104   struct SDComp_s {
105          C_COLOR         cspec[SDmaxCh]; /* component spectral bases */
106 <        SDFunc          *func;          /* methods for this component */
106 >        const SDFunc    *func;          /* methods for this component */
107          void            *dist;          /* loaded distribution data */
108          SDCDst          *cdList;        /* cumulative distribution cache */
109   };
# Line 107 | Line 118 | typedef struct {
118  
119   /* Loaded BSDF data */
120   typedef struct {
121 <        char            name[SDnameLn]; /* BSDF name (derived from file) */
121 >        char            name[SDnameLn]; /* BSDF name (usu. derived from file) */
122 >        char            matn[SDnameLn]; /* material name */
123 >        char            makr[SDnameLn]; /* manufacturer */
124          char            *mgf;           /* geometric description (if any) */
125 <        float           dim[3];         /* width, height, thickness (meters) */
125 >        double          dim[3];         /* width, height, thickness (meters) */
126          SDValue         rLambFront;     /* diffuse front reflectance */
127          SDValue         rLambBack;      /* diffuse rear reflectance */
128 <        SDValue         tLamb;          /* diffuse transmission */
129 <        SDSpectralDF    *rf, *rb, *tf;  /* non-diffuse BSDF components */
128 >        SDValue         tLambFront;     /* diffuse front transmittance */
129 >        SDValue         tLambBack;      /* diffuse back transmittance */
130 >        SDSpectralDF    *rf, *rb;       /* non-diffuse BRDF components */
131 >        SDSpectralDF    *tf, *tb;       /* non-diffuse BTDF components */
132   } SDData;
133  
134   /* List of loaded BSDFs */
# Line 124 | Line 139 | extern struct SDCache_s {
139                          *next;
140   } *SDcacheList;         /* Global BSDF cache */
141  
142 < /* BSDF cache retention preference */
143 < #define SDretainNone    0               /* free unreferenced data (default) */
144 < #define SDretainBSDFs   1               /* keep loaded BSDFs in cache */
142 > /* BSDF cache retention policies */
143 > #define SDretainNone    0               /* free unreferenced BSDF data */
144 > #define SDretainBSDFs   1               /* keep loaded BSDFs in memory */
145   #define SDretainAll     2               /* also keep cumulative cache data */
146  
147 < extern int              SDretainSet;    /* set to SDretainNone by default */
147 > extern int              SDretainSet;    /* =SDretainNone by default */
148 > extern unsigned long    SDmaxCache;     /* =0 (unlimited) by default */
149  
150   /*****************************************************************
151   * The following routines are less commonly used by applications.
# Line 137 | Line 153 | extern int             SDretainSet;    /* set to SDretainNone by def
153  
154   #define SDisLoaded(sd)  ((sd)->rLambFront.spec.flags != 0)
155  
156 < /* Report an error to the indicated stream (in English) */
157 < extern SDError          SDreportEnglish(SDError ec, FILE *fp);
156 > /* Report an error to the indicated stream */
157 > extern SDError          SDreportError(SDError ec, FILE *fp);
158  
159   /* Shorten file path to useable BSDF name, removing suffix */
160   extern void             SDclipName(char res[SDnameLn], const char *fname);
# Line 146 | Line 162 | extern void            SDclipName(char res[SDnameLn], const char
162   /* Allocate new spectral distribution function */
163   extern SDSpectralDF     *SDnewSpectralDF(int nc);
164  
165 + /* Add component(s) to spectral distribution function */
166 + extern SDSpectralDF     *SDaddComponent(SDSpectralDF *odf, int nadd);
167 +
168   /* Free a spectral distribution function */
169   extern void             SDfreeSpectralDF(SDSpectralDF *df);
170  
171 < /* Initialize an unused BSDF struct (clears to zeroes) */
172 < extern void             SDclearBSDF(SDData *sd);
171 > /* Initialize an unused BSDF struct and assign name (calls SDclipName) */
172 > extern void             SDclearBSDF(SDData *sd, const char *fname);
173  
174   /* Load a BSDF struct from the given file (keeps name unchanged) */
175   extern SDError          SDloadFile(SDData *sd, const char *fname);
# Line 165 | Line 184 | extern SDData          *SDgetCache(const char *bname);
184   extern void             SDfreeCumulativeCache(SDSpectralDF *df);
185  
186   /* Sample an individual BSDF component */
187 < extern SDError          SDsampComponent(SDValue *sv, FVECT outVec,
188 <                                        const FVECT inVec, double randX,
170 <                                        SDComponent *sdc);
187 > extern SDError          SDsampComponent(SDValue *sv, FVECT ioVec,
188 >                                        double randX, SDComponent *sdc);
189  
190   /* Convert 1-dimensional random variable to N-dimensional */
191   extern void             SDmultiSamp(double t[], int n, double randX);
192  
175 – /* Map a [0,1]^2 square to a unit radius disk */
176 – void                    SDsquare2disk(double ds[2], double seedx, double seedy);
177 –
178 – /* Map point on unit disk to a unit square in [0,1]^2 range */
179 – void                    SDdisk2square(double sq[2], double diskx, double disky);
180 –
193   /*****************************************************************
194   * The calls below are the ones most applications require.
195   * All directions are assumed to be unit vectors.
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, 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,
212 <                                        const FVECT inVec, const SDData *sd);
211 > extern SDError          SDevalBSDF(SDValue *sv, const FVECT inVec,
212 >                                        const FVECT outVec, const SDData *sd);
213  
214   /* Compute directional hemispherical scattering at given incident angle */
215   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,
207 <                                        const FVECT inVec, double randX,
219 > extern SDError          SDsampBSDF(SDValue *sv, FVECT ioVec, double randX,
220                                          int sflags, const SDData *sd);
221  
222   /*****************************************************************
# Line 212 | 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 223 | 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);
231 –
232 – /*################################################################*/
233 – /*######### DEPRECATED DEFINITIONS AWAITING PERMANENT REMOVAL #######*/
234 – /*
235 – * Header for BSDF i/o and access routines
236 – */
237 –
238 – #include "mat4.h"
239 –                                /* up directions */
240 – typedef enum {
241 –        UDzneg=-3,
242 –        UDyneg=-2,
243 –        UDxneg=-1,
244 –        UDunknown=0,
245 –        UDxpos=1,
246 –        UDypos=2,
247 –        UDzpos=3
248 – } UpDir;
249 –                                /* BSDF coordinate calculation routines */
250 –                                /* vectors always point away from surface */
251 –
252 – typedef int     b_vecf2(FVECT v, int n, void *cd);
253 – typedef int     b_ndxf2(FVECT v, void *cd);
254 – typedef double  b_radf2(int n, void *cd);
255 –
256 – /* Bidirectional Scattering Distribution Function */
257 – struct BSDF_data {
258 –        int     ninc;                   /* number of incoming directions */
259 –        int     nout;                   /* number of outgoing directions */
260 –        float   dim[3];                 /* width, height, thickness (meters) */
261 –        char    *mgf;                   /* geometric description (if any) */
262 –        void    *ib_priv;               /* input basis private data */
263 –        b_vecf2 *ib_vec;                /* get input vector from index */
264 –        b_ndxf2 *ib_ndx;                /* get input index from vector */
265 –        b_radf2 *ib_ohm;                /* get input radius for index */
266 –        void    *ob_priv;               /* output basis private data */
267 –        b_vecf2 *ob_vec;                /* get output vector from index */
268 –        b_ndxf2 *ob_ndx;                /* get output index from vector */
269 –        b_radf2 *ob_ohm;                /* get output radius for index */
270 –        float   *bsdf;                  /* scattering distribution data */
271 – };                              /* bidirectional scattering distrib. func. */
272 –
273 – #define getBSDF_incvec(v,b,i)   (*(b)->ib_vec)(v,i,(b)->ib_priv)
274 – #define getBSDF_incndx(b,v)     (*(b)->ib_ndx)(v,(b)->ib_priv)
275 – #define getBSDF_incohm(b,i)     (*(b)->ib_ohm)(i,(b)->ib_priv)
276 – #define getBSDF_outvec(v,b,o)   (*(b)->ob_vec)(v,o,(b)->ob_priv)
277 – #define getBSDF_outndx(b,v)     (*(b)->ob_ndx)(v,(b)->ob_priv)
278 – #define getBSDF_outohm(b,o)     (*(b)->ob_ohm)(o,(b)->ob_priv)
279 – #define BSDF_value(b,i,o)       (b)->bsdf[(o)*(b)->ninc + (i)]
280 –
281 – extern struct BSDF_data *load_BSDF(char *fname);
282 – extern void free_BSDF(struct BSDF_data *b);
283 – extern int r_BSDF_incvec(FVECT v, struct BSDF_data *b, int i,
284 –                                double rv, MAT4 xm);
285 – extern int r_BSDF_outvec(FVECT v, struct BSDF_data *b, int o,
286 –                                double rv, MAT4 xm);
287 – extern int getBSDF_xfm(MAT4 xm, FVECT nrm, UpDir ud, char *xfbuf);
288 –
289 – /*######### END DEPRECATED DEFINITIONS #######*/
290 – /*################################################################*/
243  
244   #ifdef __cplusplus
245   }

Diff Legend

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