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.18 by greg, Mon Mar 5 00:17:06 2012 UTC vs.
Revision 2.30 by greg, Mon Dec 13 21:05:00 2021 UTC

# Line 25 | Line 25
25  
26   #include "fvect.h"
27   #include "ccolor.h"
28 + #include "platform.h"
29  
30   #ifdef __cplusplus
31   extern "C" {
32   #endif
33  
33 – #ifdef _WIN32
34 – #define strcasecmp      stricmp
35 – #endif
36 –
34   #define SDnameLn        128             /* maximum BSDF name length */
35   #define SDmaxCh         3               /* maximum # spectral channels */
36  
# Line 58 | Line 55 | extern "C" {
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 78 | Line 78 | typedef struct SDCDst_s {
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 < typedef const struct {
87 > typedef struct {
88                                          /* return non-diffuse BSDF */
89 <        int             (*getBSDFs)(float coef[SDmaxCh], const FVECT outVec,
90 <                                    const FVECT inVec, SDComponent *sdc);
89 >        int             (*getBSDFs)(float coef[SDmaxCh], const FVECT inVec,
90 >                                    const FVECT outVec, SDComponent *sdc);
91                                          /* query non-diffuse PSA for vector */
92          SDError         (*queryProjSA)(double *psa, const FVECT v1,
93                                                  const RREAL *v2, int qflags,
# Line 102 | Line 104 | typedef const struct {
104   /* Structure to hold a spectral BSDF component (typedef SDComponent above) */
105   struct SDComp_s {
106          C_COLOR         cspec[SDmaxCh]; /* component spectral bases */
107 <        SDFunc          *func;          /* methods for this component */
107 >        const SDFunc    *func;          /* methods for this component */
108          void            *dist;          /* loaded distribution data */
109          SDCDst          *cdList;        /* cumulative distribution cache */
110   };
# Line 121 | Line 123 | typedef struct {
123          char            matn[SDnameLn]; /* material name */
124          char            makr[SDnameLn]; /* manufacturer */
125          char            *mgf;           /* geometric description (if any) */
126 <        float           dim[3];         /* width, height, thickness (meters) */
126 >        double          dim[3];         /* width, height, thickness (meters) */
127          SDValue         rLambFront;     /* diffuse front reflectance */
128          SDValue         rLambBack;      /* diffuse rear reflectance */
129 <        SDValue         tLamb;          /* diffuse transmission */
130 <        SDSpectralDF    *rf, *rb, *tf;  /* non-diffuse BSDF components */
129 >        SDValue         tLambFront;     /* diffuse front transmittance */
130 >        SDValue         tLambBack;      /* diffuse back transmittance */
131 >        SDSpectralDF    *rf, *rb;       /* non-diffuse BRDF components */
132 >        SDSpectralDF    *tf, *tb;       /* non-diffuse BTDF components */
133   } SDData;
134  
135   /* List of loaded BSDFs */
# Line 142 | Line 146 | extern struct SDCache_s {
146   #define SDretainAll     2               /* also keep cumulative cache data */
147  
148   extern int              SDretainSet;    /* =SDretainNone by default */
149 + extern unsigned long    SDmaxCache;     /* =0 (unlimited) by default */
150  
151   /*****************************************************************
152   * The following routines are less commonly used by applications.
# Line 149 | Line 154 | extern int             SDretainSet;    /* =SDretainNone by default *
154  
155   #define SDisLoaded(sd)  ((sd)->rLambFront.spec.flags != 0)
156  
157 < /* Report an error to the indicated stream (in English) */
158 < extern SDError          SDreportEnglish(SDError ec, FILE *fp);
157 > /* Report an error to the indicated stream */
158 > extern SDError          SDreportError(SDError ec, FILE *fp);
159  
160   /* Shorten file path to useable BSDF name, removing suffix */
161   extern void             SDclipName(char res[SDnameLn], const char *fname);
# Line 186 | Line 191 | extern SDError         SDsampComponent(SDValue *sv, FVECT ioV
191   /* Convert 1-dimensional random variable to N-dimensional */
192   extern void             SDmultiSamp(double t[], int n, double randX);
193  
189 – /* Map a [0,1]^2 square to a unit radius disk */
190 – void                    SDsquare2disk(double ds[2], double seedx, double seedy);
191 –
192 – /* Map point on unit disk to a unit square in [0,1]^2 range */
193 – void                    SDdisk2square(double sq[2], double diskx, double disky);
194 –
194   /*****************************************************************
195   * The calls below are the ones most applications require.
196   * All directions are assumed to be unit vectors.
197   */
198  
199   /* Get BSDF from cache (or load and cache it on first call) */
200 < /* Report any problems to stderr (in English), return NULL on failure */
200 > /* Report any problems to stderr, return NULL on failure */
201   extern const SDData     *SDcacheFile(const char *fname);
202  
203   /* Free a BSDF from our cache (clear all if sd==NULL) */
# Line 210 | Line 209 | extern SDError         SDsizeBSDF(double *projSA, const FVECT
209                                          const SDData *sd);
210  
211   /* Return BSDF for the given incident and scattered ray vectors */
212 < extern SDError          SDevalBSDF(SDValue *sv, const FVECT outVec,
213 <                                        const FVECT inVec, const SDData *sd);
212 > extern SDError          SDevalBSDF(SDValue *sv, const FVECT inVec,
213 >                                        const FVECT outVec, const SDData *sd);
214  
215   /* Compute directional hemispherical scattering at given incident angle */
216   extern double           SDdirectHemi(const FVECT inVec,
# Line 242 | Line 241 | extern SDData          *loadBSDF(char *name);
241  
242   /* Application-specific BSDF error translator (not part of our library) */
243   extern char             *transSDError(SDError ec);
245 –
246 – /*################################################################*/
247 – /*######### DEPRECATED DEFINITIONS AWAITING PERMANENT REMOVAL #######*/
248 – /*
249 – * Header for BSDF i/o and access routines
250 – */
251 –
252 – #include "mat4.h"
253 –                                /* up directions */
254 – typedef enum {
255 –        UDzneg=-3,
256 –        UDyneg=-2,
257 –        UDxneg=-1,
258 –        UDunknown=0,
259 –        UDxpos=1,
260 –        UDypos=2,
261 –        UDzpos=3
262 – } UpDir;
263 –                                /* BSDF coordinate calculation routines */
264 –                                /* vectors always point away from surface */
265 –
266 – typedef int     b_vecf2(FVECT v, int n, void *cd);
267 – typedef int     b_ndxf2(FVECT v, void *cd);
268 – typedef double  b_radf2(int n, void *cd);
269 –
270 – /* Bidirectional Scattering Distribution Function */
271 – struct BSDF_data {
272 –        int     ninc;                   /* number of incoming directions */
273 –        int     nout;                   /* number of outgoing directions */
274 –        float   dim[3];                 /* width, height, thickness (meters) */
275 –        char    *mgf;                   /* geometric description (if any) */
276 –        void    *ib_priv;               /* input basis private data */
277 –        b_vecf2 *ib_vec;                /* get input vector from index */
278 –        b_ndxf2 *ib_ndx;                /* get input index from vector */
279 –        b_radf2 *ib_ohm;                /* get input radius for index */
280 –        void    *ob_priv;               /* output basis private data */
281 –        b_vecf2 *ob_vec;                /* get output vector from index */
282 –        b_ndxf2 *ob_ndx;                /* get output index from vector */
283 –        b_radf2 *ob_ohm;                /* get output radius for index */
284 –        float   *bsdf;                  /* scattering distribution data */
285 – };                              /* bidirectional scattering distrib. func. */
286 –
287 – #define getBSDF_incvec(v,b,i)   (*(b)->ib_vec)(v,i,(b)->ib_priv)
288 – #define getBSDF_incndx(b,v)     (*(b)->ib_ndx)(v,(b)->ib_priv)
289 – #define getBSDF_incohm(b,i)     (*(b)->ib_ohm)(i,(b)->ib_priv)
290 – #define getBSDF_outvec(v,b,o)   (*(b)->ob_vec)(v,o,(b)->ob_priv)
291 – #define getBSDF_outndx(b,v)     (*(b)->ob_ndx)(v,(b)->ob_priv)
292 – #define getBSDF_outohm(b,o)     (*(b)->ob_ohm)(o,(b)->ob_priv)
293 – #define BSDF_value(b,i,o)       (b)->bsdf[(o)*(b)->ninc + (i)]
294 –
295 – extern struct BSDF_data *load_BSDF(char *fname);
296 – extern void free_BSDF(struct BSDF_data *b);
297 – extern int r_BSDF_incvec(FVECT v, struct BSDF_data *b, int i,
298 –                                double rv, MAT4 xm);
299 – extern int r_BSDF_outvec(FVECT v, struct BSDF_data *b, int o,
300 –                                double rv, MAT4 xm);
301 – extern int getBSDF_xfm(MAT4 xm, FVECT nrm, UpDir ud, char *xfbuf);
302 –
303 – /*######### END DEPRECATED DEFINITIONS #######*/
304 – /*################################################################*/
244  
245   #ifdef __cplusplus
246   }

Diff Legend

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