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.15 by greg, Thu Jun 9 17:09:39 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.
# Line 23 | 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 30 | Line 30
30   extern "C" {
31   #endif
32  
33 – #ifdef _WIN32
34 – #define strcasecmp      stricmp
35 – #endif
36 –
33   #define SDnameLn        128             /* maximum BSDF name length */
34   #define SDmaxCh         3               /* maximum # spectral channels */
35  
# Line 58 | 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 71 | 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, SDComponent *sdc);
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 v1,
92                                                  const RREAL *v2, int qflags,
# Line 102 | 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 118 | Line 119 | typedef struct {
119   /* Loaded BSDF data */
120   typedef struct {
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 140 | Line 145 | extern struct SDCache_s {
145   #define SDretainAll     2               /* also keep cumulative cache data */
146  
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 147 | Line 153 | extern int             SDretainSet;    /* =SDretainNone by default *
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 156 | 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  
# Line 181 | Line 190 | extern SDError         SDsampComponent(SDValue *sv, FVECT ioV
190   /* Convert 1-dimensional random variable to N-dimensional */
191   extern void             SDmultiSamp(double t[], int n, double randX);
192  
184 – /* Map a [0,1]^2 square to a unit radius disk */
185 – void                    SDsquare2disk(double ds[2], double seedx, double seedy);
186 –
187 – /* Map point on unit disk to a unit square in [0,1]^2 range */
188 – void                    SDdisk2square(double sq[2], double diskx, double disky);
189 –
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 (in English), 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 sd==NULL) */
# Line 205 | Line 208 | extern SDError         SDsizeBSDF(double *projSA, const FVECT
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,
# Line 237 | Line 240 | extern SDData          *loadBSDF(char *name);
240  
241   /* Application-specific BSDF error translator (not part of our library) */
242   extern char             *transSDError(SDError ec);
240 –
241 – /*################################################################*/
242 – /*######### DEPRECATED DEFINITIONS AWAITING PERMANENT REMOVAL #######*/
243 – /*
244 – * Header for BSDF i/o and access routines
245 – */
246 –
247 – #include "mat4.h"
248 –                                /* up directions */
249 – typedef enum {
250 –        UDzneg=-3,
251 –        UDyneg=-2,
252 –        UDxneg=-1,
253 –        UDunknown=0,
254 –        UDxpos=1,
255 –        UDypos=2,
256 –        UDzpos=3
257 – } UpDir;
258 –                                /* BSDF coordinate calculation routines */
259 –                                /* vectors always point away from surface */
260 –
261 – typedef int     b_vecf2(FVECT v, int n, void *cd);
262 – typedef int     b_ndxf2(FVECT v, void *cd);
263 – typedef double  b_radf2(int n, void *cd);
264 –
265 – /* Bidirectional Scattering Distribution Function */
266 – struct BSDF_data {
267 –        int     ninc;                   /* number of incoming directions */
268 –        int     nout;                   /* number of outgoing directions */
269 –        float   dim[3];                 /* width, height, thickness (meters) */
270 –        char    *mgf;                   /* geometric description (if any) */
271 –        void    *ib_priv;               /* input basis private data */
272 –        b_vecf2 *ib_vec;                /* get input vector from index */
273 –        b_ndxf2 *ib_ndx;                /* get input index from vector */
274 –        b_radf2 *ib_ohm;                /* get input radius for index */
275 –        void    *ob_priv;               /* output basis private data */
276 –        b_vecf2 *ob_vec;                /* get output vector from index */
277 –        b_ndxf2 *ob_ndx;                /* get output index from vector */
278 –        b_radf2 *ob_ohm;                /* get output radius for index */
279 –        float   *bsdf;                  /* scattering distribution data */
280 – };                              /* bidirectional scattering distrib. func. */
281 –
282 – #define getBSDF_incvec(v,b,i)   (*(b)->ib_vec)(v,i,(b)->ib_priv)
283 – #define getBSDF_incndx(b,v)     (*(b)->ib_ndx)(v,(b)->ib_priv)
284 – #define getBSDF_incohm(b,i)     (*(b)->ib_ohm)(i,(b)->ib_priv)
285 – #define getBSDF_outvec(v,b,o)   (*(b)->ob_vec)(v,o,(b)->ob_priv)
286 – #define getBSDF_outndx(b,v)     (*(b)->ob_ndx)(v,(b)->ob_priv)
287 – #define getBSDF_outohm(b,o)     (*(b)->ob_ohm)(o,(b)->ob_priv)
288 – #define BSDF_value(b,i,o)       (b)->bsdf[(o)*(b)->ninc + (i)]
289 –
290 – extern struct BSDF_data *load_BSDF(char *fname);
291 – extern void free_BSDF(struct BSDF_data *b);
292 – extern int r_BSDF_incvec(FVECT v, struct BSDF_data *b, int i,
293 –                                double rv, MAT4 xm);
294 – extern int r_BSDF_outvec(FVECT v, struct BSDF_data *b, int o,
295 –                                double rv, MAT4 xm);
296 – extern int getBSDF_xfm(MAT4 xm, FVECT nrm, UpDir ud, char *xfbuf);
297 –
298 – /*######### END DEPRECATED DEFINITIONS #######*/
299 – /*################################################################*/
243  
244   #ifdef __cplusplus
245   }

Diff Legend

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